#include <iostream>
using namespace std;
 
// 定義抽象類 Subject，代表原始對象和代理對象共同的接口
class Subject {
public:
    virtual void request() = 0;
};
 
// 定義具體類 RealSubject，實(shí)現(xiàn)原始對象的功能
class RealSubject : public Subject {
public:
    void request() override {
        cout << "RealSubject: Handling request." << endl;
    }
};
 
// 定義代理類 Proxy，實(shí)現(xiàn)代理對象的功能
class Proxy : public Subject {
private:
    RealSubject* real_subject_;
 
    void check_access() const {
        cout << "Proxy: Checking access prior to handling request." << endl;
    }
 
public:
    Proxy(RealSubject* real_subject) : real_subject_(real_subject) {}
 
    void request() override {
        check_access();
        real_subject_->request();
    }
};
 
int main() {
    RealSubject* real_subject = new RealSubject;
    Proxy* proxy = new Proxy(real_subject);
    proxy->request();
 
    delete proxy;
    delete real_subject;
    return 0;
}

// 假設(shè)這是遠(yuǎn)程服務(wù)端對象的頭文件
class RemoteService {
public:
    virtual void foo() = 0;
};
 
// 代理類，用于訪問遠(yuǎn)程服務(wù)端對象
class RemoteServiceProxy : public RemoteService {
public:
    RemoteServiceProxy(const std::string& host, int port) : m_host(host), m_port(port) {}
 
    void foo() override {
        // 連接遠(yuǎn)程服務(wù)端
        connect();
 
        // 向遠(yuǎn)程服務(wù)端發(fā)送請求
        sendRequest("foo");
 
        // 等待遠(yuǎn)程服務(wù)端響應(yīng)
        std::string response = receiveResponse();
 
        // 關(guān)閉連接
        disconnect();
 
        // 處理響應(yīng)
        processResponse(response);
    }
 
private:
    std::string m_host;
    int m_port;
    int m_socketFd;  // 保存套接字描述符，用于連接遠(yuǎn)程服務(wù)端
 
    void connect() {
        // 連接遠(yuǎn)程服務(wù)端代碼
    }
 
    void sendRequest(const std::string& request) {
        // 向遠(yuǎn)程服務(wù)端發(fā)送請求代碼
    }
 
    std::string receiveResponse() {
        // 從遠(yuǎn)程服務(wù)端接收響應(yīng)代碼
    }
 
    void disconnect() {
        // 關(guān)閉連接代碼
    }
 
    void processResponse(const std::string& response) {
        // 處理響應(yīng)代碼
    }
};
 
// 客戶端代碼
int main() {
    RemoteServiceProxy proxy("127.0.0.1", 8080);
    proxy.foo();  // 通過代理對象間接訪問遠(yuǎn)程服務(wù)端對象的foo()方法
    return 0;
}

#include <iostream>
using namespace std;
 
// 定義一個(gè)抽象類Subject
class Subject {
public:
    virtual void request() = 0;
};
 
// 定義一個(gè)真實(shí)的Subject類RealSubject
class RealSubject : public Subject {
public:
    void request() {
        cout << "真實(shí)的請求" << endl;
    }
};
 
// 定義一個(gè)代理類Proxy
class Proxy : public Subject {
private:
    RealSubject *realSubject;
 
public:
    void request() {
        if (realSubject == nullptr) {
            realSubject = new RealSubject();
        }
        cout << "代理請求" << endl;
        realSubject->request();
    }
};
 
// 客戶端代碼
int main() {
    Proxy proxy;
    proxy.request();
    return 0;
}

#include <iostream>
#include <string>
#include <memory>
 
class Image {
public:
    Image(std::string name) : name_(name) {}
    virtual void Display() = 0;
    virtual ~Image() {}
 
protected:
    std::string name_;
};
 
class RealImage : public Image {
public:
    RealImage(std::string name) : Image(name) {
        LoadFromDisk();
    }
 
    void Display() override {
        std::cout << "Displaying " << name_ << std::endl;
    }
 
private:
    void LoadFromDisk() {
        std::cout << "Loading " << name_ << " from disk" << std::endl;
    }
};
 
class ImageProxy : public Image {
public:
    ImageProxy(std::string name) : Image(name) {}
 
    void Display() override {
        if (real_image_ == nullptr) {
            real_image_ = std::make_unique<RealImage>(name_);
        }
        real_image_->Display();
    }
 
private:
    std::unique_ptr<RealImage> real_image_;
};
 
int main() {
    // Create a real image object
    auto real_image = std::make_unique<RealImage>("image1.jpg");
    
    // Display the real image
    real_image->Display();
 
    // Create an image proxy object
    auto image_proxy = std::make_unique<ImageProxy>("image2.jpg");
 
    // Display the image proxy
    image_proxy->Display();
 
    // The real image is only loaded once, even though it is displayed twice
    return 0;
}

#include <iostream>
#include <unordered_map>
 
using namespace std;
 
// 定義一個(gè)全局的緩存代理類
class FactorialCacheProxy {
public:
    int getFactorial(int n) {
        if (cache_.find(n) != cache_.end()) {
            // 如果結(jié)果已經(jīng)被緩存，直接返回緩存的結(jié)果
            cout << "Get result from cache: " << n << endl;
            return cache_[n];
        } else {
            // 如果結(jié)果沒有被緩存，進(jìn)行計(jì)算并緩存結(jié)果
            cout << "Calculate result: " << n << endl;
            int result = calculateFactorial(n);
            cache_[n] = result;
            return result;
        }
    }
private:
    // 計(jì)算階乘的實(shí)際函數(shù)
    int calculateFactorial(int n) {
        int result = 1;
        for (int i = 1; i <= n; i++) {
            result *= i;
        }
        return result;
    }
    // 使用一個(gè) unordered_map 來作為緩存
    unordered_map<int, int> cache_;
};
 
int main() {
    FactorialCacheProxy cacheProxy;
    for (int i = 5; i <= 7; i++) {
        int result = cacheProxy.getFactorial(i);
        cout << "Factorial of " << i << " is " << result << endl;
    }
    for (int i = 5; i <= 7; i++) {
        int result = cacheProxy.getFactorial(i);
        cout << "Factorial of " << i << " is " << result << endl;
    }
    return 0;
}