Builder Pattern(建造者模式)

/*Product.h*/
#ifndef PRODUCT_H
#define PRODUCT_H

class Product
{
public:
    Product();
    ~Product();
protected:
private:
};
#endif
/*Product.cpp*/
#include "Product.h"

Product::Product()
{
}

Product::~Product()
{
}
/*Builder.h*/
#ifndef BUILDER_H
#define BUILDER_H
#include <string>

class Product
{
public:
    virtual ~Builder();
    virtual void BuildPartA(const string &build_para)=0;
    virtual void BuildPartB(const string &build_para)=0;
    virtual void BuildPartC(const string &build_para)=0;
    virtual Product *GetProduct()=0;
protected:
    Builder();
private:
};

class ConcreteBuilder:public Builder
{
public:
    ConcreteBuilder();
    ~ConcreteBuilder();
    void BuilderPartA(const string &build_para);
    void BuilderPartB(const string &build_para);
    void BuilderPartC(const string &build_para);
    Product *GetProduct();
};
#endif
/*Builder.cpp*/
#include "Builder.h"
#include "Product.h"
#include <iostream>

Builder::Builder()
{
}

Builder::~Builder()
{
}

ConcreteBuilder::ConcreteBuilder()
{
}

ConcreteBuilder::~ConcreteBuilder()
{
}

ConcreteBuilder::BuildPartA(const string &build_para)
{
    std::cout<<"build_para"<<std::endl;
}

ConcreteBuilder::BuildPartB(const string &build_para)
{
    std::cout<<"build_para"<<std::endl;
}

ConcreteBuilder::BuildPartC(const string &build_para)
{
    std::cout<<"build_para"<<std::endl;
}

ConcreteBuilder *ConcreteBuilder::GetProduct()
{
    BuildPartA("Defined");
    BuildPartB("Defined");
    BuildPartC("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.cpp*/
#include "Diretor.h"
#include "Builder.h"

Director::Director(Builder *bld)
{
    bld_=bld;
}

Director::~Director()
{
}

void Director::Construct()
{
    bld_->BuildPartA("Defined");
    bld_->BuildPartB("Defined");
    bld_->BuildPartC("Defined");
}
/*main.cpp*/
#include <iostream>
#include "Product.h"
#include "Builder.h"
#include "Director.h"

int main()
{
    Director *d=new Director(new ConcreteBuilder());
    d->Construct();
    return 0;
}
时间: 2024-11-04 00:46:40

Builder Pattern(建造者模式)的相关文章

设计模式(五)Builder Pattern建造者模式

在我们日常生活中,如构建一个飞船,一个手机,一栋建筑,都会有非常复杂的组装,这时候应该用到建造者模式 以建造一个飞船为例 案例:造小页飞船 1.飞船各部分元件 package com.littlepage.BuilderPattern; public interface AirShipBuilder { Engine builderEngine(); OrbitalModule builderOrbitalModule(); Escape builderEscape(); } 2.飞船实体用来组

Builder(建造者模式)

public interface Builder { public void buildHead(); public void buildBody(); public void buildHand(); public void buildFoot(); public Person buildPerson(); } public class ManBuilder implements Builder{ Person person; public ManBuilder(){ person = new

设计模式(5):建造者模式

建造者模式: 定义: 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 类图: 4个角色: 1.Product产品类 通常是实现了模板方法模式. 2.Builder抽象建造者 规范产品的组建,一般是由子类实现. 3.ConcreateBuilder 实现抽象类定义的所有方法,并且返回一个组件好的对象. 4.Director导演类 负责安排已有模块的顺序,然后告诉Builder开始建造. //产品类 class Product { public void doSometh

C#设计模式之创建类模式:建造者模式

无论在现实世界中还是软件工程中,都存在一些复杂对象,他们拥有多个组成部分,例如汽车.电脑.冰箱.洗衣机等.他们包含了大量的零部件.对于大部分用户而言,他们并不知道这些部件的装配细节,也几乎不会适用单独某部件,而是使用一辆完整的汽车,一个完整的冰箱或洗衣机.如何将这些部件组装成一个完整的产品并返回给客户,是建造者模式需要解决的问题,建造者模式可以将部件本身和他们的组装过程分开,它关注如何一步步创建一个包含多个组成部分的复杂对象,用户只需要指定复杂对象的类型即可得到该对象,而不是知道其内部的实现细节

建造者模式(Builder Pattern)

一. 建造者(Builder)模式 建造者模式(Builder)将复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示.在软件系统中,有时候面临一个复杂对象的创建工作,该对象通常由各个部分子对象用一定的算法构成,或者按一定的步骤组合而成:这些算法和步骤是稳定的,而构成这个对象的子对象却经常由于需求的变化而不断变化. 二.建造者模式的结构 建造者模式参与者: ◊ Builder:为创建一个Product对象的各个部件指定抽象接口: ◊ ConcreteBuilder ° 实现Builde

.NET设计模式 第二部分 创建型模式(3)—建造者模式(Builder Pattern)

建造者模式(Builder Pattern) ——.NET设计模式系列之四 Terrylee,2005年12月17日 概述 在软件系统中,有时候面临着“一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成:由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法确相对稳定.如何应对这种变化?如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化,从而保持系统中的“稳定构建算法”不随着需求改变而改变?这就是要说的建造者模式. 本文通过现实生活中的买

第4章 建造者模式(Builder Pattern)

原文 第4章 建造者模式(Builder Pattern) 定义 将一个复杂对象的构造与它的表示分离,使同样的构建过程可以创建不同的表示,这样的设计模式被称为建造者模式. 实用范围 1 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时. 2 当构造过程必须允许被构造的对象有不同表示时. 角色 在这样的设计模式中,有以下几个角色: 1 builder:为创建一个产品对象的各个部件指定抽象接口. 2 ConcreteBuilder:实现Builder的接口以构造和装配该产品的各个部

.NET设计模式(4):建造者模式(Builder Pattern)(转)

概述 在软件系统中,有时候面临着“一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成:由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法确相对稳定.如何应对这种变化?如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化,从而保持系统中的“稳定构建算法”不随着需求改变而改变?这就是要说的建造者模式. 本文通过现实生活中的买KFC的例子,用图解的方式来诠释建造者模式. 意图 将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表

深入浅出设计模式——建造者模式(Builder Pattern)

模式动机无论是在现实世界中还是在软件系统中,都存在一些复杂的对象,它们拥有多个组成部分,如汽车,它包括车轮.方向盘.发送机等各种部件.而对于大多数用户而言,无须知道这些部件的装配细节,也几乎不会使用单独某个部件,而是使用一辆完整的汽车,可以通过建造者模式对其进行设计与描述,建造者模式可以将部件和其组装过程分开,一步一步创建一个复杂的对象.用户只需要指定复杂对象的类型就可以得到该对象,而无须知道其内部的具体构造细节. 在软件开发中,也存在大量类似汽车一样的复杂对象,它们拥有一系列成员属性,这些成员

【java类的设计模式—02】建造者模式(Builder pattern)

参考1:http://en.wikipedia.org/wiki/Builder_pattern 参考2:http://www.cnblogs.com/devinzhang/archive/2012/01/06/2314670.html 建造者模式通过一个builder的对象对大量构造器一步一步执行并返回构造的结果.The intent of the Builder design pattern is toseparate the construction of a complex object