Re: passing functor or function to template class

Many thanks for your suggestions; you are right, this avoids the code dupli=
cation caused by the specialization. But the price to pay is that now, the =
user of the interface has to provide the appropriate functionality to handl=
e noncopyable objects: The example below shows that everything is fine as l=
ong as the callable object is either a function or a copyable functor, but =
that (from the user's point of view) quite some hackery is required for non=
copyable functors.

Any ideas how this could be avoided, if possible not using more than tr1?

#include <iostream>
#include <tr1/functional>
// A function.
const char *function() {return "function\n";}
// A copyable functor.
struct CopyableFunctor {
    const char *operator()() {return "copyableFunctor\n";}
} copyableFunctor;
// A non-copyable functor.
struct NoncopyableFunctor {
    NoncopyableFunctor() {}
    const char *operator()() {return "noncopyableFunctor\n";}
  private:
    NoncopyableFunctor(const NoncopyableFunctor &);
} noncopyableFunctor;
// May be instantiated with either a function or a copyable functor.
template<typename T> struct Value {
    Value(T t):callable(t) {}
    T callable;
};
// Test if it works.
int main() {
    Value<const char *(*)()> f1(function);
    Value<CopyableFunctor> f2(copyableFunctor);
    // If the functor is non-copyable, the hackery below is required.
    Value<std::tr1::function<const char *()> > f3(std::tr1::ref(noncopyable=
Functor));
    std::cout << f1.callable();
    std::cout << f2.callable();
    std::cout << f3.callable();
    return 0;
}