c++ builder生成器模式

最新推荐文章于 2024-06-20 21:36:05 发布
原创 最新推荐文章于 2024-06-20 21:36:05 发布
· 264 阅读 · 0 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

生成器模式旨在将复杂对象的构建与表示分离，确保创建过程独立于对象的组件和装配方式。当创建算法需独立于表示且支持不同表示时，此模式适用。与Template Method和工厂模式有相似之处，但更侧重于构建顺序的安排。通过代码示例展示了从无分离到逐步分离的House对象创建过程，强调了稳定构建步骤带来的好处。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

模式定义：
生成器模式是为了解决将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不的表示的问题。对象的构建过程相对稳定。

适用情况：
1、当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2、当构造过程必须允许被构造的对象有不同的表示时。

生成器模式有点类似于template method，都是某个过程的总体流程固定，具体每一步可变。生成器模式是对象的构建过程相对稳定，template method是算法的整体步骤相对稳定。

生成器模式和工厂模式也非常相似，都是构造对象。生成器模式最主要功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了；而工厂方法则重点是创建，你要什么对象我创造一个对象出来，组装顺序则不是他关心的。

下面代码实现了一个house的创建过程，总共有三个版本，一步步演化抽象。

版本1,house的表示和构造未分离。

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

class House{
public:
    House(bool ifBuildWindow):m_ifBuildWindow(ifBuildWindow){
    }
    void init(){
        buildWall();
        buildDoor();
        if(ifBuildWindow()){
            buildWindow();
        }
        buildRoof();
    }
    virtual void showHouse() = 0; 
    virtual ~House(){};
protected:
    virtual void buildDoor() = 0;
    virtual void buildWall() = 0;
    virtual void buildWindow() = 0;
    virtual void buildRoof() = 0;
    virtual bool ifBuildWindow() = 0;
    string m_window;
    string m_door;
    string m_roof;
    string m_wall;
    bool m_ifBuildWindow;
};

class StoneHouse :public House{
public:
    StoneHouse(bool ifBuildWindow):House(ifBuildWindow){}
protected:
    virtual void buildDoor(){
        m_door = "big stone door";
    }
    virtual void buildWall(){
        m_wall = "small stone wall";
    }
    virtual void buildWindow(){
        m_window = "medium stone window";
    }
    virtual void buildRoof(){
        m_roof = "little stone roof";
    }
    virtual bool ifBuildWindow(){
        return m_ifBuildWindow;
    }
    virtual void showHouse(){
        printf(" stone houce door : %s, wall : %s, window : %s, root : %s\n", 
        m_door.c_str(), m_wall.c_str(), m_window.c_str(), m_roof.c_str());
    }
};

class IceHouse :public House{
public:
    IceHouse(bool ifBuildWindow):House(ifBuildWindow){}
protected:
    virtual void buildDoor(){
        m_door = "big ice  door";
    }
    virtual void buildWall(){
        m_wall = "small ice wall";
    }
    virtual void buildWindow(){
        m_window = "medium ice window";
    }
    virtual void buildRoof(){
        m_roof = "little ice roof";
    }
    virtual bool ifBuildWindow(){
        return m_ifBuildWindow;
    }
    virtual void showHouse(){
        printf(" ice houce door : %s, wall : %s, window : %s, root : %s\n", 
        m_door.c_str(), m_wall.c_str(), m_window.c_str(), m_roof.c_str());
    }
};

//使用
int main()
{
    House * pHouse = new StoneHouse(true);
    pHouse->init();
    pHouse->showHouse();

    House * pHouse1 = new IceHouse(true);
    pHouse1->init();
    pHouse1->showHouse();
}

版本2,house的表示和构造分离。

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

class House{
public:
    House(bool ifBuildWindow):m_ifBuildWindow(ifBuildWindow){
    }
    virtual void showHouse() = 0; 
    virtual ~House(){};
public:
    string m_window;
    string m_door;
    string m_roof;
    string m_wall;
    bool m_ifBuildWindow;
};


