#include
#include
#include
class C
{
public:
C();
~C();
int my_temp;
void test();
};
C::C()
:my_temp(0)
{
printf("C构造函数n");
}
C::~C()
{
}
void C::test()
{
printf("C::testn");
}
namespace metasp
{
namespace net
{
//class C;
class B
{
public:
B(std::shared_ptrtmp,int tmp1);
virtual ~B();
virtual void test2()
{
printf("virtual void test2n");
}
std::shared_ptr pmyC;
//std::atomic mytmp1;
int mytmp1;
void test3()
{
printf("test3()n");
}
};
}
}
using namespace metasp::net;
using namespace std;
B::B(std::shared_ptrtmp,int tmp1)
:pmyC(new C()),
mytmp1(tmp1)
{
printf("B构造函数n");
pmyC->test();
printf("B::mytmp1 = %dn",(mytmp1));
printf("B::mytmp1 = %pn",(&B::mytmp1));//类的偏移地址
printf("this->mytmp2 = %dn",(this->mytmp1));
test3();
this->test3();
B::test3();
}
B::~B()
{
}
using NewCallback = std::function ;
using DefaultFunction = std::function;
class A : public metasp::net::B
{
public:
A(std::shared_ptrtmp,int tmp1);
~A();
void test2();
void test2(int a);
void Event1();
void Event2(int a);
void setFunc(const DefaultFunction func);
void setNewCallback( const NewCallback callback);
// std::shared_ptr pmyC;
DefaultFunction messageCallback;
NewCallback messageCallback1;
};
A::A(std::shared_ptrtmp,int tmp1)
:B(tmp,tmp1)
{
printf("A构造函数n");
pmyC->test();
this->setFunc(std::bind(&A::Event1,this));
this->setNewCallback(std::bind(&A::Event2,this,std::placeholders::_1));
}
A::~A()
{
}
void A::test2()
{
printf("A::test2n");
}
void A::test2(int a)
{
printf("A::test2(int a) a=%dn",a);
}
void A::setNewCallback( const NewCallback callback)
{
messageCallback1 = callback;
}
void A::setFunc(const DefaultFunction func)
{
messageCallback = func;
}
void A::Event1()
{
printf("A::Event1()n");
}
void A::Event2(int tmp)
{
printf("A::Event2() tmp = %dn",tmp);
}
int main(int argc, char** argv) {
std::shared_ptr pmyC;
int mytmp5 = 5;
A *pA = new A(pmyC,mytmp5);
pA->test2();
pA->test2(7);
pA->Event1();
pA->Event2(mytmp5);
printf("hello worldn");
return 0;
}