[c++]代理对象模式

代理对象

#include <iostream>
#include <vector>
using namespace std;
class Vehicle {
public:
Vehicle() {}
virtual string getName() = 0;
};

class Car : public Vehicle {
public:
Car() {
name = "car";
}
virtual string getName() {
return name; }
~Car() {
cout << "delete" << endl;
}
private:
string name;
};

class Bike : public Vehicle {
public:
Bike() {}
virtual string getName() { return "bike"; }
private:
string name;
};
void wrong_code(vector<Vehicle *> &parkinglot) {
Car c;
cout << &c << endl;
parkinglot[0] = &c;  //将c插入到parkinglot内
cout << &(*parkinglot[0]) << endl;
}
int main() {
vector<Vehicle *> parkinglot(1);
wrong_code(parkinglot);
cout << parkinglot[0]->getName() << endl;  // Oops!!parkinglot内存的地址指向了一块被销毁的内存
cout << &(*parkinglot[0]) << endl;
return 0;
}

0x7fff5fbff6d8

0x7fff5fbff6d8

delete

0x7fff5fbff6d8
0x7fff5fbff6d8
delete
乱码。。。。
0x7fff5fbff6d8

在这种情况下会出现因为临时对象在生命周期结束之后，对象上的内存被释放，所以访问它的数据就会出现不可预计的结果。

在这种大前提下,代理类就顺势而生了.

顾名思义,代理类就是指某个基类以及其子类的代理,其功能是使之能在容器中也表现出多态性.而没有动态内存管理的烦恼.

现在定义Vehicle以及子类的代理类VehicleSurrogate.

#include <iostream>
#include <vector>
using namespace std;

class Vehicle {
public:
Vehicle() {}
virtual string getName() = 0;
virtual Vehicle *copy() const = 0;
virtual ~Vehicle() {}  //虚析构函数是为了支持多态.但是本例中并不需要.
private:
};

class Car : public Vehicle {
public:
Car() { name = "car"; }
virtual string getName() { return name; }
virtual Vehicle *copy() const { return new Car; }
virtual ~Car() {}

private:
string name;
};

class Bike : public Vehicle {
public:
Bike() { name = "bike"; }
virtual string getName() { return name; }
virtual Vehicle *copy() const { return new Bike; }
virtual ~Bike() {}

private:
string name;
};

class VehicleSurrogate {
public:
VehicleSurrogate() : p(0) {}
VehicleSurrogate(const Vehicle &v) : p(v.copy()) {}
VehicleSurrogate(const VehicleSurrogate &vs) : p(vs.p ? vs.p->copy() : 0) {}
VehicleSurrogate &operator=(const VehicleSurrogate &vs) {
if (this !=
&vs)  //在删除p之前一定得记得判断vs和this是不是同一个,否则会有问题
{
delete p;
p = vs.p->copy();
}
return *this;
}
string getName() { return p->getName(); }
~VehicleSurrogate() { delete p; }

private:
Vehicle *p;
};
void right_code(vector<VehicleSurrogate> &parkinglot) {
Car c;
parkinglot.push_back(c);
}
int main() {
vector<VehicleSurrogate> parkinglot;
right_code(parkinglot);
cout << parkinglot[0].getName() << endl;
return 0;
}

car

所以，这种代理对象的模式实际上就是对对象的封装，同时处理他们对他们进行资源管理，从而防止指针对象指向未被析构的对象地址，已经内存泄露的问题。

示例来自