Hossein Haeri wrote:
Dear all,
Yep, again it's me, and it's agian function_traits<>...
AFAIK, std::iterator_traits<> is one of the counterparts of function_traits<>, not?
A sort of symmetry which iterator_traits<> has got is that it can work for Iterators as well as plain pointers.
That's the wrong way to think about it. It just works for iterators. Plain pointers just happen to be iterators, by the *standard's definition* of "iterator."
This seems to be not the case for function_traits<>. That is, you can pass a function type to it, but you can't do that for a functor. Is that right?
That's because function object types (what you're calling functors) are not functions by the standard's definition of "function."
If it is, a big drawback turns out to happen for variations of the following which are not that few common:
template < typename ..., ..., typename Function > struct Foo { typedef typename function_traits<Function> ::result_type result_type;
Foo (Function f) : f_(f) {}
//... result_type operator () () {/*..*/}
Function f_; };
It doesn't work because there's no way to code it in general. First of all there's no universal standard for a way to get the result type of a function object. Accessing a nested result_type sometimes works, but then, sometimes the operator() is overloaded, or even templated. You might look at boost::result_of for a more general solution. -- Dave Abrahams Boost Consulting http://www.boost-consulting.com