代理设计模式的核心思想是通过引入一个代理类，来间接访问真实的目标对象，代理类可以在访问前后添加额外的逻辑，比如权限校验、延迟加载、日志记录等，从而实现对目标对象访问的控制。在c++中实现代理模式，通常需要让代理类和真实对象实现同一个接口，这样客户端就可以像使用真实对象一样使用代理对象。
c++实现代理设计模式的基本步骤
实现代理设计模式通常需要三个核心角色：抽象主题接口、真实主题类、代理类。下面通过一个简单的示例来演示完整的实现过程。
1. 定义抽象主题接口
抽象主题接口定义了真实对象和代理对象共同需要实现的方法，这样客户端可以面向接口编程，不需要关心具体使用的是真实对象还是代理对象。
// 抽象主题接口，定义公共方法
class Image {
public:
virtual ~Image() = default;
// 显示图片的抽象方法
virtual void display() = 0;
};
2. 实现真实主题类
真实主题类是真正执行业务逻辑的类，这里以图片加载为例，真实主题类负责从磁盘读取图片并显示。
#include <iostream>
#include <string>
// 真实主题类，实现抽象接口
class RealImage : public Image {
private:
std::string filename;
public:
// 构造函数中模拟加载图片的耗时操作
RealImage(const std::string& name) : filename(name) {
loadFromDisk();
}
void display() override {
std::cout << "显示图片: " << filename << std::endl;
}
private:
void loadFromDisk() {
std::cout << "从磁盘加载图片: " << filename << std::endl;
}
};
3. 实现代理类
代理类同样继承抽象主题接口，内部持有真实主题对象的指针，在调用真实对象的方法前后可以添加额外的控制逻辑，这里的示例实现了延迟加载的功能，只有在真正需要显示图片的时候才会创建真实图片对象。
// 代理类，同样继承抽象接口
class ImageProxy : public Image {
private:
RealImage* realImage;
std::string filename;
public:
ImageProxy(const std::string& name) : realImage(nullptr), filename(name) {}
~ImageProxy() {
delete realImage;
}
void display() override {
// 延迟加载：第一次调用display时才创建真实对象
if (realImage == nullptr) {
realImage = new RealImage(filename);
}
// 调用真实对象的显示方法
realImage->display();
}
};
4. 客户端使用示例
客户端只需要面向抽象接口编程，不需要知道代理类和真实类的区别，通过代理对象就可以实现对真实对象的访问控制。
int main() {
// 创建代理对象，此时不会加载真实图片
Image* image = new ImageProxy("test.jpg");
std::cout << "代理对象创建完成，未加载图片" << std::endl;
// 第一次调用display，触发真实图片加载
image->display();
// 第二次调用display，直接使用已加载的真实对象
image->display();
delete image;
return 0;
}
c++控制对象访问的多种方式
除了代理模式之外，c++中还有多种常见的方式可以控制对象的访问，不同的方式适用于不同的场景。
1. 访问控制符控制
c++的类成员访问控制符public、protected、private是最基础的对象访问控制方式，通过不同的访问权限限制外部对类成员的访问。
class User {
private:
// 私有成员，只有类内部可以访问
std::string password;
protected:
// 保护成员，类和子类可以访问
int age;
public:
// 公有成员，外部可以直接访问
std::string name;
void setPassword(const std::string& pwd) {
// 可以在设置密码时添加校验逻辑
if (pwd.length() >= 6) {
password = pwd;
}
}
std::string getPassword() const {
// 控制密码的返回逻辑，避免直接暴露
return "******";
}
};
2. 智能指针控制生命周期与访问
c++的智能指针std::shared_ptr、std::unique_ptr等不仅可以管理对象的生命周期，还可以通过自定义删除器或者配合其他逻辑控制对象的访问，比如限制对象只能被特定方式使用。
#include <memory>
#include <iostream>
class Resource {
public:
void use() {
std::cout << "使用资源" << std::endl;
}
};
int main() {
// 独占智能指针，保证资源只能被一个所有者访问
std::unique_ptr<Resource> res = std::make_unique<Resource>();
res->use();
// 不能复制unique_ptr，避免多个地方同时修改资源
// std::unique_ptr<Resource> res2 = res; // 编译报错
return 0;
}
3. 友元机制控制访问
c++的友元函数和友元类可以突破访问权限的限制，允许特定的函数或者类访问当前类的私有成员，适用于需要让特定模块访问内部状态的场景。
class BankAccount {
private:
double balance;
// 声明Audit类为友元类，允许Audit访问私有成员
friend class Audit;
public:
BankAccount(double initBalance) : balance(initBalance) {}
};
class Audit {
public:
void checkBalance(const BankAccount& account) {
// 友元类可以直接访问私有成员balance
std::cout << "账户余额: " << account.balance << std::endl;
}
};
4. 代理模式的不同应用场景
代理模式除了延迟加载之外，还可以实现多种访问控制场景，以下是常见的几种代理类型：
- 保护代理：在代理类中添加权限校验逻辑，只有满足权限要求的请求才会转发给真实对象。
- 远程代理：代理类负责处理远程调用的细节，让客户端像访问本地对象一样访问远程对象。
- 日志代理：在调用真实对象方法前后记录日志，用于监控方法的调用情况。
下面是一个简单的保护代理示例，只有管理员权限的用户才能执行删除操作：
#include <iostream>
#include <string>
// 抽象操作接口
class Operation {
public:
virtual ~Operation() = default;
virtual void execute(const std::string& userRole) = 0;
};
// 真实操作类
class DeleteFile : public Operation {
public:
void execute(const std::string& userRole) override {
std::cout << "执行删除文件操作" << std::endl;
}
};
// 保护代理类
class ProtectedDeleteProxy : public Operation {
private:
DeleteFile* realOperation;
public:
ProtectedDeleteProxy() : realOperation(new DeleteFile()) {}
~ProtectedDeleteProxy() {
delete realOperation;
}
void execute(const std::string& userRole) override {
// 权限校验：只有管理员可以执行删除
if (userRole == "admin") {
realOperation->execute(userRole);
} else {
std::cout << "权限不足，无法执行删除操作" << std::endl;
}
}
};
不同访问控制方式的对比
为了帮助开发者选择合适的方式，下面列出不同访问控制方式的特点和适用场景：
| 控制方式 | 核心特点 | 适用场景 |
|---|---|---|
| 访问控制符 | 语言原生支持，粒度细，控制类成员访问 | 类内部成员的访问权限划分 |
| 智能指针 | 管理生命周期，限制所有权转移 | 资源生命周期管理，避免野指针 |
| 友元机制 | 突破访问权限，允许特定模块访问私有成员 | 需要特定模块访问内部状态的场景 |
| 代理模式 | 灵活扩展访问逻辑，不修改原对象代码 | 延迟加载、权限校验、日志、远程调用等场景 |
在实际开发中，可以根据需求选择合适的访问控制方式，代理模式的灵活性最高，适合需要在访问前后添加额外逻辑的场景，而其他方式更适合基础性的访问控制需求。