C++设计模式12--建造者模式----创建复杂对象的工程师

建造者（Builder）模式

建造者模式可以将一个产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。

对象性质的建造

有些情况下，一个对象会有一些重要的性质，在它们没有恰当的值之前，对象不能作为一个完整的产品使用。比如，一个电子邮件有发件人地址、收件人地址、主题、内容、附录等部分，而在最起码的收件人地址未被赋值之前，这个电子邮件不能发出。

有些情况下，一个对象的一些性质必须按照某个顺序赋值才有意义。在某个性质没有赋值之前，另一个性质则无法赋值。这些情况使得性质本身的建造涉及到复杂的商业逻辑。

这时候，此对象相当于一个有待建造的产品，而对象的这些性质相当于产品的零件，建造产品的过程就是组合零件的过程。由于组合零件的过程很复杂，因此，这些"零件"的组合过程往往被"外部化"到一个称作建造者的对象里，建造者返还给客户端的是一个全部零件都建造完毕的产品对象。

Builder模式的结构：

①建造者（Builder）角色：给出一个抽象接口，以规范产品对象的各个组成成分的建造。一般而言，此接口独立于应用程序的商业逻辑。模式中直接创建产品对象的是具体建造者（ConcreteBuilder）角色。具体建造者类必须实现这个接口所要求的方法：一个是建造方法，另一个是结果返还方法。

②具体建造者（Concrete Builder）角色：担任这个角色的是于应用程序紧密相关的类，它们在应用程序调用下创建产品实例。这个角色主要完成的任务包括：

③实现Builder角色提供的接口，一步一步完成创建产品实例的过程。

在建造过程完成后，提供产品的实例。

指导者（Director）角色：担任这个角色的类调用具体建造者角色以创建产品对象。导演者并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者对象。

④产品（Product）角色：产品便是建造中的复杂对象。

指导者角色是于客户端打交道的角色。导演者角色将客户端创建产品的请求划分为对各个零件的建造请求，再将这些请求委派给具体建造者角色。具体建造者角色是做具体建造工作的，但却不为客户端所知。

程序举例：

该程序演示了Builder模式一步一步完成构件复杂产品的过程。用户可以控制生成过程以及生成不同对象。

《大话设计模式》举了一个很好的例子——建造小人，一共需建造6个部分，头部、身体、左右手、左右脚。

与工厂模式不同，建造者模式是在导向者的控制下一步一步构造产品的。建造小人就是在控制下一步步构造出来的。创建者模式可以能更精细的控制构建过程，从而能更精细的控制所得产品的内部结构。

我们要生成不同的小人

[cpp] view plain copy print ?

// 产品[product]角色
class Person // 待建造的l人
{
public :
void SetHead(std::string head)
{
this->m_head = head;
}
std::string GetHead( )
{
return this->m_head;
}
void SetBody(std::string body)
{
this->m_body = body;
}
std::string GetBody( )
{
return this->m_body;
}
void SetFoot(std::string foot)
{
this->m_foot = foot;
}
std::string GetFoot( )
{
return this->m_foot;
}
void ShowPerson( ) // 显示当前的人的信息
{
std::cout <<"This is a person has" <<std::endl;
std::cout <<"HEAD : "<<this->m_head <<", BODY : " <<this->m_body <<", FOOT : " <<this->m_foot <<std::endl;
}
protected :
std::string m_head; // 人的头
std::string m_body; // 人的躯体
std::string m_foot; // 人的脚
};

// 产品[product]角色
class Person    // 待建造的l人
{
public :
	void SetHead(std::string head)
	{
		this->m_head = head;
	}

	std::string GetHead( )
	{
		return this->m_head;
	}

	void SetBody(std::string body)
	{
		this->m_body = body;
	}

	std::string GetBody( )
	{
		return this->m_body;
	}

	void SetFoot(std::string foot)
	{
		this->m_foot = foot;
	}

	std::string GetFoot( )
	{
		return this->m_foot;
	}

	void ShowPerson( )         // 显示当前的人的信息
	{
		std::cout <<"This is a person has" <<std::endl;
		std::cout <<"HEAD : "<<this->m_head <<", BODY : " <<this->m_body <<", FOOT : " <<this->m_foot <<std::endl;
	}

protected :
    std::string m_head;     // 人的头
    std::string m_body;     // 人的躯体
    std::string m_foot;     // 人的脚
};

不同的小人由不同的建造工程师进行设计

[cpp] view plain copy print ?

// 建造者[build]角色
class Builder // 建造者的基类
{
public :
Builder() // 无参数的构造函数
{
this->m_person = new Person( );
}
virtual ~Builder( ) // 析构函数
{
delete this->m_person;
}
Person*& GetPerson( ) // 获取建造者建造的人对象
{
return this->m_person;
}
virtual void BuildHead( ) = 0; // 建造人的头
virtual void BuildBody( ) = 0; // 建造人的躯体
virtual void BuildFoot( ) = 0; // 建造人的脚
protected :
Person *m_person;
};
// 胖子的实际建造者-=> 具体建造者[Concrete Builder]
class FatBuilder : public Builder
{
public :
FatBuilder() // 无参数的构造函数
:Builder( )
{
// this->m_person = new Person( );
}
virtual ~FatBuilder( ) // 析构函数
{
}
void BuildHead( ) // 建造人的头
{
this->m_person->SetHead("Fat Head");
std::cout <<"Build Fat head..." <<std::endl;
}
void BuildBody( ) // 建造人的躯体
{
this->m_person->SetBody("Fat Body");
std::cout <<"Build Fat body..." <<std::endl;
}
void BuildFoot( ) // 建造人的脚
{
this->m_person->SetFoot("Fat Foot");
std::cout <<"Build Fat foot..." <<std::endl;
}
};
// 瘦人的实际建造者-=>具体建造者[Concrete Builder]
class ThinBuilder : public Builder
{
public :
ThinBuilder( ) // 无参数的构造函数
:Builder( )
{
// this->m_person = new Person( );
}
virtual ~ThinBuilder( ) // 析构函数
{
}
void BuildHead( ) // 建造人的头
{
this->m_person->SetHead("Thin Head");
std::cout <<"Build thin head..." <<std::endl;
}
void BuildBody( ) // 建造人的躯体
{
this->m_person->SetBody("Thin Body");
std::cout <<"Build thin body..." <<std::endl;
}
void BuildFoot( ) // 建造人的脚
{
this->m_person->SetFoot("Thin Foot");
std::cout <<"Build thin foot..." <<std::endl;
}
};