class HouseBuilder{
public:
    HouseBuilder(House* pHouse):m_pHouse(pHouse){}
public:
    void init(){
        buildWall();
        buildDoor();
        if(ifBuildWindow()){
            buildWindow();
        }
        buildRoof();
    }
    House * getHouse(){
        return m_pHouse;
    }
    virtual ~HouseBuilder(){}
protected:
    virtual void buildDoor() = 0;
    virtual void buildWall() = 0;
    virtual void buildWindow() = 0;
    virtual void buildRoof() = 0;
    virtual bool ifBuildWindow() = 0;
    House * m_pHouse;
};

class StoneHouse :public House{
public:
    StoneHouse(bool ifBuildWindow):House(ifBuildWindow){}
    virtual void showHouse(){
        printf(" stone house door : %s, wall : %s, window : %s, root : %s\n", 
        m_door.c_str(), m_wall.c_str(), m_window.c_str(), m_roof.c_str());
    }
};

class StoneHouseBuilder :public HouseBuilder{
public:
    StoneHouseBuilder(House* pHouse):HouseBuilder(pHouse){}
protected:
    virtual void buildDoor(){
        m_pHouse->m_door = "stone big door";//这里就不get set
    }
    virtual void buildWall(){
        m_pHouse->m_wall = "stone  small wall";
    }
    virtual void buildWindow(){
        m_pHouse->m_window = "stone  medium window";
    }
    virtual void buildRoof(){
        m_pHouse->m_roof = "stone  little roof";
    }
    virtual bool ifBuildWindow(){
        return m_pHouse->m_ifBuildWindow;
    }
};

class IceHouse :public House{
public:
    IceHouse(bool ifBuildWindow):House(ifBuildWindow){}
    virtual void showHouse(){
        printf(" ice houce door : %s, wall : %s, window : %s, root : %s\n", 
        m_door.c_str(), m_wall.c_str(), m_window.c_str(), m_roof.c_str());
    }
};

class IceHouseBuilder :public HouseBuilder{
public:
    IceHouseBuilder(House* pHouse):HouseBuilder(pHouse){}
protected:
    virtual void buildDoor(){
        m_pHouse->m_door = "ice big door";//这里就不get set
    }
    virtual void buildWall(){
        m_pHouse->m_wall = "ice small wall";
    }
    virtual void buildWindow(){
        m_pHouse->m_window = "ice medium window";
    }
    virtual void buildRoof(){
        m_pHouse->m_roof = "ice little roof";
    }
    virtual bool ifBuildWindow(){
        return m_pHouse->m_ifBuildWindow;
    }
};


//使用
int main()
{
    HouseBuilder * pHouseBuilder = new StoneHouseBuilder(new StoneHouse(true));
    pHouseBuilder->init();
    House *pHouse = pHouseBuilder->getHouse();
    pHouse->showHouse();
}

版本3, 将构建的分步骤和总步骤分离，使得总步骤稳定不变（稳定不变的好处：松耦合，可以增量编译、改动无需重新测试等等）

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

class House{
public:
    House(bool ifBuildWindow):m_ifBuildWindow(ifBuildWindow){
    }
    virtual void showHouse() = 0;
    virtual ~House(){};
public:
    string m_window;
    string m_door;
    string m_roof;
    string m_wall;
    bool m_ifBuildWindow;
};


class HouseBuilder{
public:
    HouseBuilder(House* pHouse):m_pHouse(pHouse){}
    House * getHouse(){
        return m_pHouse;
    }
    virtual ~HouseBuilder(){}
    virtual void buildDoor() = 0;
    virtual void buildWall() = 0;
    virtual void buildWindow() = 0;
    virtual void buildRoof() = 0;
    virtual bool ifBuildWindow() = 0;
    House * m_pHouse;
};


class HouseDirector{
public:
    HouseDirector(HouseBuilder* pHouseBuilder){
        this->pHouseBuilder = pHouseBuilder;
    }
    House* Construct(){
        pHouseBuilder->buildWall();
        pHouseBuilder->buildDoor();
        if(pHouseBuilder->ifBuildWindow()){
            pHouseBuilder->buildWindow();
        }
        pHouseBuilder->buildRoof();
        return pHouseBuilder->getHouse();
    }
    ~HouseDirector(){}
private:
    HouseBuilder* pHouseBuilder;
};

