function+bind实现多态（松耦合）

基类定义虚函数，子类实现虚函数，使用基类指针指向子类对象，从而实现多态，function+bind可以使没有任何关系的各种类对象及其行为以一种相同的行为表现出来，类似多态，高于多态，这里没有继承、没有指针、没有虚函数、松耦合…
将某类对象及其行为包装为模板类function的实例对象，或以模板函数bind将某类对象及其行为包装为模板类function的实例对象，定义包含模板类function的实例对象的Base类，使用Base类可以表现为多态性

元组tuple存储标准库function实例对象（ 包装各种类对象及其成员函数 ）、解包元组对象，链接点击这里

1、代码中的模板类func及模板函数bind_f是为了理解标准库里的工具库的包装类function及函数bind，本人所写

#include <iostream>
#include <tuple>  		//元组
						//std::make_index_sequence< >( )
						//std::tuple_size::value
 //A类
struct A{
	void f(int a, int b, double c) { std:: cout <<"A: a + b + c = " << a + b + c << "\n"; } 
};
//B类
struct B{
	void f(int a, int b) { std:: cout <<"B: a + b = " <<  a + b << "\n"; } 
};

//func模板类
template<typename T,typename...Args>
class func{
private:
	T a;                       //T类型对象
	void (T::*f)(Args...);	   //T类型对象的成员函数
	std::tuple<Args...> args;  //保存可变参数//保存T类型对象的成员函数的参数
	template<size_t...index>   //tuple解包//c++14
	void tuple_unpack(std::index_sequence<index... > ){ 
		(a.*f)( std::get<index>(args)... ); 
	}
public:	
	func( const T &a, void(T::*f)(Args...),Args...args ):a(a),f(f), args(args...) {  } //参数为对象、成员函数指针及可变参数的构造函数		
	void operator()(){ //重载 ()		
		tuple_unpack( std::make_index_sequence< std::tuple_size<decltype(args)>::value >( ) );
	} 	
};

//bind_f模板函数// 返回func模板类对象
template<typename T,typename...Args>
func<T,Args...> bind_f(const T &a, void(T::*f)(Args...),Args...args ){	
	return func<T,Args...>(a, f,args... ); //构造一个func对象
} 

//包含模板类func实例对象的Base类
struct Base{
	template<typename T>
	void fun(T&& t){  t();  }
};

int main(int, char *[] )
{
	Base base;
	A a;
	B b;
	//多态性//但A类、B类没有任何关系
	base.fun( bind_f(a, &A::f,5,9,1.23 ) ); // A类
	base.fun( bind_f(b, &B::f,5,6 ) );      // B类

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

2、代码使用标准库的function+bind

#include <iostream>
#include <functional>  	//function + bind//工具类标准库

 //A类
struct A{
	void f(int a, int b, double c) { std:: cout <<"A: a + b + c = " << a + b + c << "\n"; } 
};
//B类
struct B{
	void f(int a, int b) { std:: cout <<"B: a + b = " <<  a + b << "\n"; } 
};

//Base类
struct Base{
	template<typename T>
	void fun(T&& t){  t();  }
};

int main(int, char *[] )
{
	Base base;
	A a;
	B b;
	//多态性//但A类、B类没有任何关系
	base.fun( std::bind(&A::f,a, 5,9,1.23 ) ); // A类
	base.fun( std::bind(&B::f,b, 5,6) );       // B类

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30