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

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

将某类对象及其行为包装为模板类function的实例对象，或以模板函数bind将某类对象及其行为包装为模板类function的实例对象，定义包含模板类function的实例对象的Base类，使用Base类可以表现为多态性

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

目录

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

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

#include <iostream>
#include <tuple>  		//元组
						//std::make_index_sequence< >( )
						//std::tuple_size<decltype(args)>::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;
}

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