/*上面是稳定的，应该单独放在一个或多个文件，这里就不放了*/

class StoneHouse :public House{
public:
    StoneHouse(bool ifBuildWindow):House(ifBuildWindow){}
    virtual void showHouse(){
        printf(" stone houce door : %s, wall : %s, window : %s, root : %s\n", 
        m_door.c_str(), m_wall.c_str(), m_window.c_str(), m_roof.c_str());
    }
};

class StoneHouseBuilder :public HouseBuilder{
public:
    StoneHouseBuilder(House* pHouse):HouseBuilder(pHouse){}
protected:
    virtual void buildDoor(){
        m_pHouse->m_door = "stone big door";//这里就不get set
    }
    virtual void buildWall(){
        m_pHouse->m_wall = "stone  small wall";
    }
    virtual void buildWindow(){
        m_pHouse->m_window = "stone  medium window";
    }
    virtual void buildRoof(){
        m_pHouse->m_roof = "stone  little roof";
    }
    virtual bool ifBuildWindow(){
        return m_pHouse->m_ifBuildWindow;
    }
};

class IceHouse :public House{
public:
    IceHouse(bool ifBuildWindow):House(ifBuildWindow){}
    virtual void showHouse(){
        printf(" ice houce door : %s, wall : %s, window : %s, root : %s\n", 
        m_door.c_str(), m_wall.c_str(), m_window.c_str(), m_roof.c_str());
    }
};

class IceHouseBuilder :public HouseBuilder{
public:
    IceHouseBuilder(House* pHouse):HouseBuilder(pHouse){}
protected:
    virtual void buildDoor(){
        m_pHouse->m_door = "ice big door";//这里就不get set
    }
    virtual void buildWall(){
        m_pHouse->m_wall = "ice small wall";
    }
    virtual void buildWindow(){
        m_pHouse->m_window = "ice medium window";
    }
    virtual void buildRoof(){
        m_pHouse->m_roof = "ice little roof";
    }
    virtual bool ifBuildWindow(){
        return m_pHouse->m_ifBuildWindow;
    }
};


