boost::bind boost::function绑定万能函数测试2（类成员函数和虚函数）

#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <iostream>
#include <vector>


class CParameter
{
public:
CParameter() : m_StrInfo("CParameter")
{
m_VecInt.push_back(1);
m_VecInt.push_back(2);
m_VecInt.push_back(3);
}
~CParameter(){}


public:
const std::string m_StrInfo;
std::vector<int>  m_VecInt;
};


class CBase
{
public:
CBase(){}
virtual ~CBase(){}


public:
void testFunction0(const std::string& vParam0, double vParam1)
{
std::cout << "base testFunction0:" << vParam0 << std::ends << vParam1 << std::endl;
}
virtual void testFunction1(const CParameter& vParam0, const std::string& vParam1)
{
std::cout << "base testFunction1:" << vParam0.m_StrInfo << std::ends << vParam0.m_VecInt[0] << std::ends << vParam1 << std::endl;
}
};


class CDerive : public CBase
{
public:
CDerive(){}
virtual ~CDerive(){}


public:
virtual void testFunction1(const CParameter& vParam0, const std::string& vParam1)
{
std::cout << "derive testFunction1:" << vParam0.m_StrInfo << std::endl;
for(unsigned int i = 0; i < vParam0.m_VecInt.size(); ++i)
{
std::cout << vParam0.m_VecInt[i] << std::ends;
}
std::cout << std::endl << vParam1 << std::endl;
}
};


class CBindFunctor
{
public:
~CBindFunctor(){}


public:
static CBindFunctor* getInstance()
{
if(!m_pInstance)
{
m_pInstance = new CBindFunctor;
}
return m_pInstance;
}


public:
template <typename F, typename P0, typename P1, typename P2>
void excute(F vFuncAddress, P0 vParam0, P1 vParam1, P2 vParam2)
{
typedef boost::function<void(P0, P1, P2)> __functor;
__functor tmpFunctor;
tmpFunctor = boost::bind(vFuncAddress, _1, _2, _3);
tmpFunctor(vParam0, vParam1, vParam2);
}


private:
CBindFunctor(){}
CBindFunctor(const CBindFunctor&){}


private:
CBindFunctor& operator=(const CBindFunctor&){}


private:
static CBindFunctor *m_pInstance;
};


/* TEST_0
void function0(int vParam0, int vParam1)
{
std::cout << "function0:" << vParam0 << std::ends << vParam1 << std::endl; 
}


void function1(std::string vParam0, float vParam1)
{
std::cout << "function1:" << vParam0 << std::ends << vParam1 << std::endl;
}




template <typename FuncAddress, typename P0, typename P1>
void excute(FuncAddress vFuncAddress, P0 vParam0, P1 vParam1) 
{
typedef boost::function<void(P0, P1)> m_Functor; 
m_Functor functor;
functor = boost::bind(vFuncAddress, _1, _2);
functor(vParam0, vParam1);
}
TEST_0*/
CBindFunctor* CBindFunctor::m_pInstance = NULL;


int main(int argc, char **argv)
{
CBase base;
CDerive derive;
CParameter parameter;
std::string str("base test");
CBindFunctor::getInstance()->excute(&CBase::testFunction0, &base, str, 123); //must be reference for improving speed
CBindFunctor::getInstance()->excute(&CBase::testFunction1, &base, CParameter(), str);
str = "derive test";
CBindFunctor::getInstance()->excute(&CDerive::testFunction0, &derive, str, 321);
CBindFunctor::getInstance()->excute(&CDerive::testFunction1, &derive, parameter, str);
/*TEST_0
excute(&function0, 2, 1);
std::string Str("hello world");
excute(&function1, Str, 11.0f);
TEST_0*/
return 0;
}