第四天：原型模式建造者模式

原型模式:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象. 

涉及到对深复制浅复制的理解.

 class Uncopyable
 {
 protected:
     Uncopyable(){}
     ~Uncopyable(){}
     
 private:
     Uncopyable(const Uncopyable&);
     Uncopyable& operator=(const Uncopyable&);
 };
 
 template<class T>
 class ICloneable : private Uncopyable
 {
 public:
     virtual T* Clone() = 0;
 };
 
 #include <cstdlib>
 #include <string>
 class Prototype : public ICloneable<Prototype>
 {
 public:
     Prototype():ch_(new char[10]), integer_(0)
     {
         memset(ch_, '\0', 10);
     }
     
     ~Prototype(){ if(ch_) delete ch_; ch_ = nullptr; }
     
     virtual Prototype* Clone()
     {
         Prototype* pt = new Prototype;
         pt->CopySelf(*this);
         return pt;
     }
     
     void SetChar(char c)
     {
         *ch_ = c;
     }
 
 private:
     void CopySelf(const Prototype& rhs)
     {
         strcpy_s(ch_, 10, rhs.ch_);
         integer_ = rhs.integer_;
     }
     char*    ch_;
     int        integer_;
 };
 
 #include <memory>
 using std::shared_ptr;

template<class T>
T* CreateInstance(ICloneable<T>* clone)
 {
    return clone->Clone();
 }


 int main()
 {
     Prototype t1;
     t1.SetChar('1');
     
     //Prototype t2(t1);
     //Prototype t3 = t1;
     shared_ptr<Prototype> t4(CreateInstance(&t1));
     t4->SetChar('2');
 }

建造者模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示.

建造者模式是当在创建复杂对象的算法应该独立于该对象的组成部分以及他的装配方式时适用的模式

建造者更重视产品建造时的逻辑顺序，但抽象工厂更重视生产出不同型号的产品，而不关心顺序.

#include <string>
#include <iostream>
using std::cout;
using std::endl;
using std::string;
class Car
{
public:
    void SetWheel(const string& wheel)
    {
        wheel_ = wheel;
    }

    void SetBody(const string& body)
    {
        body_ = body;
    }

    void Show()
    {
        cout << "body:" << body_;
        cout << "wheel:" << wheel_ << endl;
    }


private:
    string wheel_;
    string body_;
};

class CarBuilder{
public:
    virtual void BuilderBody() = 0;
    virtual void BuilderWheel() = 0;    
    virtual Car GetCar()
    {
        return car_;
    }
protected:
    Car car_;
};


class BMWBuilder : public CarBuilder
{
public:
    virtual void BuilderBody(){
        car_.SetBody("BMWBody");
    }
    virtual void BuilderWheel(){
        car_.SetWheel("BMWWheel");
    }
};

class KIABuilder : public CarBuilder
{
public:
    virtual void BuilderBody(){
        car_.SetBody("KIABody");
    }
    virtual void BuilderWheel(){
        car_.SetWheel("KIAWheel");
    }
};

class Director
{
public:
    Director(CarBuilder* builder):builder_(builder)
    {
    }
    Car BuildCar()
    {
        builder_->BuilderBody();
        builder_->BuilderWheel();
        return builder_->GetCar();
    }
    
private:
    CarBuilder*  builder_;
};

int main()
{
    BMWBuilder bmw;
    KIABuilder kia;
    Director d(&bmw);
    Car c = d.BuildCar();
    c.Show();
    Director d2(&kia);
    Car c2 = d2.BuildCar();
    c2.Show();
    return 0;
}