C++ 设计模式——建造者模式

已于 2024-08-18 14:02:07 修改
阅读量1.3k 收藏 19
点赞数 30
分类专栏： # C++ 设计模式 文章标签： c++ 设计模式 建造者模式
于 2024-08-18 14:01:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68194402/article/details/141299021
版权

建造者模式

建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，它允许使用多个简单的对象一步步构建一个复杂的对象。建造者模式通过将对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。

引入“建造者”模式的定义：将一个复杂的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

组成部分

  • 产品（Product）：代表最终构建的复杂对象，包含多个部件和属性。产品类定义了对象的结构和行为，通常包括多个属性和方法。
  • 建造者（Builder）：定义创建产品的各个部件的抽象接口。建造者接口提供了构建不同部分的方法，允许灵活地创建不同类型的产品。
  • 具体建造者（ConcreteBuilder）：实现建造者接口，具体构建和装配产品的各个部件。每个具体建造者负责创建特定类型的产品，同时维护构建过程的状态。
  • 指挥者（Director）：负责管理建造过程，调用建造者的方法以生成产品。指挥者定义构建的顺序，确保产品的构建过程符合预期。

建造者模式使用步骤

1. 定义产品类

首先定义一个复杂对象的类 Monster，它是所有怪物的基类。

//怪物父类
class Monster
{
public:
    virtual ~Monster() {} //做父类时析构函数应该为虚函数
    // 其他方法可以在这里定义
};
2. 创建具体产品类

创建多个具体的怪物类，继承自 Monster 类。

//亡灵类怪物
class M_Undead :public Monster{};

//元素类怪物
class M_Element :public Monster{};

//机械类怪物
class M_Mechanic :public Monster{};
3. 创建建造者接口

定义一个抽象建造者类 MonsterBuilder，声明构建产品各个部分的方法。

//怪物构建器父类
class MonsterBuilder
{
public:
	virtual ~MonsterBuilder() {} //做父类时析构函数应该为虚函数
	//返回指向Monster类的成员变量指针m_pMonster，当一个复杂的对象构建完成后，可以通过该成员函数把对象返回
	Monster* GetResult()
	{
		return m_pMonster;
	}

	virtual void LoadTrunkModel(string strno) = 0;//这里也可以写为空函数体，子类决定是否重新实现
	virtual void LoadHeadModel(string strno) = 0;
	virtual void LoadLimbsModel(string strno) = 0;

protected:
	Monster* m_pMonster;  //指向Monster类的成员变量指针
};
4. 实现具体建造者

创建多个具体建造者类，负责构建不同类型的怪物。

//亡灵类怪物构建器类
class M_UndeadBuilder :public MonsterBuilder
{
public:
	M_UndeadBuilder() //构造函数
	{
		m_pMonster = new M_Undead();
	}

