C++25设计模式之建造者模式

图片引用于百度

简介：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。

优点：封装性好，构建和表示分离。扩展性好，各个具体的建造者相互独立。客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险

缺点：产品的组成部分必须相同，这限制了其使用范围。

例子背景：现在需要组装一台电脑主机，而主机的各个部件都不相同，我们需要根据不同的主机构建不同的部件，然后组装它

概念：它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

建造者模式代码：

• 产品类：

#pragma once
#include <string>
#include <iostream>
using namespace std;

class IProduct
{
public:
        virtual ~IProduct() {}
private:
        string m_cpu;
        string m_mainboard;
        string m_graphicscard;
        string m_memorybank;
        string m_harddisk;
        string m_powersupply;
        string m_heatdissipation;
        string m_computercase;
public:
        string GetCpu() { return m_cpu; }
        string GetMainboard() { return m_mainboard; }
        string GetGraphicscard() { return m_graphicscard; }
        string GetMemorybank() { return m_memorybank; }
        string GetHarddisk() { return m_harddisk; }
        string GetPowersupply() { return m_powersupply; }
        string GetHeatdissipation() { return m_heatdissipation; }
        string GetComputercase() { return m_computercase; }
        void   SetCpu(string cpu) { m_cpu = cpu; }
        void   SetMainboard(string mainboard) { m_mainboard = mainboard; }
        void   SetGraphicscard(string graphicscard) { m_graphicscard = graphicscard; }
        void   SetMemorybank(string memorybank) { m_memorybank = memorybank; }
        void   SetHarddisk(string harddisk) { m_harddisk = harddisk; }
        void   SetPowersupply(string powersupply) { m_powersupply = powersupply; }
        void   SetHeatdissipation(string heatdissipation) { m_heatdissipation = heatdissipation; }
        void   SetComputercase(string computercase) { m_computercase = computercase; }
};

• 建造者基类：

#pragma once
#include "IProduct.h"

class Builder
{
public:
        Builder() {}
        virtual ~Builder() {}
        virtual void BuildCpu() = 0;
        virtual void BuildMainboard() = 0;
        virtual void BuildGraphicscard() = 0;
        virtual void BuildMemorybank() = 0;
        virtual void BuildHarddisk() = 0;
        virtual void BuildPowersupply() = 0;
        virtual void BuildHeatdissipation() = 0;
        virtual void BuildComputercase() = 0;
        virtual shared_ptr<IProduct> BuildProduct() = 0;
};

• 产品构建类：

#pragma once
#include "Builder.h"
#include <memory>

class i3Builder : public Builder
{
public:
        i3Builder() { m_i3IProduct.reset(new IProduct); }
        ~i3Builder() {}
private:
        shared_ptr<IProduct> m_i3IProduct;
public:
        virtual void BuildCpu()
        {
                m_i3IProduct->SetCpu("i3CPU");
                cout << "建造了：" << m_i3IProduct->GetCpu() << endl;
        }
        virtual void BuildMainboard()
        {
                m_i3IProduct->SetMainboard("h510主板");
                cout << "建造了：" << m_i3IProduct->GetMainboard() << endl;
        }
        virtual void BuildGraphicscard()
        {
                m_i3IProduct->SetGraphicscard("3050Ti显卡");
                cout << "建造了：" << m_i3IProduct->GetGraphicscard() << endl;
        }
        virtual void BuildMemorybank()
        {
                m_i3IProduct->SetMemorybank("8G内存");
                cout << "建造了：" << m_i3IProduct->GetMemorybank() << endl;
        }
        virtual void BuildHarddisk()
        {
                m_i3IProduct->SetHarddisk("250G M.2硬盘");
                cout << "建造了：" << m_i3IProduct->GetHarddisk() << endl;
        }
        virtual void BuildPowersupply()
        {
                m_i3IProduct->SetPowersupply("550w电源");
                cout << "建造了：" << m_i3IProduct->GetPowersupply() << endl;
        }
        virtual void BuildHeatdissipation()
        {
                m_i3IProduct->SetHeatdissipation("风冷散热");
                cout << "建造了：" << m_i3IProduct->GetHeatdissipation() << endl;
        }
        virtual void BuildComputercase()
        {
                m_i3IProduct->SetComputercase("爱国者暗影机箱");
                cout << "建造了：" << m_i3IProduct->GetComputercase() << endl;
        }
        virtual shared_ptr<IProduct> BuildProduct()
        {
                cout << "i3主机建造完成" << endl;
                return m_i3IProduct;
        }
};

