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;
}
