c++尝试写一个代理类

#include <iostream>
using namespace std;




//运算符重载
//class A
//{
//public:
// A(){}
// A(double a1)
// {
// m_a = a1; 
// }
// virtual ~A(){ cout << "~A" << endl; }
// //~A(){ cout << "1111" << endl; }
// double getA() const { return m_a; }
// A& operator=(const A& a2) // 注意赋值操作 返回的还是第一个操作数 所以这里不用构造心对象 +法就不一样 他是一个新的对象 
// {
// if (&a2 != this)
// {
// m_a = a2.getA();
// }
// return *this;
// }
// A operator+(const A& a2)
// {
// return A(m_a + a2.getA());
// }
//private:
// double m_a;
//};
//
////继承的测试工作 
//class B : public A
//{
//public:
// B(){}
// //virtual ~B(){ cout << "~B" << endl; }
// //~B(){ cout << "222" << endl; }
//};
//顶层函数 测试工作 




//前置声明 




//通常来说我们的数组或者链表装的数据一般都是一个类型的 比如int a[100] list<Person> lp[100] 这些东西
class IObject // 只要我们派生的类都基于这个 可以说我们的代理列表 或者是对象数组 可以装任何对象 是不是很酷 
{
public:
IObject(){}
virtual ~IObject() {  cout << "call IObject 析构函数" << endl; };
virtual void work() = 0;
virtual IObject* copy() const = 0;
};


class Object1 :public IObject
{
public:
Object1(){}
Object1(const Object1& ob1)
{
value = ob1.getValue();
}
Object1(int n) :value(n){}
int getValue() const { return value; }
virtual void work() { cout << "Object1 work!" << endl; }
virtual ~Object1(){ cout << "call Object1 析构函数" << endl; };
virtual IObject* copy() const
{
return new Object1(*this);
}


private:
int value;


};


class Object2 :public IObject
{
public:
Object2(){}
Object2(const Object2& ob2)
{
value = ob2.getValue();
}
Object2(string n) :value(n){}
virtual ~Object2()
{
cout << "call Object2 析构函数" << endl;
};
string getValue() const { return value; }
virtual void work() { cout << "Object2 work!" << endl; }
virtual IObject* copy() const
{
return new Object2(*this);
}


private:
string value;


};


class Agent // 代理类  Agent ag[100] 100个代理对象  so  how to deal 每一个对象可能都是完全不同的类型  
{
public:
Agent() :pObj(NULL){}
Agent(const IObject& obj) :pObj(obj.copy()){}
Agent(const Agent& ag) :pObj(ag.getObj() ? ag.getObj()->copy():NULL){}
Agent& operator=(const Agent& ag2) //=号是一个二元符 赋值操作只是改变左值 并不会参生新的对象 注意函数返回值不要返回对象 而应该是引用  
{
if (&ag2 != this)
{
delete pObj;
pObj = ag2.getObj()->copy();
}
return *this;
}
IObject* getObj() const { return pObj; }//这里的const表示不改变该类的成员变量 
void work()
{
if (pObj)
{
pObj->work();
}
}
~Agent(){ cout << "~Agent析构函数 " << endl; delete pObj; }




private:
IObject* pObj;
};




void test1()
{
Agent* ag[2];
int index = 0;
ag[index++] = new Agent(Object2("i am good")); //参数构建的时候 会有一次构造函数和析构函数（Agent构造函数退出的时候调用）的过程 但是形参是引用 不会调用拷贝构造函数
ag[index++] = new Agent(Object1(100));
for (int i = 0; i < 2; i++)
{
ag[i]->work();//代理方法 
}
for (int i = 0; i < 2; i++)
{
delete ag[i]; // new和delete一定要对应 注意这里的delete是一种层级结构 同样的上面的new也是一种层级结构 
}
}




void test2(const Object2& ob2)  //实参以构造函数的形式进来会调用构造函数一次 出函数会调用它的析构函数
//形参如果是类对象 那么会调用一次拷贝构造函数  出函数也会调用析构函数 参数是类对象的时候 往往容易引起效率瓶颈
//建议是传引用或者指针 
{
int n = 2;
}






int main()
{
test1();
system("pause");
return 0;
}