class i5Builder : public Builder
{
public:
        i5Builder() { m_i5IProduct.reset(new IProduct); }
        ~i5Builder() {}
private:
        shared_ptr<IProduct> m_i5IProduct;
public:
        virtual void BuildCpu()
        {
                m_i5IProduct->SetCpu("i5CPU");
                cout << "建造了：" << m_i5IProduct->GetCpu() << endl;
        }
        virtual void BuildMainboard()
        {
                m_i5IProduct->SetMainboard("b690主板");
                cout << "建造了：" << m_i5IProduct->GetMainboard() << endl;
        }
        virtual void BuildGraphicscard()
        {
                m_i5IProduct->SetGraphicscard("3060Ti显卡");
                cout << "建造了：" << m_i5IProduct->GetGraphicscard() << endl;
        }
        virtual void BuildMemorybank()
        {
                m_i5IProduct->SetMemorybank("16G内存");
                cout << "建造了：" << m_i5IProduct->GetMemorybank() << endl;
        }
        virtual void BuildHarddisk()
        {
                m_i5IProduct->SetHarddisk("500G M.2硬盘");
                cout << "建造了：" << m_i5IProduct->GetHarddisk() << endl;
        }
        virtual void BuildPowersupply()
        {
                m_i5IProduct->SetPowersupply("650w电源");
                cout << "建造了：" << m_i5IProduct->GetPowersupply() << endl;
        }
        virtual void BuildHeatdissipation()
        {
                m_i5IProduct->SetHeatdissipation("风冷散热");
                cout << "建造了：" << m_i5IProduct->GetHeatdissipation() << endl;
        }
        virtual void BuildComputercase()
        {
                m_i5IProduct->SetComputercase("复仇者机箱");
                cout << "建造了：" << m_i5IProduct->GetComputercase() << endl;
        }
        virtual shared_ptr<IProduct> BuildProduct()
        {
                cout << "i5主机建造完成" << endl;
                return m_i5IProduct;
        }
};

• 组装类：

#pragma once
#include "IProductBuilder.h"

class Director
{
public:
        Director(){}
        ~Director(){}
public:
        shared_ptr<IProduct> ConstructPerson(Builder* builder)
        {
                builder->BuildCpu();
                builder->BuildMainboard();
                builder->BuildGraphicscard();
                builder->BuildMemorybank();
                builder->BuildHarddisk();
                builder->BuildPowersupply();
                builder->BuildHeatdissipation();
                builder->BuildComputercase();
                return builder->BuildProduct();
        }
};

• 调用者：

#include "Director.h"

int main()
{
        shared_ptr<Director> director(new Director);
        shared_ptr<Builder> i3(new i3Builder);
        shared_ptr<Builder> i5(new i5Builder);
        auto i31 = director->ConstructPerson(i3.get());
        auto i51 = director->ConstructPerson(i5.get());
        getchar();
        return 0;
}

总结：
建造者模式(Builders)：建造者模式可以将某个功能是实现部分拆分，封装性好，而且能够灵活的改变实现过程，唯一不好的就是组装实现过程必须是一样的，一但不同就得改变整个流程或者创建一个新的建造者类。

作者：丶梦爱
博客：https://blog.csdn.net/u014732297（转载请说明出处）