C++对象行为的动态绑定

C++实现一个对象较为复杂的行为如果用最朴素的方法，即使用if...then...else..., switch...case...这样的语句来实现效果会是这样：

class B
{... 
public:
  void g(int id)
  {
    switch(id)
    {
    case 0: /* ... */ return;
    case 1: /* ... */ return;
    default: return;
    }
};

这样的实现方案显然不便于维护，当可能的分支很多时这个方法会导致程序逻辑难以阅读。

---

因此，在实际编程中，可以使用动态方法绑定的办法来实现这个功能：
所谓动态绑定，是指类型的实例动态保存一个回调函数（可以随时设置），在后续使用某个特定接口的时候调用该函数。这样的方法更加灵活，可以用相对简介清晰的形式构造复杂的行为。一种典型方式：定义一个函数列表或者函数字典，运行时根据某个状态参数直接从列表中查找回调函数，然后运行。

#include <iostream>
#include <map>

typedef std::string string;

class A
{
public:
    A():a1(1),a2(2),a3(3) {}
    typedef void (*func_t)(A&);
    void bind(const string& name, func_t func)
    {
        funcmap[name] = func;
    }

    void g(const string& name)
    {
        if(funcmap.find(name)!=funcmap.end())
        {
            return funcmap[name](*this);
        }else
        {
        // not found
            std::cout << "function_not_found" << std::endl;
        }
    }

    int a1,a2,a3;

private:
    std::map<string, func_t> funcmap;
};

int main(int argc, char* argv[])
{
    struct functions
    {
        static void g1(A& a) { std::cout << "function g1: a1 = " << a.a1 << std::endl; }
        static void g2(A& a) { std::cout << "function g2: a2 = " << a.a2 << std::endl; }
        static void g3(A& a) { std::cout << "function g3: a3 = " << a.a3 << std::endl; }
    };

    A a;
    
    a.bind("g1", &functions::g1);
    a.bind("g2", &functions::g2);
    a.bind("g3", &functions::g3);

    a.g("g1");
    a.g("g2");
    a.g("g3");
    a.g("wtf");
    return 0;
}

运行效果如下：

function g1: a1 = 1
function g2: a2 = 2
function g3: a3 = 3
function_not_found

从上述例子看出，我们甚至可以把实现隐藏在一些函数体内的函数（C++只支持函数体内定义结构体/类，然后再在里面定义函数，并以此作为回调函数；C语言可以在函数体内直接定义函数）这样可以更好的将某些独特的行为区别于常规行为，以免引起混乱或者理解上的困难。
这样的用法仍然要注意一些问题：

• 动态绑定既可以绑定普通函数，也可以绑定类的静态成员函数，也可以绑定普通成员函数；
• 绑定函数的时候要注意类的Access问题（成员的public/protected/private属性）；
  • 如果绑定的是成员函数，并且引用了private/protected成员，可以使用成员函数绑定（见例子）；
  • 绑定外部的friend函数/类的成员函数来操作该类的protected成员；
• 并不推荐使用绑定成员函数的方式
• 推荐使用绑定普通函数（兼容类的静态成员函数）的方式

设置器（setter）和获取器（getter）动态绑定成员函数的例子：

#include <iostream>

typedef std::string string;

class A
{
public:
    A():val(0),pval(&val),setter(&A::_set_inside){}
    ~A()
    {
    }

    typedef void(A::*setter_t)(int);
    typedef int(A::*getter_t)()const;
    void bind(setter_t _setter, getter_t _getter, int* _pval = nullptr)
    {
        setter = _setter;
        getter = _getter;
        if(_pval==nullptr)
        {
            pval = &val;
        }else
        {
            pval = _pval;
        }
    }

    void _set_inside(int _val) { val = _val; }
    void _set_extern(int _val) { (*pval) = _val; }
    int _get_inside() const { return val; }
    int _get_extern() const { return *pval; }
    
    void set(int _val)
    {
        (this->*setter)(_val);
    }
    int get() const
    {
        return (this->*getter)();
    }
private:
    setter_t setter;
    getter_t getter;
    int  val;
    int* pval;
};

int main(int argc, char* argv[])
{
    using namespace std;
    A a;
    a.bind(&A::_set_inside, &A::_get_inside);
    a.set(1);
    cout << "inside value: " << a.get() << endl;

    int extern_val = 2;
    a.bind(&A::_set_extern, &A::_get_extern, &extern_val);
    cout << "external value: " << a.get() << endl;

    return 0;
}