设计模式之六：原型模式(Prototype)

最新推荐文章于 2024-05-28 00:15:00 发布
最新推荐文章于 2024-05-28 00:15:00 发布
阅读量933 收藏
点赞数
分类专栏： 设计模式 设计模式（C++） 文章标签： 设计模式 原型模式 Prototype
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012501459/article/details/46383025
版权

原型模式：使用原型实例来指定创建对象的种类，并通过拷贝这个对象的值来创建新的对象。

Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prototype.

UML图：

这里写图片描述

主要包括

  1. Prototype:定义了一个包含克隆自身的接口
  2. ConcretePrototype：具体的原型类，实现了克隆自身函数的类
  3. Client：通过一个具体的原型实例来克隆自身。

其它语言针对上面的克隆有专门的函数，但是C++好像没有。针对上面的克隆函数，C++中可以通过拷贝构造函数来实现。而拷贝构造函数又涉及到了浅拷贝和深拷贝的问题。

先看看浅拷贝的克隆模式的C++代码实现：

#include <iostream>
#include <string>

using namespace std;
class Prototype
{
    public:
            Prototype(string str=""):id(str)
            {
            }
            //对C++而言需要返回指针
            virtual Prototype * clone()=0;
            string getId() const
            {
                return id;
            }
    private:
            string id;

};

class ConcretePrototype1:public Prototype
{
    public:
            ConcretePrototype1(string str=""):Prototype(str)
            {

            }
            Prototype * clone()
            {
                std::cout<<"ConcretePrototype1::clone()"<<std::endl;
                return new ConcretePrototype1(*this);
            }
};

class ConcretePrototype2:public Prototype
{
    public:
            ConcretePrototype2(string str=""):Prototype(str)
            {

            }
            Prototype * clone()
            {
                std::cout<<"ConcretePrototype2::clone()"<<std::endl;
                return new ConcretePrototype2(*this);
            }
};

int main()
{
    std::cout<<"原型模式测试"<<std::endl;
    ConcretePrototype1* cp1=new ConcretePrototype1("001");
    ConcretePrototype1* cp11=dynamic_cast<ConcretePrototype1 *>(cp1->clone());

    ConcretePrototype2* cp2=new ConcretePrototype2("002");
    ConcretePrototype2* cp22=dynamic_cast<ConcretePrototype2 *>(cp2->clone());

    delete cp1;
    delete cp11;
    delete cp2;
    delete cp22;
    return 0;
}

执行代码如下：
这里写图片描述
但是当代码中有自定义类型的指针成员变量时需要注意一个浅拷贝和深拷贝的问题，这个问题的实质是C++中的拷贝构造函数只是执行简单的按位复制操作（即浅拷贝），当成员变量中含有指针类型的数据时，它也只是简单的复制一下指针的值，不会复制一份指针所指向的内存（深拷贝）。
考虑下面的代码：
这对代码最后输出对象cp1和cp11更改前后的三项信息：

  1. 成员变量pChar的地址
  2. 成员变量data的地址
  3. 成员变量data所指向内存区域的值name和info

可以发现更改cp11中成员变量data的name字段后cp1中的成员变量data的name字段也发生了变化，这是由于data指向的是同一块内存区域，根据它们的地址信息可以很直观的看出这一点。

#include <iostream>
#include <string>
#include <stdlib.h>
#include <stdio.h>

using namespace std;

class Data
{
        public:
        Data(string n,string i):name(n),info(i)
        {

        }
                string name;
                string info;
};

class Prototype
{
    public:
            Prototype()
            {

            }
            Prototype(char *point):pChar(point)
            {
            }
            //对C++而言需要返回指针
            virtual Prototype * clone()=0;
            char * getPchar() const 
            {
                return pChar;
            }
            void setPchar(char * ch)
            {
                pChar=ch;
            }
            Data * getData() const
            {
                return data;
            }
            void setData(Data *d)
            {
                data=d;
            }
    private:
            char * pChar;
            Data * data;

};

class ConcretePrototype1:public Prototype
{
    public:
            ConcretePrototype1()
            {

            }
            ConcretePrototype1(char * point):Prototype(point)
            {

            }
            Prototype * clone()
            {
                std::cout<<"ConcretePrototype1::clone()"<<std::endl;
                return new ConcretePrototype1(*this);
            }
};