// 建造者[build]角色
class Builder    // 建造者的基类
{
public :
    Builder()             // 无参数的构造函数
    {
        this->m_person = new Person( );
    }

    virtual ~Builder( )      // 析构函数
    {
        delete this->m_person;
    }

    Person*& GetPerson( )            // 获取建造者建造的人对象
    {
        return this->m_person;
    }

    virtual void BuildHead( ) = 0;          // 建造人的头

    virtual void BuildBody( ) = 0;          // 建造人的躯体

    virtual void BuildFoot( ) = 0;          // 建造人的脚

protected :
    Person *m_person;
};

// 胖子的实际建造者-=> 具体建造者[Concrete Builder]
class FatBuilder : public Builder
{
public :
    FatBuilder()             // 无参数的构造函数
    :Builder( )
    {
       // this->m_person = new Person( );
    }

    virtual ~FatBuilder( )      // 析构函数
    {
    }

	void BuildHead( )          // 建造人的头
	{
		this->m_person->SetHead("Fat Head");
		std::cout <<"Build Fat head..." <<std::endl;
	}

	void BuildBody( )         // 建造人的躯体
	{
		this->m_person->SetBody("Fat Body");
		std::cout <<"Build Fat body..." <<std::endl;
	}

	void BuildFoot( )          // 建造人的脚
	{
		this->m_person->SetFoot("Fat Foot");
		std::cout <<"Build Fat foot..." <<std::endl;
	}

};

// 瘦人的实际建造者-=>具体建造者[Concrete Builder]
class ThinBuilder : public Builder
{
public :
    ThinBuilder( )             // 无参数的构造函数
    :Builder( )
    {
       // this->m_person = new Person( );
    }

    virtual ~ThinBuilder( )      // 析构函数
    {
    }

	void BuildHead( )          // 建造人的头
	{
		this->m_person->SetHead("Thin Head");
		std::cout <<"Build thin head..." <<std::endl;
	}

	void BuildBody( )         // 建造人的躯体
	{
		this->m_person->SetBody("Thin Body");
		std::cout <<"Build thin body..." <<std::endl;
	}

	void BuildFoot( )          // 建造人的脚
	{
		this->m_person->SetFoot("Thin Foot");
		std::cout <<"Build thin foot..." <<std::endl;
	}

};

我们有一个向导来控制小人的创建，只要告诉它我们需要什么样的小人，向导会自动为我们设计

[cpp] view plain copy print ?

// 向导
class Director
{
public :
Director(Builder *builder) // 向导类构造函数
{
this->m_builder = builder;
}
void CreatePerson( )
{
this->m_builder->BuildHead( ); // 利用建造者建造人的头
this->m_builder->BuildBody( ); // 利用建造者建造人的躯体
this->m_builder->BuildFoot( ); // 利用建造者建造人的脚
}
protected:
Builder *m_builder; //
};

// 向导
class Director
{
public :
    Director(Builder *builder)          // 向导类构造函数
    {
        this->m_builder = builder;
    }

	void CreatePerson( )
	{
		this->m_builder->BuildHead( );      // 利用建造者建造人的头
		this->m_builder->BuildBody( );      // 利用建造者建造人的躯体
		this->m_builder->BuildFoot( );      // 利用建造者建造人的脚
	}

protected:
    Builder *m_builder;         //
};

下面看看客户端调用的代码

[cpp] view plain copy print ?

int main()
{
std::cout <<"Start create thin person..." <<std::endl;
ThinBuilder thinBuilder;
Director thinDirector(&thinBuilder);
thinDirector.CreatePerson( );
Person *thinPerson = thinBuilder.GetPerson( );
thinPerson->ShowPerson( );
std::cout <<std::endl;
std::cout <<"Start create fat person..." <<std::endl;
FatBuilder fatBuilder;
Director fatDirector(&fatBuilder);
fatDirector.CreatePerson( );
Person *fatPerson = fatBuilder.GetPerson( );
fatPerson->ShowPerson( );
std::cout <<std::endl;
return 0;
}

转载：http://blog.csdn.net/gatieme/article/details/21512591

时间： 2024-09-20 17:54:03

C++设计模式12--建造者模式----创建复杂对象的工程师

建造者（Builder）模式

Builder模式的结构：

程序举例：

C++设计模式12--建造者模式----创建复杂对象的工程师的相关文章

C#设计模式(5)——建造者模式（Builder Pattern）

【秒懂设计模式】建造者模式

深入理解JavaScript系列（27）：设计模式之建造者模式详解

设计模式 ( 十七) 状态模式State（对象行为型）

设计模式：建造者模式（Builder）

乐在其中设计模式(C#) - 建造者模式(Builder Pattern)

C++设计模式之建造者模式_C 语言

设计模式之建造者模式

php设计模式 Builder(建造者模式)