建造者模式

Builder 模式（建造者模式）

生活中有着很多的Builder的例子，个人觉得大学生活就是一个Builder模式的最好体验：要完成大学教育，一般将大学教育过程分成 4 个学期进行，因此没有学习可以看作是构建完整大学教育的一个部分构建过程，每个人经过这 4 年的（4 个阶段）构建过程得到的最后的结果不一样，因为可能在四个阶段的构建中引入了很多的参数（每个人的机会和际遇不完全相同）

Builder 模式要解决的也正是这样的问题：当我们要创建的对象很复杂的时候（通常是由很多其他的对象组合而成），我们要要复杂对象的创建过程和这个对象的表示（展示）分离开来，这样做的好处就是通过一步步的进行复杂对象的构建，由于在每一步的构造过程中可以引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样。

举例：

代码：

//Product.h 
#ifndef _PRODUCT_H_ 
#define _PRODUCT_H_ 
class Product 
{ 
public: 
 Product(); 
 ~Product(); 
 void ProducePart(); 
protected: 
private: 
}; 

class ProductPart 
{ 
public: 
 ProductPart(); 
 ~ProductPart(); 
 ProductPart* BuildPart(); 
protected: 
private: 
}; 
#endif //~_PRODUCT_H_



//Builder.h 
#ifndef _BUILDER_H_ 
#define _BUILDER_H_ 
#include <string>
using namespace std; 
class Product; 
class Builder 
{ 
public: 
 virtual ~Builder(); 
virtual void BuildPartA(const string& 
buildPara) = 0; 
virtual void BuildPartB(const string& 
buildPara) = 0; 
virtual void BuildPartC(const string& 
buildPara) = 0; 
virtual Product* GetProduct() = 0;
protected: 
 Builder(); 
private: 
}; 
class ConcreteBuilder:public Builder 
{ 
public: 
 ConcreteBuilder(); 
 ~ConcreteBuilder(); 
void BuildPartA(const string& 
buildPara);
void BuildPartB(const string& buildPara);
void BuildPartC(const string& buildPara);
 Product* GetProduct(); 
protected: 
private: 
}; 
#endif //~_BUILDER_H_

//Builder.cpp 
#include "Builder.h" 
#include "Product.h" 
#include <iostream> 
using namespace std; 
Builder::Builder() 
{ 
} 
Builder::~Builder() 
{ 
} 
ConcreteBuilder::ConcreteBuilder() 
{ 
} 
ConcreteBuilder::~ConcreteBuilder() 
{ 
} 
void ConcreteBuilder::BuildPartA(const string& buildPara) 
{ 
 cout<<"Step1:Build PartA..."<<buildPara<<endl; 
} 
void ConcreteBuilder::BuildPartB(const string& buildPara) 
{ 
 cout<<"Step1:Build PartB..."<<buildPara<<endl; 
} 
void ConcreteBuilder::BuildPartC(const string& buildPara) 
{ 
 cout<<"Step1:Build PartC..."<<buildPara<<endl; 
} 
Product* ConcreteBuilder::GetProduct() 
{ 
 BuildPartA("pre-defined"); 
 BuildPartB("pre-defined"); 
 BuildPartC("pre-defined"); 
return new Product(); 
}

//Director.h 
#ifndef _DIRECTOR_H_ 
#define _DIRECTOR_H_ 
class Builder; 
class Director 
{ 
public: 
 Director(Builder* bld); 
 ~Director(); 
 void Construct();
protected: 
private: 
 Builder* _bld; 
}; 
#endif //~_DIRECTOR_H_


//Director.cpp 
#include "director.h" 
#include "Builder.h" 
Director::Director(Builder* bld)
{ 
_bld = bld; 
} 
Director::~Director() 
{ 
 
} 
void Director::Construct() 
{ 
 _bld->BuildPartA("user-defined"); 
 _bld->BuildPartB("user-defined"); 
 _bld->BuildPartC("user-defined"); 
}

//main.cpp 
#include "Builder.h" 
#include "Product.h" 
#include "Director.h" 
#include <iostream> 
using namespace std; 
int main(int argc,char* argv[])
{ 
Director* d = new Director(new
ConcreteBuilder()); 
 d->Construct();
 return 0;
}

总结：

Builder 模式的关键是其中的 Director对象并不直接返回对象，而是通过一步步（BuildPartA，BuildPartB，BuildPartC）来一步步进行对象的创建。

Builder 模式的示例代码中，BuildPart 的参数是通过客户程序员传入的，这里使用“user-defined”代替，实际的可在 Construct 方法中传入这 3 个参数，这样就可以得到不同的细微差别的复杂对象了。

Builder 模式和 AbstractFactory 模式在功能上很相似，因为都是用来创建大的复杂的对象，它们的区别是Builder 模式强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象，一般来说 Builder 模式中对象不是直接返回的。而在 AbstractFactory 模式中对象是直接返回的，AbstractFactory 模式强调的是为创建多个相互依赖的对象提供一个同一的接口。

在UE4（Unreal Engine 4）中，C++编程语言常用于构建游戏逻辑和功能。建造者模式是一种设计模式，通常用于创建复杂对象。在UE4中使用建造者模式可以帮助管理复杂对象的创建过程，并提供更好的可维护性和可扩展性。

下面是一个简单的示例，展示如何在UE4中使用C++实现建造者模式：

假设我们正在创建一个游戏中的角色对象，该角色对象具有各种属性，例如名称、生命值、攻击力等。我们将使用建造者模式来构建这样一个角色对象。

// CharacterBuilder.h

#pragma once

#include "CoreMinimal.h"

// Forward declaration of Character class
class ACharacter;

class CharacterBuilder
{
public:
    CharacterBuilder();
    ~CharacterBuilder();

    // Setters for character properties
    void SetName(const FString& Name);
    void SetHealth(float Health);
    void SetAttackDamage(float Damage);

    // Builder method to create the character
    ACharacter* BuildCharacter();

private:
    // Properties to hold character data
    FString Name;
    float Health;
    float AttackDamage;
};

// CharacterBuilder.cpp

#include "CharacterBuilder.h"

CharacterBuilder::CharacterBuilder()
{
    // Initialize properties
    Name = "DefaultName";
    Health = 100.0f;
    AttackDamage = 10.0f;
}

CharacterBuilder::~CharacterBuilder()
{
}

void CharacterBuilder::SetName(const FString& NewName)
{
    Name = NewName;
}

void CharacterBuilder::SetHealth(float NewHealth)
{
    Health = NewHealth;
}

void CharacterBuilder::SetAttackDamage(float Damage)
{
    AttackDamage = Damage;
}

ACharacter* CharacterBuilder::BuildCharacter()
{
    // Create character object and set properties
    ACharacter* NewCharacter = new ACharacter(); // You should use UE4's UObject-based class
    NewCharacter->SetName(Name);
    NewCharacter->SetHealth(Health);
    NewCharacter->SetAttackDamage(AttackDamage);
    return NewCharacter;
}

在上述代码中，我们创建了一个名为CharacterBuilder的类，它负责构建角色对象。该类具有一组setter方法，用于设置角色的各种属性，例如名称、生命值和攻击力。BuildCharacter方法用于实际创建角色对象并将设置的属性应用于其上。

请注意，以上代码只是一个简单示例，实际项目中可能需要更多的功能和错误处理。此外，在UE4中，您应该使用UE4提供的对象（如ACharacter）来构建游戏对象，而不是使用标准的C++对象。