量化交易之设计模式篇 - 建造者模式(生成器模式)

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

// eg: 1
class Person {
public:
    virtual ~Person() = default;

    virtual void createHead() = 0;
    virtual void createHand() = 0;
    virtual void createBody() = 0;
    virtual void createFoot() = 0;
};

class ThinPerson: public Person {
public:
    virtual void createHead() {
        std::cout << "ThinPerson createHead." << std::endl;
    }
    virtual void createHand() {
        std::cout << "ThinPerson createHand." << std::endl;
    }
    virtual void createBody() {
        std::cout << "ThinPerson createBody." << std::endl;
    }
    virtual void createFoot() {
        std::cout << "ThinPerson createFoot." << std::endl;
    }
};
class FatPerson: public Person {
public:
    virtual void createHead() {
        std::cout << "FatPerson createHead." << std::endl;
    }
    virtual void createHand() {
        std::cout << "FatPerson createHand." << std::endl;
    }
    virtual void createBody() {
        std::cout << "FatPerson createBody." << std::endl;
    }
    virtual void createFoot() {
        std::cout << "FatPerson createFoot." << std::endl;
    }
};

class Direct {
public:
    Direct(Person* person) {
        this->person = person;
    }

    void create() {
        this->person->createBody();
        this->person->createHand();
        this->person->createBody();
        this->person->createFoot();
    }

private:
    Person* person;
};

int main() {
    Person* person = new FatPerson();
    Direct* direct = new Direct(person);

    direct->create();

    delete person;
    delete direct;

    return 0;
}

//
// Created by win10 on 2021/11/16.
//

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

// eg 2
// 产品类
class Product {
public:
    void add(string str) {
        this->m_list.push_back(str);
    }
    void show() {
        for (auto iterator = this->m_list.begin(); iterator != this->m_list.end(); iterator++) {
            std::cout << *iterator << std::endl;
        }
    }

private:
    vector<string> m_list;
};

class Builder {
public:
    Builder() = default;
    virtual ~Builder() = default;
    virtual void buildA() = 0;
    virtual void buildB() = 0;
    virtual Product* getResult() = 0;
};
class ConcreteBuilder1: public Builder {
public:
    ConcreteBuilder1() {
        this->product = new Product();
    }
    virtual ~ConcreteBuilder1() {
        delete this->product;
    };

    virtual void buildA() {
        this->product->add("a");
    }
    virtual void buildB() {
        this->product->add("b");
    }
    virtual Product* getResult() {
        return this->product;
    }

private:
    Product* product;
};
class ConcreteBuilder2: public Builder {
public:
    ConcreteBuilder2() {
        this->product = new Product();
    }
    virtual ~ConcreteBuilder2() {
        delete this->product;
    };

    virtual void buildA() {
        this->product->add("a");
    }
    virtual void buildB() {
        this->product->add("b");
    }
    virtual Product* getResult() {
        return this->product;
    }

private:
    Product* product;
};

class Direct {
public:
    Direct() = default;
    void constructor(Builder* builder) {
        builder->buildA();
        builder->buildB();
    }
};

int main() {
    Builder* builder1 = new ConcreteBuilder1();
    Builder* builder2 = new ConcreteBuilder2();

    Direct direct;
    direct.constructor(builder1);
    Product* product1 = builder1->getResult();
    product1->show();

    direct.constructor(builder2);
    Product* product2 = builder1->getResult();
    product2->show();

    delete builder1;
    delete builder2;
    return 0;
}