C solution faible foncteur de

Question

Ceci est spécifique à annuler() foncteurs, mais qui est bien avec moi ...

struct Foo 
{ 
    void Bar(int x) 
    { 
     std::cout << x << std::endl; 
    } 
}; 

struct VoidBind 
{ 
    typedef void result_type; 

    template<typename T> void operator()(const std::weak_ptr<T>& obj, std::function<void()>& func) 
    { 
     std::shared_ptr<T> shared_obj = obj.lock(); 

     if (shared_obj) 
     { 
      func(); 
     } 
    } 

    template<typename T> static std::function<void()> bind(const std::shared_ptr<T>& obj, const std::function<void()>& func) 
    { 
     return std::bind(VoidBind(), std::weak_ptr<T>(obj), func); 
    } 
}; 

#define BIND(F, O, A...) VoidBind::bind(O, std::function<void()>(std::bind(F, O.get(), ##A))) 

Ce code est alors invoquée comme ...

auto obj = std::make_shared<Foo>(); 
auto func = BIND(&Foo::Bar, obj, 99); // match std::bind style 
func(); 
obj.reset(); // destroy object 
func();  // will not do anything 

Ma question est de savoir s'il existe un moyen d'éviter la macro BIND?

Answer 1

modèles VARIADIC peuvent être utilisés ici:

template<class F, class O, class... Args> 
auto bind(F f, O&& o, Args&&... args) 
    -> decltype(VoidBind::bind(o, std::function<void()>(std::bind(f, O.get(), args...)))) 
{ 
    return VoidBind::bind(O, std::function<void()>(std::bind(F, O.get(), args...))); 
} 

Il se bonifie avec C++ 14 déduction retour automatique de type où vous ne même pas besoin de spécifier la valeur de retour:

template<class F, class O, class... Args> 
auto bind(F f, O&& o, Args&&... args) 
{ 
    return VoidBind::bind(o, std::function<void()>(std::bind(f, O.get(), args...))); 
} 

Answer 2

Avez-vous envisagé d'utiliser des expressions lambda au lieu d'objets foncteurs - la même fonctionnalité, mais beaucoup plus compact, et avec la liaison dans le cadre de la déclaration de ce lambda.