//使用
int main()
{
    HouseBuilder * pHouseBuilder = new StoneHouseBuilder(new StoneHouse(true));
    HouseDirector * pHouseDirector = new HouseDirector(pHouseBuilder);
    House *pHouse = pHouseDirector->Construct();
    pHouse->showHouse();
}
C++ 【生成器模式】
Absorbed__的博客
04-02 1294
讲述了生成器模式，快来进来看看吧，还是会有一些收获的
BUILDER模式 C++实现
10-10
BUILDER模式 C++实现
C++之生成器(builder)模式
lovely_yoshino的博客
03-07 9601
0. 简介 生成器是一种创建型设计模式， 当构建一个复杂对象时，将构建过程与表示分离。使得同样的过程创建不同的对象。生成器与其他创建型模式不同， 生成器不要求产品拥有通用接口。 这使得用相同的创建过程生成不同的产品成为可能。生成器方法通常支持方法链 （例如 someBuilder->setValueA(1)->setValueB(2)->create() ），来组成复杂的对象。相比于工厂模式专门用于生产一系列相关对象而言，生成器重点关注如何分步生成复杂对象。 1. 生成器UML介绍 生
设计模式C++描述----07.建造者(Builder)模式
脚踏实地，仰望星空
05-07 2870
一. 概述 Builder 模式要解决的问题是：当我们要创建的对象很复杂的时候（通常是由很多其他的对象组合而成），我们要要复杂对象的创建过程和这个对象的表示（展示）分离开来，这样做的好处就是通过一步步的进行复杂对象的构建，由于在每一步的构造过程中可以引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样。 二. 举例 KFC 与 Mcdonalds 的汉堡生成过程大致都是一样的，假设
builder模式 c++
豆子的collection
02-25 1761
builder模式：对象创建型模式 意图：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 适用性: 1 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。 2 当构造过程必须允许被构造的对象有不同的表示时 参与者： Builder: 为创建一个Product对象的各个部件指定抽象接口 ConcreteBuilder:实现Builder 的
c++Builder模式
11-02 1043
设计模式--Builder模式
c++builder6安装包
06-22
3. **C++编译器**：C++Builder 6内置的C++编译器支持C++标准，包括模板、异常处理、命名空间等特性，并且针对Windows平台进行了优化，生成的代码运行速度快。 4. **数据库支持**：C++Builder 6提供了丰富的数据库...
C++Builder 6 Update Pack4
06-21
1. **性能优化**：通过更新编译器和链接器，C++Builder 6 Update Pack 4 提升了代码生成的速度，使程序运行更高效。 2. **错误修复**：解决了C++Builder 6中的一些已知问题，包括编译错误、内存泄漏、崩溃等问题，...
C++ builder 2009
03-19
C++ Builder以其快速的应用程序开发（RAD）著称，它包含了一套完整的编译器、调试器和VCL（Visual Component Library）组件库。VCL库提供了大量的预定义组件，如按钮、文本框、表格等，这些组件可以方便地插入到用户...
C++Builder 导出数据到EXCEL表格
03-19
在C++Builder IDE中，可以通过Component Palette管理器来添加这些组件。 2. **创建对象**：在代码中，首先创建TExcelApplication或相应的对象实例，这代表了一个Excel应用程序实例。然后，创建一个TSpreadsheet对象...
正弦数据生成器
03-08
C++ Builder 6.0下开发的一个正弦数据生成器，正弦数据的点数可选
正弦波数据生成器
06-01
该正弦波生成器能够生成不同输出点数，12位分辨率和8位分辨率的十六进制，ASM，HEX格式的正弦波数据
正弦表生成器
06-17
一个正弦表生成器 别人的都太贵了 要三个币 我这个只用一个币 便宜
正弦波生成器
11-07
自动生成正弦波DA数据，避免人工计算偶尔出错的问题
程序设计模式(三) C++ Builder模式
llg070401046的博客
05-09 2172
Builder模式是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。Builder模式和AbstractFactory模式在功能上很相似，因为都是用来创建大的复杂的对象，它们的区别是：Builder模式强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象，一般来说Builder模式中对象不是直接返回的。而在AbstractFactory模式中对象是直接返回的
C++设计模式之生成器模式（Builder）
波风水门
06-06 2277
生成器是一种创建型设计模式，使你能够分步骤创建复杂对象。该模式允许你使用相同的创建　代码生成不同类型和形式的对象。假设有这样一个复杂对象，在对其进行构造时需要对诸多成员变量和嵌套对象进行繁复的初始化工作。这些初始化代码通常深藏于一个包含众多参数且让人基本看不懂的构造函数中；甚至还有更糟糕的情况，那就是这些代码散落在客户端代码的多个位置。如果为每种可能的对象都创建一个子类，这可能导致程序过于复杂：例如， 我们来思考如何创建一个房屋（House）对象。
设计模式 - 建造者模式（Builder） C++实现
zhaosdfa
06-21 1157
生成器模式（Builder） 意图：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
C++设计者模式——Builder模式
lxn18392641463的博客
03-15 329
在软件设计过程中面临着复杂对象的创建工作：其通常有一些稳定的算法构成，由于需求的变化各个子部分通常会发生剧烈的变化 代码报错："public: __thiscall House::House(void)" (??0House@@QAE@XZ)，该符号在函数 "public: __thiscall StoneHouse::StoneHouse(void)" (??0StoneHouse@@QAE...
C++ 设计模式之建造者模式
最新发布
L_qingting的博客
06-20 612
C++ 设计模式之建造者模式
C++builder XE10随机数生成器教程及实例
在深入分析所给文件内容之前，首先需要澄清的是，文件名称中提到的“C++builder xe10生成随机小数.zip”和文件内的描述“C++builder XE10生成随机小数整数”暗示了这次探讨的焦点是利用Embarcadero C++Builder XE10...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值