『阅读笔记』设计模式5

外观模式

类成员包含用到的依赖库，很直观的设计模式，只是不知道它叫“外观模式”这个名字

class Base1 {
public:
  Base1() = default;
  void op1() {
    std::cout << "Base1 op1" << std::endl;
  }

  void op2() {
    std::cout << "Base1 op2" << std::endl;
  }
};

class Base2 {
public:
  Base2() = default;
  void op1() {
    std::cout << "Base2 op1" << std::endl;
  }

  void op2() {
    std::cout << "Base2 op2" << std::endl;
  }
};

class Facade {
public:
  Facade(Base1* b1, Base2* b2) : b1_(b1), b2_(b2) {
    assert(b1);
    assert(b2);
  };
  void op() {
    b1_->op1();
    b1_->op2();

    b2_->op1();
    b2_->op2();
  }

protected:
  Base1* b1_;
  Base2* b2_;
};

享元模式

新学了两个概念:

1. 外在状态，即可以被外部操作改变的类状态
2. 内在状态，和外在状态相反，是只读的状态

享元模式就是将所有内在状态用一个instance保存，以达到节省内存的目的。
代码太长了，贴一个书里的

代理模式

用一个代理类来执行简单操作或额外操作，如果涉及到真实的对象操作再执行。核心思想也是节省内存使用罢（
贴一个书里的代码

#include <iostream>
/**
 * The Subject interface declares common operations for both RealSubject and the
 * Proxy. As long as the client works with RealSubject using this interface,
 * you'll be able to pass it a proxy instead of a real subject.
 */
class Subject {
 public:
  virtual void Request() const = 0;
};
/**
 * The RealSubject contains some core business logic. Usually, RealSubjects are
 * capable of doing some useful work which may also be very slow or sensitive -
 * e.g. correcting input data. A Proxy can solve these issues without any
 * changes to the RealSubject's code.
 */
class RealSubject : public Subject {
 public:
  void Request() const override {
    std::cout << "RealSubject: Handling request.\n";
  }
};
/**
 * The Proxy has an interface identical to the RealSubject.
 */
class Proxy : public Subject {
  /**
   * @var RealSubject
   */
 private:
  RealSubject *real_subject_;

  bool CheckAccess() const {
    // Some real checks should go here.
    std::cout << "Proxy: Checking access prior to firing a real request.\n";
    return true;
  }
  void LogAccess() const {
    std::cout << "Proxy: Logging the time of request.\n";
  }

  /**
   * The Proxy maintains a reference to an object of the RealSubject class. It
   * can be either lazy-loaded or passed to the Proxy by the client.
   */
 public:
  Proxy(RealSubject *real_subject) : real_subject_(new RealSubject(*real_subject)) {
  }

  ~Proxy() {
    delete real_subject_;
  }
  /**
   * The most common applications of the Proxy pattern are lazy loading,
   * caching, controlling the access, logging, etc. A Proxy can perform one of
   * these things and then, depending on the result, pass the execution to the
   * same method in a linked RealSubject object.
   */
  void Request() const override {
    if (this->CheckAccess()) {
      this->real_subject_->Request();
      this->LogAccess();
    }
  }
};
/**
 * The client code is supposed to work with all objects (both subjects and
 * proxies) via the Subject interface in order to support both real subjects and
 * proxies. In real life, however, clients mostly work with their real subjects
 * directly. In this case, to implement the pattern more easily, you can extend
 * your proxy from the real subject's class.
 */
void ClientCode(const Subject &subject) {
  // ...
  subject.Request();
  // ...
}

int main() {
  std::cout << "Client: Executing the client code with a real subject:\n";
  RealSubject *real_subject = new RealSubject;
  ClientCode(*real_subject);
  std::cout << "\n";
  std::cout << "Client: Executing the same client code with a proxy:\n";
  Proxy *proxy = new Proxy(real_subject);
  ClientCode(*proxy);

  delete real_subject;
  delete proxy;
  return 0;
}