	virtual void LoadTrunkModel(string strno)
	{
		cout << "载入亡灵类怪物的躯干部位模型，需要m_pMonster指针调用M_Undead类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//具体要做的事情其实是委托给怪物子类来完成，委托指把本该自己实现的功能转给其他类实现
		//m_pMonster->......略

	}
	virtual void LoadHeadModel(string strno)
	{
		cout << "载入亡灵类怪物的头部模型并挂接到躯干部位，需要m_pMonster指针调用M_Undead类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
	virtual void LoadLimbsModel(string strno)
	{
		cout << "载入亡灵类怪物的四肢模型并挂接到躯干部位，需要m_pMonster指针调用M_Undead类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
};

//元素类怪物构建器类
class M_ElementBuilder :public MonsterBuilder
{
public:
	M_ElementBuilder() //构造函数
	{
		m_pMonster = new M_Element();
	}

	virtual void LoadTrunkModel(string strno)
	{
		cout << "载入元素类怪物的躯干部位模型，需要m_pMonster指针调用M_Element类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略			
	}
	virtual void LoadHeadModel(string strno)
	{
		cout << "载入元素类怪物的头部模型并挂接到躯干部位，需要m_pMonster指针调用M_Element类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
	virtual void LoadLimbsModel(string strno)
	{
		cout << "载入元素类怪物的四肢模型并挂接到躯干部位，需要m_pMonster指针调用M_Element类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
};
//机械类怪物构建器类
class M_MechanicBuilder :public MonsterBuilder
{
public:
	M_MechanicBuilder() //构造函数
	{
		m_pMonster = new M_Mechanic();
	}

	virtual void LoadTrunkModel(string strno)
	{
		cout << "载入机械类怪物的躯干部位模型，需要m_pMonster指针调用M_Mechanic类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
	virtual void LoadHeadModel(string strno)
	{
		cout << "载入机械类怪物的头部模型并挂接到躯干部位，需要m_pMonster指针调用M_Mechanic类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
	virtual void LoadLimbsModel(string strno)
	{
		cout << "载入机械类怪物的四肢模型并挂接到躯干部位，需要m_pMonster指针调用M_Mechanic类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
};
5. 创建指挥者类

定义一个指挥者类 MonsterDirector，负责管理建造过程。

//指挥者类
class MonsterDirector
{
public:
	MonsterDirector(MonsterBuilder* ptmpBuilder) //构造函数
	{
		m_pMonsterBuilder = ptmpBuilder;
	}

	//指定新的构建器
	void SetBuilder(MonsterBuilder* ptmpBuilder)
	{
		m_pMonsterBuilder = ptmpBuilder;
	}

	//原MonsterBuilder类中的Assemble成员函数
	Monster* Construct(string strmodelno) //参数：模型编号，形如“1253679201245”等，每些位的组合都有一些特别的含义，这里无需深究
	{
		m_pMonsterBuilder->LoadTrunkModel(strmodelno.substr(4, 3));  //载入躯干模型，截取某部分字符串以表示躯干模型的编号
		m_pMonsterBuilder->LoadHeadModel(strmodelno.substr(7, 3));   //载入头部模型并挂接到躯干模型上
		m_pMonsterBuilder->LoadLimbsModel(strmodelno.substr(10, 3)); //载入四肢模型并挂接到躯干模型上
		return m_pMonsterBuilder->GetResult();  //返回构建后的对象
	}
private:
	MonsterBuilder* m_pMonsterBuilder; //指向所有构建器类的父类
};
6. 客户端代码

在客户端中，创建具体建造者和指挥者的实例，使用指挥者构建产品。

int main() 
{
    // 创建亡灵类怪物建造者
    M_UndeadBuilder* undeadBuilder = new M_UndeadBuilder();
    MonsterDirector undeadDirector(undeadBuilder); // 创建亡灵类怪物的指挥者

    // 构建亡灵类怪物
    Monster* undeadMonster = undeadDirector.Construct("1253679201245");
    // 使用构建的亡灵类怪物对象
    // ...

    // 创建元素类怪物的建造者
    M_ElementBuilder* elementBuilder = new M_ElementBuilder();
    MonsterDirector elementDirector(elementBuilder); // 创建元素类怪物的指挥者

    // 构建元素类怪物
    Monster* elementMonster = elementDirector.Construct("1253679201245");
    // 使用构建的元素类怪物对象
    // ...

    // 创建机械类怪物的建造者
    M_MechanicBuilder* mechanicBuilder = new M_MechanicBuilder();
    MonsterDirector mechanicDirector(mechanicBuilder); // 创建机械类怪物的指挥者

    // 构建机械类怪物
    Monster* mechanicMonster = mechanicDirector.Construct("1253679201245");
    // 使用构建的机械类怪物对象
    // ...

    // 清理资源
    delete undeadMonster; // 释放亡灵类怪物对象
    delete elementMonster; // 释放元素类怪物对象
    delete mechanicMonster; // 释放机械类怪物对象
    delete undeadBuilder; // 释放亡灵类建造者对象
    delete elementBuilder; // 释放元素类建造者对象
    delete mechanicBuilder; // 释放机械类建造者对象

    return 0;
}

建造者模式 UML 图

建造者模式 UML 图

建造者模式 UML 图解析

  • Builder (抽象构建器)：
    • MonsterBuilder 类定义了创建产品对象的各个部件的抽象接口，包括方法如 LoadTrunkModel、LoadHeadModel、LoadLimbsModel。同时，它还定义了 GetResult 接口，用于返回所创建的复杂对象。
  • ConcreteBuilder (具体构建器)：
    • 具体构建器类（如 M_UndeadBuilder、M_ElementBuilder、M_MechanicBuilder）实现了 MonsterBuilder 接口，负责具体的构造和装配过程。每个具体构建器定义了其所创建的复杂对象（如 M_Undead、M_Element、M_Mechanic），并可能提供方法返回创建好的复杂对象。
  • Product (产品)：
    • 产品类指被构建的复杂对象，包含多个部件。具体构建器负责创建该产品的内部表示并定义它的装配过程。例如，M_Undead、M_Element、M_Mechanic 类分别表示不同类型的怪物。
  • Director (指挥者)：
    • MonsterDirector 类是指挥者，持有一个指向抽象构建器的引用（如 m_pMonsterBuilder）。它利用该引用在 Construct 成员函数中调用构建器对象的方法，完成复杂对象的构建。指挥者控制构建过程的顺序，确保各个部件按正确的顺序装配。例如，Construct 函数中会依次调用 LoadTrunkModel、LoadHeadModel 和 LoadLimbsModel。
  • 客户端：
    • 在客户端（如 main 函数）中，用户只需生成一个具体的构建器对象，并利用该构建器对象创建指挥者对象，调用指挥者的 Construct 方法，就可以构建出所需的复杂对象。这种设计使得客户端与具体实现解耦，提高了灵活性和可维护性。

建造者模式的优缺点

优点：

  • 解耦：建造者模式将复杂对象的构建与表示分离，使得构建过程与产品的表示相互独立，降低了模块间的耦合度。
  • 灵活性：可以通过更换具体建造者来灵活地构建不同类型的产品，而无需修改指挥者或客户端代码。
  • 可读性和可维护性：通过清晰的接口和结构，增加了代码的可读性，便于后续的维护和扩展。
  • 支持复杂对象的构建：适合构建复杂对象，特别是那些具有多个部件和装配顺序要求的对象。
  • 步骤控制：指挥者可以控制构建的步骤和顺序，确保复杂对象按照预期的方式构建。

缺点：

  • 复杂性：对于简单对象的构建，使用建造者模式可能显得过于复杂，增加了不必要的代码和结构。
  • 类的数量增加：需要创建多个具体建造者类和产品类，可能导致类的数量增加，增加了系统的复杂性。
  • 构建过程固定：一旦定义了指挥者的构建过程，可能不够灵活，难以适应一些动态变化的需求。

建造者模式的适用场景

  • 构建复杂对象：当对象由多个部件组成，且构建和组合过程复杂时，例如游戏中的角色（如怪物、NPC）。
  • 产品变体多样化：当需要创建多种不同类型的产品，但构建过程相似时，例如不同类型的车辆（轿车、卡车、摩托车）。
  • 构建过程需要控制：当构建过程需要明确的步骤和顺序时，例如根据不同条件动态调整构建顺序。
  • 对象的构建与表示分离：当产品的构建与表示需要解耦，以便于后续维护和扩展，例如构建复杂文档时。
  • 逐步构建对象：当对象的构建过程需要分步进行，或在构建过程中进行条件判断时，例如配置复杂系统。
  • 需要灵活的对象创建：当需要在运行时决定构建哪种类型的对象时，例如根据用户输入或配置文件动态选择不同的构建器。

完整代码

#include <iostream>
#include <string>

using namespace std;

//怪物父类
class Monster
{
public:
	virtual ~Monster() {} //做父类时析构函数应该为虚函数
	//void Assemble(string strmodelno) //参数：模型编号，形如“1253679201245”等，每些位的组合都有一些特别的含义，这里无需深究
	//{
	//	LoadTrunkModel(strmodelno.substr(4, 3));  //载入躯干模型，截取某部分字符串以表示躯干模型的编号
	//	LoadHeadModel(strmodelno.substr(7, 3));   //载入头部模型并挂接到躯干模型上
	//	LoadLimbsModel(strmodelno.substr(10, 3)); //载入四肢模型并挂接到躯干模型上
	//}

	//virtual void LoadTrunkModel(string strno) = 0; //这里也可以写为空函数体，子类决定是否重新实现
	//virtual void LoadHeadModel(string strno) = 0;
	//virtual void LoadLimbsModel(string strno) = 0;
};

//亡灵类怪物
class M_Undead :public Monster
{
	/*public:
		virtual void LoadTrunkModel(string strno)
		{
			cout << "载入亡灵类怪物的躯干部位模型，需要调用M_Undead类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		}
		virtual void LoadHeadModel(string strno)
		{
			cout << "载入亡灵类怪物的头部模型并挂接到躯干部位，需要调用M_Undead类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		}
		virtual void LoadLimbsModel(string strno)
		{
			cout << "载入亡灵类怪物的四肢模型并挂接到躯干部位，需要调用M_Undead类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		}*/
};

//元素类怪物
class M_Element :public Monster
{
	/*public:
		virtual void LoadTrunkModel(string strno)
		{
			cout << "载入元素类怪物的躯干部位模型，需要调用M_Element类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		}
		virtual void LoadHeadModel(string strno)
		{
			cout << "载入元素类怪物的头部模型并挂接到躯干部位，需要调用M_Element类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		}
		virtual void LoadLimbsModel(string strno)
		{
			cout << "载入元素类怪物的四肢模型并挂接到躯干部位，需要调用M_Element类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		}*/
};

//机械类怪物
class M_Mechanic :public Monster
{
	/*public:
		virtual void LoadTrunkModel(string strno)
		{
			cout << "载入机械类怪物的躯干部位模型，需要调用M_Mechanic类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		}
		virtual void LoadHeadModel(string strno)
		{
			cout << "载入机械类怪物的头部模型并挂接到躯干部位，需要调用M_Mechanic类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		}
		virtual void LoadLimbsModel(string strno)
		{
			cout << "载入机械类怪物的四肢模型并挂接到躯干部位，需要调用M_Mechanic类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		}*/
};


//-----------------
//怪物构建器父类
class MonsterBuilder
{
public:
	virtual ~MonsterBuilder() {} //做父类时析构函数应该为虚函数
	//void Assemble(string strmodelno) //参数：模型编号，形如“1253679201245”等，每些位的组合都有一些特别的含义，这里无需深究
	//{
	//	LoadTrunkModel(strmodelno.substr(4, 3));  //载入躯干模型，截取某部分字符串以表示躯干模型的编号
	//	LoadHeadModel(strmodelno.substr(7, 3));   //载入头部模型并挂接到躯干模型上
	//	LoadLimbsModel(strmodelno.substr(10, 3)); //载入四肢模型并挂接到躯干模型上
	//}
	//返回指向Monster类的成员变量指针m_pMonster，当一个复杂的对象构建完成后，可以通过该成员函数把对象返回
	Monster* GetResult()
	{
		return m_pMonster;
	}

	virtual void LoadTrunkModel(string strno) = 0;//这里也可以写为空函数体，子类决定是否重新实现
	virtual void LoadHeadModel(string strno) = 0;
	virtual void LoadLimbsModel(string strno) = 0;

protected:
	Monster* m_pMonster;  //指向Monster类的成员变量指针
};

//---------------
//亡灵类怪物构建器类
class M_UndeadBuilder :public MonsterBuilder
{
public:
	M_UndeadBuilder() //构造函数
	{
		m_pMonster = new M_Undead();
	}

	virtual void LoadTrunkModel(string strno)
	{
		cout << "载入亡灵类怪物的躯干部位模型，需要m_pMonster指针调用M_Undead类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//具体要做的事情其实是委托给怪物子类来完成，委托指把本该自己实现的功能转给其他类实现
		//m_pMonster->......略

	}
	virtual void LoadHeadModel(string strno)
	{
		cout << "载入亡灵类怪物的头部模型并挂接到躯干部位，需要m_pMonster指针调用M_Undead类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
	virtual void LoadLimbsModel(string strno)
	{
		cout << "载入亡灵类怪物的四肢模型并挂接到躯干部位，需要m_pMonster指针调用M_Undead类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
};

//元素类怪物构建器类
class M_ElementBuilder :public MonsterBuilder
{
public:
	M_ElementBuilder() //构造函数
	{
		m_pMonster = new M_Element();
	}

	virtual void LoadTrunkModel(string strno)
	{
		cout << "载入元素类怪物的躯干部位模型，需要m_pMonster指针调用M_Element类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略			
	}
	virtual void LoadHeadModel(string strno)
	{
		cout << "载入元素类怪物的头部模型并挂接到躯干部位，需要m_pMonster指针调用M_Element类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
	virtual void LoadLimbsModel(string strno)
	{
		cout << "载入元素类怪物的四肢模型并挂接到躯干部位，需要m_pMonster指针调用M_Element类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
};
//机械类怪物构建器类
class M_MechanicBuilder :public MonsterBuilder
{
public:
	M_MechanicBuilder() //构造函数
	{
		m_pMonster = new M_Mechanic();
	}

	virtual void LoadTrunkModel(string strno)
	{
		cout << "载入机械类怪物的躯干部位模型，需要m_pMonster指针调用M_Mechanic类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
	virtual void LoadHeadModel(string strno)
	{
		cout << "载入机械类怪物的头部模型并挂接到躯干部位，需要m_pMonster指针调用M_Mechanic类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
	virtual void LoadLimbsModel(string strno)
	{
		cout << "载入机械类怪物的四肢模型并挂接到躯干部位，需要m_pMonster指针调用M_Mechanic类或其父类中其他诸多成员函数，逻辑代码略......" << endl;
		//m_pMonster->......略
	}
};

//指挥者类
class MonsterDirector
{
public:
	MonsterDirector(MonsterBuilder* ptmpBuilder) //构造函数
	{
		m_pMonsterBuilder = ptmpBuilder;
	}

	//指定新的构建器
	void SetBuilder(MonsterBuilder* ptmpBuilder)
	{
		m_pMonsterBuilder = ptmpBuilder;
	}

	//原MonsterBuilder类中的Assemble成员函数
	Monster* Construct(string strmodelno) //参数：模型编号，形如“1253679201245”等，每些位的组合都有一些特别的含义，这里无需深究
	{
		m_pMonsterBuilder->LoadTrunkModel(strmodelno.substr(4, 3));  //载入躯干模型，截取某部分字符串以表示躯干模型的编号
		m_pMonsterBuilder->LoadHeadModel(strmodelno.substr(7, 3));   //载入头部模型并挂接到躯干模型上
		m_pMonsterBuilder->LoadLimbsModel(strmodelno.substr(10, 3)); //载入四肢模型并挂接到躯干模型上
		return m_pMonsterBuilder->GetResult();  //返回构建后的对象
	}
private:
	MonsterBuilder* m_pMonsterBuilder; //指向所有构建器类的父类
};

int main()
{
	// 创建具体建造者
	M_UndeadBuilder* undeadBuilder = new M_UndeadBuilder();
	MonsterDirector undeadDirector(undeadBuilder); // 创建亡灵类怪物的指挥者

	// 构建亡灵类怪物
	Monster* undeadMonster = undeadDirector.Construct("1253679201245");
	// 使用构建的亡灵类怪物对象
	// ...

	// 创建元素类怪物的建造者
	M_ElementBuilder* elementBuilder = new M_ElementBuilder();
	MonsterDirector elementDirector(elementBuilder); // 创建元素类怪物的指挥者

	// 构建元素类怪物
	Monster* elementMonster = elementDirector.Construct("1253679201245");
	// 使用构建的元素类怪物对象
	// ...

	// 创建机械类怪物的建造者
	M_MechanicBuilder* mechanicBuilder = new M_MechanicBuilder();
	MonsterDirector mechanicDirector(mechanicBuilder); // 创建机械类怪物的指挥者

	// 构建机械类怪物
	Monster* mechanicMonster = mechanicDirector.Construct("1253679201245");
	// 使用构建的机械类怪物对象
	// ...

	// 清理资源
	delete undeadMonster; // 释放亡灵类怪物对象
	delete elementMonster; // 释放元素类怪物对象
	delete mechanicMonster; // 释放机械类怪物对象
	delete undeadBuilder; // 释放亡灵类建造者对象
	delete elementBuilder; // 释放元素类建造者对象
	delete mechanicBuilder; // 释放机械类建造者对象

	return 0;
}
不是仙人的闲人
关注
专栏目录
C++建造者模式
萧海的博客
10-26 244
头文件： #ifndef CBUILDERMODE_H #define CBUILDERMODE_H /* * 建造者模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 * 一段晦涩难懂的文字，实现创建不同表示的方法就是给创建的过程传入创建的参数。 CCarModel实现模板方法，Builder负责开始建造产品。建造产品时，构建的顺序由Director或main 决定。建造者模式和抽象工厂非常类似。建造者更重视产品建造时的逻辑顺序， 而抽象工厂更重视生产出不同型号的产品，抽
C++设计模式——建造者模式(Builder模式)
赵小厨的博客
10-05 732
Builder模式
建造者模式（C++）
蜗牛也是牛
01-30 187
建造者模式（C++） 　　建造者模式：将复杂的对象的表示和它的实现相分离，使其在同样的构建下可以构建不通的表示。 　　上面的话可能不是很明白，举个例子就明白了。假设一个公司的软件项目流程是固定的，都需要经过需求理解、需求设计、需求审核、编码、测试这个五个步骤，但是这个公司是一个一级供应商，在拿到项目后，有些模块需要承包给二级供应商，如HMI、Med...
Builder建造者模式
tianmo2010的专栏
03-26 759
mysql编码设置   MySQL的默认编码是Latin1，不支持中文，那么如何修改MySQL的默认编码呢，下面以UTF-8为例来说明   需要注意的是，要修改的地方非常多，相应的修改方法也很多。下面是一种最简单最彻底的方法：   一、Windows 1、中止MySQL服务 2、在MySQL的安装目录下找到my.ini，如果没有就把my-medium.ini复制为一个my.ini即
c++ 建造者模式
qq_40754866的博客
05-31 2950
一、建造者模式 Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建模式之一，用来隐藏复合对象的创建过程。他把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。 对象的创建：Builder模式是为了对象的创建而设计的模式-创建的是一个复合对象，被创建的对象为一个具有复合属性的复合对象，关注对象创建的各个部分的创建过程，不同工厂(Builder)对产品属性有不同的创建方法。 Builder：为创建产品各个部
【C++】—— 建造者模式
最新发布
m0_56069910的博客
03-12 636
建造者模式详解
设计模式——建造者模式
GodTheTang的博客
12-13 216
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。 介绍 意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变
大话设计模式 —— 第十三章《建造者模式》C++ 代码实现
TAOTAO
04-10 419
目录 简介 主要作用 优点 缺点 使用场景 建造者模式与工厂模式的区别 简介 建造者（也叫生成器模式，属于创建型模式）模式：将一个复杂对象的构建过程与它的构建细节分离，使得同样的构建过程可以执行不同的表示。 首先，将复杂对象的创建过程和部件的表示分离出来，其实就是把创建过程和自身的部件解耦，使得构建过程和部件都可以自由扩展，两者之间的耦合降到最低。然后，再是相同的构建过程可以创建...
我所理解的设计模式（C++实现）——建造者模式（Builder Pattern）
runfeel
04-04 213
解决的问题： 我创建的这个对象比较复杂，且该对象里面的成员函数用不同的实现来表示不同的实例，换句话说就是同样的对象构建过程可以有不同的表示。比如我那天去吃过桥米线，他们有不同的套餐，套餐里包含的种类是一样的，都有一碗米线，一份凉菜，一杯饮料。但是不同的套餐里这3样又都不是全部一样的。此时我们就可以用建造者模式。 类图结构： 1．建造者（Builder）角色：给出一个抽象接口，以规...
[C++]建造者模式
就是那个党伟
04-11 323
建造者模式，是将一个复杂的对象的构建与它的表示分离，使 得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。 C++代码如下： // 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // // 参考大话设计模式 #include <iostream> ...
建造者模式
weixin_34293911的博客
03-16 127
建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。这是建造者模式的标准表达，不过看着让人迷惑，什么叫构建和表示的分离？一个对象使用构造函数构造之后不就固定了，只有通过它方法来改变它的属性吗？而且还要同样的构建过程搞出不同的表示，怎么可能呢？多写几个构造函数？ 其实多写几个构造函数，根据不同参数设置对象不同的属性，也可以达到这样的效果，只是这样就非常麻烦了，每次...
C++中的建造者模式
tmh_15195862719的博客
08-13 488
建造者模式也成为Builder模式或者生成器模式。建造者模式是一种对象创建型模式，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，可以通过子类继承和重载的方式动态地创建具有复合属性的对象。 建造者模式的作用是将一个复杂对象的构建与它的表示分离，使的同样的构建过程可以创建不同的表示。 #include&lt;iostream&gt; using namespace std; cla...
C++实现建造者模式
Coulnaut的博客
04-22 417
本类型的最后一个模式，最后一节进行总结。 文章目录1. 建造者模式2. 构建器建造房子3. 大总结 1. 建造者模式   将一个复杂的构建与其表示相分离，使得同样的构建过程（稳定）可以创建不同（变化）的表示。建造者模式或者说构建起模式，构建过程就是设计模式一直强调的就是依赖稳定，不同的创建表示就是变化。   看到后面的实现过程，可能心中会有一个疑问，**建造者模式和模板方法模式有什么区别？**这个问题其实在实现的过程中也许就已经有答案，我会在最后进行做出自己的解释欢迎探讨。 2. 构建器建造房子   假.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值