std::function 및 리셋 클래스

std::function은 c++11에서 제공하는 Callable 클래스이기 때문에 본 글은 function의 사용 방식을 정리하고 function을 바탕으로 리셋 클래스를 봉인했습니다.1. function의 사용

#include 
#include 
#include 

int add(int a, int b)
{
    return a + b;
}

class EchoMessage
{
public:
    void echoMessage(const string& msg)
    {
        std::cout << msg << std::endl;
    }
}

void test()
{
    //  
    function<int(int, int)> f_add = &add;
    int sum = f_add(1, 2);
    //  ， ；
    function<void(EchoMessage&, const string&)> f_echo = &EchoMessage::echoMessage;
    EchoMessage em;
    f_echo(em, "Hello");
    //  
    function<void(const string&)> f_echo1 = bind(&EchoMessage::echoMessage, em, placeholders::_1);
    f_echo1("Hello");
}

2. function 기반의 리셋 클래스는 대상 바늘과 구성원 함수 바늘을 리셋 유형의 구성원에 저장하고 어떤 실행 흐름에서 실행 구성원 함수 함수를 호출하면 함수의 리셋을 실현할 수 있다.상술한 사고방식에 근거하여muduo 라이브러리에서의 실현을 참고하여 리셋류에 대한 봉인은 다음과 같다.되돌아오는 함수의 되돌아오는 값은void입니다.

#include 
#include 
#include 

using namespace std;
template <typename Cls, typename... Args>
class WeakCallback
{
public:
    //  ， ， function ；
    using callable = function<void(Cls*, Args...)>;
    //  ， ， WeakCallback 
    WeakCallback(const weak_ptr& ptr_obj, const callable& cb)
    : ptr_obj_(ptr_obj),
    cb_(cb)
    {
    }

    //  
    void operator()(Args&&... args) 
    {
        //  shared_ptr， 
        shared_ptr ptr_obj(ptr_obj_.lock());
        if(ptr_obj)
        {
            cb_(ptr_obj.get(), std::forward(args)...);
        }
    }
private: 
    weak_ptr ptr_obj_;
    callable cb_;
};

template<typename CLASS, typename... ARGS>
WeakCallback makeWeakCallback(const shared_ptr& object, void (CLASS::*mem_func)(ARGS...))
{
  return WeakCallback(object, mem_func);
}

//  
struct Foo
{
public:
    Foo(int num) : num_(num) {}

    void printAdd(int a)
    {
        std::cout << "==printAdd: " << (num_ + a) << std::endl;
    }
private:
    int num_;
};

int main()
{
    shared_ptr ptr_foo(new Foo(5));
    auto wcb = makeWeakCallback(ptr_foo, &Foo::printAdd);
    wcb(5);

    return 0;
}

상기 코드의 가장 주요한 기능은 첫 번째 리셋 대상과 대상 구성원 함수가 호출될 때의 귀속을 실현하는 것이다. c++ 자체가 매개 변수 귀속 기능을 지원하기 때문에 다음과 같은 실현 방식이 있다.

template <typename Clz, typename... Args>
using BindedWeakCallback = function<void(Args...)>;

template<typename CLASS, typename... ARGS>
BindedWeakCallback makeWeakCallbackWithBind(const shared_ptr& object,
                                              void (CLASS::*mem_func)(ARGS...))
{
    return bind(mem_func, object.get(), placeholders::_1);
}

int main()
{
    shared_ptr ptr_foo(new Foo(5));
    auto wcb = makeWeakCallbackWithBind(ptr_foo, &Foo::printAdd);
    wcb(5);

    return 0;
}