工程上來說如果要在類裡面添加一個“行為”, 可能要經過好多步編碼操作。
比如對於某一類A , update函數裡要調用一堆同類函數,這些函數還要初始化等等的操作.需要編寫大量代碼,對我等懶人來說真是麻煩死了。例如如下類A
A.h
1 class A
2 {
3 public:
4 A();
5 ~A();
6 void update();
7 private:
8 bool fun1();
9 bool fun2();
10 bool fun3();
11
12 void run(const string& s);
13 }
比如想在A中的update函數裡調用fun1()~funN(), 如果返回true則執行run:
?if(fun1()){ run("fun1"); } if(fun2()){ run("fun2"); } if(fun3()){ run("fun3"); }
當然你可以不厭其煩地寫N個類,每個類有fun和run 然後用基類+多態實現。這裡只說懶人用法。我在A裡添加一個vector,把所有function都遍歷一下就搞定了:
class A
{
public:
struct CALL{
function<bool(void)> func;
string name;
};
A();
~A();
void update();
private:
vector<CALL> cache;
bool fun1();
bool fun2();
bool fun3();
void run(const string& s);
}
1 A::A()
2 {
3 CALL f1,f2,f3;
4 f1.name = "fun1";
5 f2.name = "fun2";
6 f3.name = "fun3";
7
8 f1.func = bind(&A::fun1, this);
9 f2.func = bind(&A::fun2, this);
10 f3.func = bind(&A::fun3, this);
11 }
12
13 void A::update()
14 {
15 for(vector<CALL>::iterator itr = cache.begin(); itr != cache.end(); itr++)
16 {
17 if(itr->func()){
18 run(itr->name);
19 }
20 }
21 }
但是這樣一來,每次要新增一個funX就要寫兩行CALL結構初始化、還要在CLASS裡添加函數funX. 對我這種懶人來說代碼量還需要減少75%才願意動手。lambda表達式的優勢在這時體現出來了:
1 #include<vector>
2 #include<functional>
3 using namespace std;
4
5 class A
6 {
7 public:
8 struct CALL{
9 function<bool(void)> func;
10 string name;
11 };
12
13 A();
14 ~A();
15 void update();
16 private:
17
18 vector<CALL> cache;
19
20 void run(const string& s);
21 }
A::A()
{
CALL call[3];
int i;
for(i=0;i<3;++i)
{
char str[10];
sprintf(str, "fun%d", i+1);
call[i].name = string(str);
}
call[0] = [](){
bool ret
...;
return ret;
};
call[1] = [](){
bool ret
...;
return ret;
};
call[2] = [](){
bool ret
...;
return ret;
}
}
void A::update()
{
for(vector<CALl>::iterator itr = cache.begin(); itr != cache.end(); itr++)
{
if(itr->func()){
run(itr->name);
}
}
}
此後要加任何函數只要直接寫,不用繼承多態,俗語曰隨便搞。
優勢:代碼少、代碼即文檔、產品隨便加減需求、無效率問題
博客地址:http://www.cnblogs.com/cydonia/