int main()
{
    std::cout<<"原型模式测试"<<std::endl;
    char p1[]="hello";
    char p2[]="world";
    Data data1("Bill","Microsofe");
    ConcretePrototype1* cp1=new ConcretePrototype1(p1);
    cp1->setData(&data1);
    ConcretePrototype1* cp11=dynamic_cast<ConcretePrototype1 *>(cp1->clone());

    std::cout<<"cp1 information:------------------"<<std::endl;
    printf("cp1->pChar address:%p\n",cp1->getPchar());
    printf("cp1->data address:%p\n",cp1->getData());
    std::cout<<"cp1->data->name:"<<cp1->getData()->name<<"    cp1->data->info    "<<cp1->getData()->info<<std::endl;

    std::cout<<"cp11 information:------------------"<<std::endl;
    printf("cp11->pChar address:%p\n",cp11->getPchar());
    printf("cp11->data address:%p\n",cp11->getData());
    std::cout<<"cp11->data->name:"<<cp11->getData()->name<<"    cp11->data->info    "<<cp11->getData()->info<<std::endl;

    cp11->setPchar(p2);
    cp11->getData()->name="change to John"; 

    std::cout<<"cp11 change:----------------"<<std::endl;
    std::cout<<"cp1 information:------------------"<<std::endl;
    printf("cp1->pChar address:%p\n",cp1->getPchar());
    printf("cp1->data address:%p\n",cp1->getData());
    std::cout<<"cp1->data->name:"<<cp1->getData()->name<<"    cp1->data->info    "<<cp1->getData()->info<<std::endl;

    std::cout<<"cp11 information:------------------"<<std::endl;
    printf("cp11->pChar address:%p\n",cp11->getPchar());
    printf("cp11->data address:%p\n",cp11->getData());
    std::cout<<"cp11->data->name:"<<cp11->getData()->name<<"    cp11->data->info    "<<cp11->getData()->info<<std::endl;


    delete cp1;
    delete cp11;
    return 0;
}

输出信息：
这里写图片描述

针对上面的问题需要使用C++中的深拷贝，即自己重新定义拷贝构造函数：

#include <iostream>
#include <string>
#include <stdlib.h>
#include <stdio.h>

using namespace std;

class Data
{
        public:
        Data()
        {

        }
        Data(string n,string i):name(n),info(i)
        {

        }
                string name;
                string info;
};

class Prototype
{
    public:
            Prototype()
            {

            }
            Prototype(char *point):pChar(point)
            {
            }
            Prototype(const Prototype& rhs)
            {
                //下面这条代码是关键，又重新分配了一块内存区域
                data=new Data(*rhs.getData());
                pChar=rhs.getPchar();
            }
            //对C++而言需要返回指针
            virtual Prototype * clone()=0;
            char * getPchar() const 
            {
                return pChar;
            }
            void setPchar(char * ch)
            {
                pChar=ch;
            }
            Data * getData() const
            {
                return data;
            }
            void setData(Data *d)
            {
                data=d;
            }
    private:
            char * pChar;
            Data * data;

};

class ConcretePrototype1:public Prototype
{
    public:
            ConcretePrototype1()
            {

            }
            ConcretePrototype1(char * point):Prototype(point)
            {

            }
            ConcretePrototype1(const ConcretePrototype1 & rhs):Prototype(rhs)
            {

            }
            Prototype * clone()
            {
                std::cout<<"ConcretePrototype1::clone()"<<std::endl;
                return new ConcretePrototype1(*this);
            }
};


int main()
{
    std::cout<<"原型模式测试"<<std::endl;
    char p1[]="hello";
    char p2[]="world";
    Data data1("Bill","Microsofe");
    ConcretePrototype1* cp1=new ConcretePrototype1(p1);
    cp1->setData(&data1);
    ConcretePrototype1* cp11=dynamic_cast<ConcretePrototype1 *>(cp1->clone());

    std::cout<<"cp1 information:------------------"<<std::endl;
    printf("cp1->pChar address:%p\n",cp1->getPchar());
    printf("cp1->data address:%p\n",cp1->getData());
    std::cout<<"cp1->data->name:"<<cp1->getData()->name<<"    cp1->data->info    "<<cp1->getData()->info<<std::endl;

    std::cout<<"cp11 information:------------------"<<std::endl;
    printf("cp11->pChar address:%p\n",cp11->getPchar());
    printf("cp11->data address:%p\n",cp11->getData());
    std::cout<<"cp11->data->name:"<<cp11->getData()->name<<"    cp11->data->info    "<<cp11->getData()->info<<std::endl;

    cp11->setPchar(p2);
    cp11->getData()->name="change to John"; 

    std::cout<<"cp11 change:----------------"<<std::endl;
    std::cout<<"cp1 information:------------------"<<std::endl;
    printf("cp1->pChar address:%p\n",cp1->getPchar());
    printf("cp1->data address:%p\n",cp1->getData());
    std::cout<<"cp1->data->name:"<<cp1->getData()->name<<"    cp1->data->info    "<<cp1->getData()->info<<std::endl;

    std::cout<<"cp11 information:------------------"<<std::endl;
    printf("cp11->pChar address:%p\n",cp11->getPchar());
    printf("cp11->data address:%p\n",cp11->getData());
    std::cout<<"cp11->data->name:"<<cp11->getData()->name<<"    cp11->data->info    "<<cp11->getData()->info<<std::endl;


    delete cp1;
    delete cp11;
    return 0;
}

