title: "modern C++ DesignPattern-Part3"
date: 2018-04-12T19:08:49+08:00
lastmod: 2018-04-12T19:08:49+08:00
keywords: [设计模式, C++]
tags: [设计模式]
categories: []

结构式设计模式的最后两个，享元模式：实现对象共享，减少内存开销；代理模式，提供相同接口的代理

flyweight

享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。boost::flyweight使用：

struct User2
{
  flyweight<string> first_name, last_name;  //类似一个缓存
 
  User2(const string &first_name, const string &last_name)
    : first_name(first_name),
      last_name(last_name) {}
};
 
void boost_flyweight()
{
  User2 user1{"John", "Smith"};
  User2 user2{"Jane", "Smith"};
  cout << user1.first_name << endl;
  cout << boolalpha  //std::boolalpha可以把bool变成true/false字符串
       << (&user1.first_name.get() == &user2.first_name.get()) << endl;
  cout << boolalpha
       << (&user1.last_name.get() == &user2.last_name.get()) << endl;
}

示例：

class FormattedText {  //用来记录是否被复用的单元
    string plain_text;
    bool *caps;
public:
    explicit FormattedText(const string &plainText)
            : plain_text{plainText} {
        caps = new bool[plainText.length()];
        memset(caps, 0, plain_text.length());
    }
 
    ~FormattedText() {
        delete[] caps;
    }
 
    void capitalize(int start, int end) {
        for (int i = start; i <= end; ++i)
            caps[i] = true;
    }
 
    friend std::ostream &operator<<(std::ostream &os, const FormattedText &obj) {
        string s;
        for (int i = 0; i < obj.plain_text.length(); ++i) {
            char c = obj.plain_text[i];
            s += (obj.caps[i] ? toupper(c) : c);
        }
        return os << s;
    }
};
 
class BetterFormattedText {
public:
    struct TextRange {
        int start, end;
        bool capitalize, bold, italic;
 
        bool covers(int position) const {
            return position >= start && position <= end;
        }
    };
 
    TextRange &get_range(int start, int end) { //每当设置一个被复用的单元，push到vector里面，返回最后一个
        formatting.emplace_back(TextRange{start, end});
        return *formatting.rbegin();
    }
 
    explicit BetterFormattedText(const string &plainText)
            : plain_text{plainText} {
    }
 
    friend std::ostream &operator<<(std::ostream &os, const BetterFormattedText &obj) {
        string s;
        for (size_t i = 0; i < obj.plain_text.length(); i++) {
            auto c = obj.plain_text[i];
            for (const auto &rng : obj.formatting) {
                if (rng.covers(i) && rng.capitalize)
                    c = toupper(c);
            }
            s += c; // fixed!
        }
        return os << s;
    }
 
private:
    string plain_text;
    vector<TextRange> formatting;
};

Proxy

代理模式最经典的是shared_ptr实现，增加了引用计数的同时保持了原有的普通指针接口

Property Proxy

template <typename T> struct Property {
  T value;
  Property(const T initialValue) {
    *this = initialValue;
  }
  operator T() {  //getter
    return value;
  }
  T operator =(T newValue) {  //setter
    return value = newValue;
  }
};
//usage
struct Creature
{
  Property<int> strength{ 10 };
  Property<int> agility{ 5 };
};
void property_proxy() {
  Creature creature;
  creature.agility = 20;
  cout << creature.agility << endl;
}

主要目的是可以允许 Property<int>与int的随时转换。

Virtual Proxy

这种非常常见，使用时分两种，eager模式和lazy模式，区别就是lazy模式是在使用的时候才会初始化

struct Image{
  virtual ~Image() = default;
  virtual void draw() = 0;
};
struct Bitmap : Image{
  Bitmap(const string& filename) {
    cout << "Loading image from " << filename << endl;
  }
  void draw() override {
    cout << "Drawing image" << endl;
  }
};
struct LazyBitmap : Image {
  LazyBitmap(const string& filename): filename(filename) {}
  ~LazyBitmap() { delete bmp; }
  void draw() override {
    if (!bmp)
      bmp = new Bitmap(filename);
    bmp->draw();
  }
private:
  Bitmap* bmp{nullptr};
  string filename;
};
 
void draw_image(Image& img) {
  img.draw();
}
void virtual_proxy() {
  LazyBitmap img{ "pokemon.png" };
  draw_image(img); // loaded whether the bitmap is loaded or not
  draw_image(img);
}