int main() { CallbackClass cb; // For functors with no arguments: std::list<ArFunctor*> functors; ArFunctorC<CallbackClass> functor1(cb, &CallbackClass::callback1); functors.push_back(&functor1); functors.push_back(&functor1); functors.push_back(&functor1); std::for_each(functors.begin(), functors.end(), std::mem_fun(&ArFunctor::invoke)); // For functors with arguments, give mem_fun template parameters. std::list<ArFunctor1<int>*> functorsWithArg; ArFunctor1C<CallbackClass, int> functor2(cb, &CallbackClass::callback2); std::mem_fun1_t<void, ArFunctor1<int>, int> f(&ArFunctor1<int>::invoke); functorsWithArg.push_back(&functor2); functorsWithArg.push_back(&functor2); functorsWithArg.push_back(&functor2); std::for_each(functorsWithArg.begin(), functorsWithArg.end(), std::bind2nd(f, 42)); // You can use other STL algorithms if your functor returns something. // count_if will invoke each functor, and return the number of functor // invocations that returned true (in this case, 3, since they will // always return true) std::list<ArRetFunctor1<bool, const char*>*> functorsWithRet; ArRetFunctor1C<bool, CallbackClass, const char *> functor3(cb, &CallbackClass::callback3); std::mem_fun1_t<bool, ArRetFunctor1<bool, const char*>, const char*> rf(&ArRetFunctor1<bool, const char*>::invokeR); functorsWithRet.push_back(&functor3); functorsWithRet.push_back(&functor3); functorsWithRet.push_back(&functor3); int c = std::count_if(functorsWithRet.begin(), functorsWithRet.end(), std::bind2nd(rf, "testing")); std::cout << "Count=" << c << std::endl; return(0); }
int main() { CallbackContainer cb; DriverClass driver; ArFunctorC<CallbackContainer> functor1(cb, &CallbackContainer::callback1); ArFunctor1C<CallbackContainer, int> functor2(cb, &CallbackContainer::callback2); ArRetFunctor1C<bool, CallbackContainer, const char *> functor3(cb, &CallbackContainer::callback3); driver.setCallback1(&functor1); driver.setCallback2(&functor2); driver.setCallback3(&functor3); driver.invokeFunctors(); /* You can make functors that target global functions too. */ ArGlobalFunctor globalFunctor(&globalCallback); printf("Invoking globalFunctor... "); globalFunctor.invoke(); /* You can also include the values of arguments in an ArFunctor object, if you * want to use the same value in every invocation of the functor. */ ArFunctor1C<CallbackContainer, int> functor4(cb, &CallbackContainer::callback2, 42); printf("Invoking functor with constant argument... "); functor4.invoke(); /* Functors can be downcast to parent interface classes, as long as their invocation * does not require arguments. */ ArFunctor* baseFunctor = &functor4; printf("Invoking downcast functor... "); baseFunctor->invoke(); return(0); }
int main() { /* etape 2 */ std::cout << "TEST operator =" << std::endl; Function<int (const char*)> functor; functor = &myTest; functor("test operator = : SUCCESS"); std::cout << "TEST constructor with assignation" << std::endl; Function<int (const char*)> functor2 = &myTest; functor("test constructor with assignation : SUCCESS"); std::cout << "TEST callable object" << std::endl; Callable1 call1; Function<void (char)> functor3 = &call1; functor3('a'); std::cout << "TEST boost::bind with function" << std::endl; Function<int (char)> functor4 = (boost::function<int (char)>)boost::bind(&boost_test, 'c'); functor4('a'); return 0; }