执行代码如下，可以发现在克隆时cp1和cp11中data成员变量的地址就不一样了，这样更改cp11中的data成员后cp1中的data成员没有发生变化，这就是深拷贝了。
这里写图片描述

vincent-xia
关注
专栏目录
原型（Prototype）模式
旅行人生
10-13 1346
一、 原型（Prototype）模式原型模式的用意是：通过给出一个原型对象来指明所要创建的对象类型，然后用复制这个原型对象的办法创建出更多的同类型对象。从孙大圣的手段谈起孙悟空在与黄风怪的战斗中，"使一个身外身的手段：把毫毛揪下一把，用口嚼得粉碎，望上一喷，叫声变，变有百十个行者，都是一样得打扮，各执一根铁棒，把那怪围在空中。"换而言之，孙悟空可以根据自己的形象，复制出很多"身外身"来。老孙这
设计模式：快速理解原型模式和应用
热门推荐
张彦峰的博客
05-12 166万+
一、原型模式的定义与理解 （一）基本定义 （二）基本理解分析 （三）在Spring中的具体体现 二、具体简单实现方式 (一)实现原型类具备的三个条件 （二）具体举例 三、深拷贝、浅拷贝与原型模式的解决方案 （一）理解复制的含义，去除原有的误解 （二）浅拷贝及其带来的问题 1.新建一个上司类作为员工类的某个属性 2.测试浅拷贝带来的问题 （三）通过深拷贝来解决问题 四、原型模式的应用场景分析
设计模式六：原型模式（Prototype Pattern）
qq_40537587的博客
07-31 685
原型模式是一种创建对象的设计模式。它允许我们通过复制一个现有对象来创建新的对象，而无需知道其具体实现细节。在使用原型模式时，我们首先创建一个原始对象，然后根据需要复制该对象，以获得新创建的对象。原型模式的主要思想是基于对象的复制。通过使用原型模式，我们可以避免直接实例化对象，从而提高性能和代码灵活性。此外，原型模式还可以用于创建复杂的对象结构，因为它允许我们在创建对象时使用已经存在的对象作为蓝图。
设计模式：原型模式（Prototype）
ProgramNovice的博客
05-28 765
设计模式：原型模式（Prototype）
C++设计模式：原型模式
ajbb093的博客
04-07 1115
在本案例中，如果对史莱姆的原型进行克隆，也就是分裂成不同的对象，而不同的史莱姆型号会对应着不同的技能，假设大型史莱姆是撞击，普通史莱姆是喷射，小型史莱姆是自爆，则简单地进行深克隆以及浅克隆可能会引起异常。因此，对此的解决办法便是原型模式结合状态模式使用，状态模式是指在软件构建过程中，某些对象的状态如果发生改变，其行为也会随之发生变化，使用状态模式将能允许一个对象在其内部状态发生改变时改变它的行为，从而使对象看起来似乎修改了其行为。，普通史莱姆转换成小型史莱姆，其中四只转换后的小型史莱姆共享血量（
Java设计模式之创建型：原型模式
张维鹏的博客
11-01 1万+
原型模式主要用于对象的创建，使用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。原型模式比 new 方式创建对象的性能要好的多，因为 Object 类的 clone() 方法是一个本地方法，直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显；并且可以简化对象的创建；
C++设计模式之Prototype原型模式
喜欢打篮球的普通人
09-04 484
使用_原型实例_指定创建对象的种类，然后通过_拷贝（深拷贝）_这些原型来创建新的对象。————《设计模式》GoFPrototype模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些“易变类”拥有“稳定的接口”。Prototype模式对于“如何创建易变类的实体对象”采用“原型克隆”的方法来做，它使得我们可以非常灵活地动态创建“拥有某些稳定接口”的新对象——所需工作仅仅是_注册一个新类的对象（即原型）_，然后在仍和需要的地方Clone。
设计模式第8讲——原型模式（Prototype）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-08 3775
原型模式属于创建型设计模式。 一、什么是原型模式 二、角色组成 三、优缺点 四、应用场景 4.1 生活场景 4.2 java场景 五、代码实现5.0 UML类图5.1 HeroSkill（英雄--具体原型类）5.2 StealManFactory（塞拉斯--客户端）5.3 TestPrototype六、总结
设计模式-Prototype模式（原型模式）
weixin_44030848的博客
07-24 1239
图解设计模式中的原型模式
.NET设计模式（6）：原型模式（PrototypePattern）
01-30
### .NET设计模式（6）：原型模式（Prototype Pattern） #### 概述 在软件工程领域，设计模式提供了一系列经过验证的解决方案，帮助开发者解决常见的软件设计问题。本篇文章聚焦于.NET框架下的“原型模式”...
Java设计模式之Prototype原型模式
08-27
Java设计模式之Prototype原型模式 Prototype原型模式是Java设计模式中的一种创建型模式，它主要用于对象的克隆和创建。该模式的主要思想是将一个对象作为原型，然后通过克隆该对象来创建新的对象，从而实现对象的...
c++-设计模式之原型模式（Prototype Pattern）
最新发布
09-18
原型模式（Prototype Pattern）是一种创建型设计模式，允许通过复制现有对象来创建新对象，而不是通过类构造器。这种模式常用于需要频繁创建相似对象的场景，能够提高性能并减少内存使用。 原型模式的组成 原型接口...
设计模式C++学习之原型模式(Prototype)
09-07
本篇文章将深入探讨“原型模式(Prototype)”这一经典的设计模式，它是面向对象设计的一个重要概念，尤其在C++编程中有着广泛的应用。 原型模式是一种创建型设计模式，它的核心思想是通过复制已有对象来创建新对象，...
设计模式之二十一:中介者模式(Mediator)
06-28 1310
中介者模式：定义了一个对象，用来封装一系列对象的交互。中介者模式通过使对象之间不必显式引用降低了对象之间的耦合，并且允许你独立改变它们之间的交互。中介者模式就是将对象之间的交互封装在了一个独立的对象中，这个独立的对象用来控制对象之间的交互行为，所以这个对象还是蛮复杂的。UML类图： 主要包括： Mediator：定义了一个Colleague对象之间交互的接口。 ConcreteMediator：实
设计模式之一：简单工厂模式
05-31 1117
这几天准备把设计模式好好看一下，顺带着做下笔记，设计模式以前零零散散看过一些，做项目时也用过或见到过一些设计模式，但是可能只是停留在见到那种设计模式时有点印象，有的时候也将名称弄混，希望这次系统学习的机会能让我对设计模式有个更加深刻的印象吧。 这次学习设计模式主要的参考资料有： 《大话设计模式》 http://www.dofactory.com/net/design-patterns 上面两
设计模式之三：装饰模式(Decorator)
06-02 1109
装饰模式： 动态地给对象添加一些相关的职责。装饰模式相比与添加子类提供了一种更加灵活的方式。 UML图如下所示： 感觉上图中关键的有这几点： Decorator与Component的聚合关系（即Decorator中存在一个Component类型的引用），由于这个聚合关系的存在，Decorator可以通过一个Component的引用调用Component的接口 Decorator与Compo
设计模式之二十二：享元模式(FlyWeight)
06-30 1105
享元模式： 使用共享技术有效地支持大量细粒度的对象。 Use sharing to support large numbers of fine-grained objects efficiently. 这个设计模式和它的名字一样核心是为了共享代码。UML图： 主要包括： FlyWeight：声明了一个接口，通过这个接口所有的FlyWeight能够接受并作用于外部的状态。 ConcreteFl
设计模式之十一：抽象工厂模式(Abstract Factory)
06-06 1097
抽象工厂模式： 提供了一个创建一系列相关的或相互依赖的对象的接口而不需要具体指定它们的类型。Provide an interface for creating families of related or dependent objects without specifying their concrete classes.UML类图：主要包括： AbstractFactory(Continent
Java设计模式：PROTOTYPE原型模式详解
"本文主要介绍了Java设计模式中的原型模式(Prototype模式)，并与其他几种常见的设计模式进行了比较。" 设计模式是软件开发中的一种最佳实践，它提供了在特定场景下解决问题的模板，使得开发者能够重用这些经过验证...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值