C++ 模式设计 原型模式(深拷贝/克隆)

最新推荐文章于 2024-07-04 13:05:02 发布
最新推荐文章于 2024-07-04 13:05:02 发布
阅读量3.4k 收藏 15
点赞数 1
分类专栏： # 设计模式 C++实现 文章标签： c++ mvc 原型模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32460819/article/details/120604907
版权

文章目录


思考: 原型模式跟装饰器模式的区别?

本文核心:

	WorkExperience* clone(){
	    WorkExperience *w = new WorkExperience();
	    *w = *this; // 深拷贝一个相同的自己, 注意如果this中有指针, 需要在对这个指针类进行clone方法的实现, 这样层层嵌套, 就实现了整体的深拷贝
	    return w; // 将当前的this深拷贝给w, 返回
	}

1. 理论知识

当遇到需要复制的实例时, 我们就用到了原型模式, 比如打印20份自己的简历, 一个自己的简历类, 然后实例化一个简历A后, 在实例化 B=A, 但是很抱歉, 这里的B=A其实B是A的引用, 并不是真实的实例, 所以需要用到克隆技术

原型模式: 用原型实例指定创建对象的种类, 并且通过拷贝这些原型创建新的对象; 其实就是从一个对象在创建另外一个可定制的对象, 并且不需要知道创建的任何细节;
在这里插入图片描述

**使用场景: **
1、资源优化场景。
2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。

注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。

原型模式的优缺点
原型模式的优点： 底层的二进制实现拷贝，相比起new操作可以节约性能
原型模式的缺点： 构造函数没有调用，牺牲了灵活性

2. 逻辑模板代码

在这里插入图片描述

// 原型模式起始就是从一个对象在创建另一个可定制的对象, 而且不需要知道任何创建细节
// 原型类
class Prototype{
private:
    string id;
public:
    Prototype(string id): id(id){}
    Prototype() : id("ndy"){}
    string get(){
        return id;
    }
    virtual Prototype* clone() = 0; // 这个方法是关键
};

// 具体原型类
class ConcretePrototype_1 : public Prototype{
private:

public:
    ConcretePrototype_1(string id): Prototype(id){}
    ConcretePrototype_1() {}
    // 相当于实现了深拷贝
    virtual Prototype *clone(){
        // 先开辟等量空间
        ConcretePrototype_1 *p = new ConcretePrototype_1();
        *p = *this; // 在将当前类深拷贝给上面空间
        return p;
    }
};

// 客户端
int main(int argc, char const *argv[]){
    Prototype *p1 = new ConcretePrototype_1("nb");
    Prototype *c1 = p1->clone();
    // ConcretePrototype_1 *p1 = new ConcretePrototype_1("nb");
    // ConcretePrototype_1 *c1 = (ConcretePrototype_1 *)p1->clone();
    cout << c1->get() <<endl; // 输出nb
    delete p1, c1;

    return 0;
}

3. 应用

3.1 应用1: 改写简历

创建一个简历实例A, 在从这个实例A中修改数据变成实例B

// 简历
class Resume{
private:
    string name, sex, age, timeArea, company;
public:
    Resume(string name) : name(name){}
    // 设置个人信息
    void setPersonalInfo(string sex, string age) {
        this->sex = sex;
        this->age = age;
    }
    // 设置工作经历
    void setWorkExperience(string timeArea, string company){
        this->company = company;
        this->timeArea = timeArea;
    }
    // 显示
    void Display(){
        cout << "个人信息:" << name << " " << age << " " << sex << " " << timeArea << " " << company <<endl;
    }
    Resume* clone(){
        Resume *r = new Resume("");
        *r = *this;
        return r;
    }
};

// 这里实现了一个功能为除了name不变, 其他的信息可以改变的不同的简历
// 比如我做了一个简历V1, 然后简历V2是在V1的基础上修改了些信息做的
int main(int argc, char const *argv[])
{
    Resume *nb = new Resume("nb");
    nb->setPersonalInfo("男", "25");
    nb->setWorkExperience("2015-2-2", "tencent");

    Resume *b2 = (Resume*) nb->clone();
    b2->setPersonalInfo("女" , "27");

    Resume *b3 = (Resume*) b2->clone();
    b3->setWorkExperience("2020-5-5", "baidu");

    b2->Display();
    nb->Display();
    b3->Display();

    delete nb, b2, b3;
    return 0;
}

3.2 深浅拷贝的问题 *

上面应用遇到一个问题, 当成员变量有指针时, 默认拷贝还是浅拷贝, 比如工作经历如果是一个类, 那么实例指针只会在拷贝的时候拷贝指针, 而不会拷贝实例, 这样拷贝的指针依然指向实例未变, 如果看不懂, 请看下面的例子

// 工作经历类
class WorkExperience{
private:
    string workDate, company;
public:
    void set(string workDate, string company){
        this->workDate = workDate, this->company = company;
    }
    string get_workDate(){return this->workDate;}
    string get_company(){return this->company;}
};

// 简历
class Resume{
private:
    string name, sex, age;
    WorkExperience *work = nullptr;
public:
    Resume(string name) : name(name), work(new WorkExperience()){}
    // 设置个人信息
    void setPersonalInfo(string sex, string age) {
        this->sex = sex;
        this->age = age;
    }
    // 设置工作经历
    void setWorkExperience(string timeArea, string company){
        work->set(timeArea, company);
    }
    // 显示
    void Display(){
        cout << "个人信息:" << name << " " << age <<" " << sex << " " << work->get_workDate() << " " << work->get_company() <<endl;
    }
    Resume* clone(){
        Resume *r = new Resume("");
        *r = *this; 
        // 注意: 这里由于work是类, 默认拷贝是引用, 因此这里进行拷贝, 
        // 虽然其他成员变量都是深拷贝, 但是work这个指针也是拷贝了指针, 并没有拷贝指针所指的对象
        return r;
    }
};

// 这里实现了一个功能为除了name不变, 其他的信息可以改变的不同的简历
// 比如我做了一个简历V1, 然后简历V2是在V1的基础上修改了些信息做的
int main(int argc, char const *argv[])
{
    Resume *nb = new Resume("nb");
    nb->setPersonalInfo("男", "25");
    nb->setWorkExperience("2015-2-2", "tencent");

    Resume *b2 = (Resume*) nb->clone();
    b2->setPersonalInfo("女" , "27");

    Resume *b3 = (Resume*) b2->clone();
    b3->setWorkExperience("2020-5-5", "baidu");

    b2->Display();
    nb->Display();
    b3->Display();

    delete nb, b2, b3;
    return 0;
}

个人信息:nb 27 女 2020-5-5 baidu
个人信息:nb 25 男 2020-5-5 baidu
个人信息:nb 27 女 2020-5-5 baidu

就会发现所有的工作经验都变成最后修改的值了, 这是因为浅拷贝, 无论怎么修改都是在修改第一个实例的工作经验

3.3 深拷贝的嵌套使用

在类里面都增加一个clone方法来克隆(深拷贝)对象, 这样就方便了下面使用该类进行深拷贝的操作了

// 工作经历类
class WorkExperience{
private:
    string workDate, company;
public:
    void set(string workDate, string company){
        this->workDate = workDate, this->company = company;
    }
    string get_workDate(){return this->workDate;}
    string get_company(){return this->company;}

    WorkExperience* clone(){ // b. 当调用这个方法时, 深拷贝了一个新work
        WorkExperience *w = new WorkExperience();
        *w = *this;
        return w; // 将当前的this深拷贝给w, 返回
    }
};

// 简历
class Resume{
private:
    string name, sex, age;
    WorkExperience *work = nullptr;
public:
    Resume(string name) : name(name), work(new WorkExperience()){} // a. 第一次创建简历时, 同时创建了工作经历类
    Resume(){}
    ~Resume(){ // 由于每个resume都对应一个work
        if(work != nullptr){
            delete work
        }
    }
    // 设置个人信息
    void setPersonalInfo(string sex, string age) {
        this->sex = sex;
        this->age = age;
    }
    // 设置工作经历
    void setWorkExperience(string timeArea, string company){
        work->set(timeArea, company);
    }
    // 显示
    void Display(){
        cout << "个人信息:" << name << " " << age <<" " << sex << " " << work->get_workDate() << " " << work->get_company() <<endl;
    }
    Resume* clone(){
        Resume *r = new Resume(); // c. 创建干净的简历时, 此时r->work还是空的
        *r  =  *this;  // 此时r->work已经是this->work的深拷贝了, 但是里面的work指针还是指向this的work实例
        r->work = work->clone(); // 这样就深拷贝了一个新的work给r, 在返回r, 就是全新的了
        return r;
    }
};

// 这里实现了一个功能为除了name不变, 其他的信息可以改变的不同的简历
// 比如我做了一个简历V1, 然后简历V2是在V1的基础上修改了些信息做的
int main(int argc, char const *argv[])
{
    Resume *nb = new Resume("nb");
    nb->setPersonalInfo("男", "25");
    nb->setWorkExperience("2015-2-2", "tencent");

    Resume *b2 = (Resume*) nb->clone();
    b2->setPersonalInfo("女" , "27");

    Resume *b3 = (Resume*) b2->clone();
    b3->setWorkExperience("2020-5-5", "baidu");

    b2->Display();
    nb->Display();
    b3->Display();

    delete nb, b2, b3;
    return 0;
}
落子无悔!
关注
专栏目录
C++设计模式——原型(Prototype)模式
HUGOPIGS的博客
03-04 1546
在玩一款叫《杀戮尖塔》的游戏时，里面有一个boss怪物叫史莱姆之王，它的技能是在低于自身血量一般时，分裂成两个血量上限为分裂前剩余血量的史莱姆。 那么。我们如何使用C++来模拟这一行为呢？ 我们就要提到C++设计模式之一——原型模式。 #include <iostream> using namespace std; namespace _SlayTheSpire{ class Monster{ public: Monster(int m_hp, int m_atk, int m_de
C++ 类的深拷贝
05-22
设计并实现一个动态整型数组类Vect，要求： （1）实现构造函数重载，可以根据指定的元素个数动态创建初始值为0的整型数组，或根据指定的内置整型数组动态创建整型数组。 （2）设计拷贝构造函数和析构函数，注意使用深拷贝。 （3）设计存取指定位置的数组元素的公有成员函数，并进行下标越界，若越界则输出“out of boundary”。 （4）设计获取数组元素个数的公有成员函数。 （5）设计用于输出数组元素的公有成员函数，元素之间以空格分隔，最后以换行符结束。 在main函数中按以下顺序操作： （1）根据内置的静态整型数组{1,2,3,4,5}构造数组对象v1，根据输入的整型数构造数组对象v2。 （2）调用Vect的成员函数依次输出v1和v2的所有元素。 （3）输入指定的下标及对应的整型数，设置数组对象v1的指定元素。 （4）根据数组对象v1拷贝构造数组对象v3。 （5）调用Vect的成员函数依次输出v1和v3的所有元素。 设计并实现一个动态整型数组类Vect，要求： （1）实现构造函数重载，可以根据指定的元素个数动态创建初始值为0的整型数组，或根据指定的内置整型数组动态创建整型数组。 （2）设计拷贝构造函数和析构函数，注意使用深拷贝。 （3）设计存取指定位置的数组元素的公有成员函数，并进行下标越界，若越界则输出“out of boundary”。 （4）设计获取数组元素个数的公有成员函数。 （5）设计用于输出数组元素的公有成员函数，元素之间以空格分隔，最后以换行符结束。 在main函数中按以下顺序操作： （1）根据内置的静态整型数组{1,2,3,4,5}构造数组对象v1，根据输入的整型数构造数组对象v2。 （2）调用Vect的成员函数依次输出v1和v2的所有元素。 （3）输入指定的下标及对应的整型数，设置数组对象v1的指定元素。 （4）根据数组对象v1拷贝构造数组对象v3。 （5）调用Vect的成员函数依次输出v1和v3的所有元素。
C++实现的深拷贝
杰之行的博客
10-31 944
实现代码 #include <iostream> #include <cstdio> #include <cstdlib> #include <queue> #include <stack> #include <algorithm> #include <string> #include <map> #include <set> #include <vector> using namespa
【C++】C++中深拷贝与浅拷贝详解
最新发布
qq_35902025的博客
07-04 593
在C++中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种不同的对象复制方式，主要涉及到动态内存分配的对象。如果一个类管理了动态分配的资源，那么正确实现拷贝构造函数和赋值操作符以进行深拷贝是非常重要的，以避免潜在的内存管理问题。如果原始对象被销毁，其所拥有的资源也会被释放，这可能会导致未定义行为，因为其他对象仍然引用着已经被释放的内存。深拷贝确保每个对象都有自己的资源副本，因此原始对象的销毁不会影响到复制后的对象。当对象拥有动态分配的内存时，浅拷贝会导致多个对象共享同一块内存资源。
C++ clone()函数的用法
xiangxianghehe的博客
12-13 1万+
本文系转载，出处：设计模式学习笔记（原型模式）原型模式在C++中，要拷贝一个对象，除了自定义一个拷贝构造函数来实现对象复制外，还可以像实现一个clone函数，这需要借助编译器实现的一个隐藏拷贝构造函数，这样的做法，更省心。背后的原理是C++的原型（Prototype）模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。Prototype模式提供了一个通过已存在对象进行新对象创建的接
C++ 深拷贝
꧁༺ʚvv༒catɞ༻꧂的博客
11-29 1468
#include <iostream> #include <cstdlib> using namespace std; int strlen(const char s[]){ int len = 0; while (s[len]){ len++; } return len; // 返回数组str中首个值为null的元素的下标值 } char* strcpy(char *p, const char *s){ char *t = p; while (*p+
c++深拷贝和浅拷贝
热门推荐
思緒凌亂
10-06 3万+
C++中类的拷贝有两种：深拷贝，浅拷贝当出现类的等号赋值时，会调用拷贝函数 在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的。 但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。 所以，这时，必须采用深拷贝。 深拷贝与浅拷贝
c++20设计模式-第4章-原型模式代码
02-05
下面是一个简单的C++原型模式实现示例： ```cpp // 接口类 class Prototype { public: virtual ~Prototype() {} virtual Prototype* clone() const = 0; }; // 具体类 class ConcretePrototype : public ...
C++设计模式-原型模式
06-03
在原型模式中，通常需要实现深拷贝以确保克隆出的对象与原始对象相互独立。 ### 4. C++中的赋值运算符 赋值运算符`=`也涉及到对象的复制，类似于拷贝构造函数，但它是在对象已经创建后进行的。为了确保正确的行为...
设计模式C++学习之原型模式(Prototype)
09-07
本篇文章将深入探讨“原型模式(Prototype)”这一经典的设计模式，它是面向对象设计的一个重要概念，尤其在C++编程中有着广泛的应用。 原型模式是一种创建型设计模式，它的核心思想是通过复制已有对象来创建新对象，...
C++之深拷贝和浅拷贝
09-09
通过简短的代码和图片来说明C++中深拷贝和浅拷贝的区别和概念。
C++深拷贝&浅拷贝
jigetage的专栏
12-06 956
先上结论： 深拷贝：拷贝的是指针所指向的一整块内存，即将指针pSrc所指向的一整块内存，拷贝出来，然后赋值给指针pDst所指向的一个区域，核心代码是 char* pDst = new char[128]; memcpy(pDst, pSrc, sizeof(pSrc)); 浅拷贝：拷贝的是指针的值，即将指针pSrc赋值给了pDst char* pDst = nullptr; pDst ...
【C++基础之四】深拷贝和浅拷贝
偶尔e网事
09-11 7438
1.普通类型对象的拷贝 普通类型对象的拷贝很简单，就是值的复制而已。比如： int _tmain(int argc, _TCHAR* argv[]) { int a=1; int b=a; return 0; } 2.类对象的拷贝 类对象的拷贝相比于普通类型的拷贝就复杂多了，它存在着各种成员变量。比如： CopyTest.h class CCopyTest { publi
C++的深拷贝与浅拷贝
02-27 476
对于普通类型的对象来说，它们之间的复制是很简单的，例如： int a=88; int b=a;  而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。 #include using namespace std; class CExample { private: 　int a; public: 　CExample(int b)
C++深浅拷贝的实现
koroce的博客
02-25 1137
C++中提供了对象拷贝的功能，在进行拷贝时，如果我们没有特意去写拷贝构造函数，系统会自动为我们生成，但有些时候，比如对象成员中含有指针变量的时候，就需要防止拷贝出的构造函数中的指针变量与我们的模板对象成员变量中的指针指向同一块地址，此时就需要进行深拷贝，深拷贝会将两块内存中的信息进行拷贝，而不仅仅是值的拷贝（浅拷贝）。浅拷贝会直接将值进行复制：class One { public: One(...
C++深拷贝
ykc的专栏
11-15 469
对于一般的对象比如 int a = 10; int b = 20; 对象间的赋值，复制过程很简单，但对于类对象来说，其内部存在着各种各样类型变量，其拷贝过程比较复杂。事实上，在对象拷贝过程中。如果没有自定义拷贝构造函数，系统会提供一个默认的拷贝构造函数，缺省的拷贝构造函数对于基本类型的成员变量，按字节复制，对于类类型的成员变量，调用其相应得拷贝构造函数，原型如下： string（con
C++ -- 深浅拷贝
我的博客
06-02 1万+
浅拷贝 1.例如对于下面的String类，它包含一个成员变量，一个char*的指针： class String { private: char* _str; }; 2.对于String类的拷贝构造函数及operator=函数来说，当用一个String对象拷贝构造或赋值给另一个String对象时，就是将这个对象里的指针的值赋值给另一个对象里的指针。将一个指针值赋值给另一个指针，就会...
深拷贝与浅拷贝
weixin_37977062的博客
03-20 257
浅拷贝  所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝 class Rect { public: Rect(){ count++; cout //拷贝构造函数 /*Rect(const Rect &r) *{ * width = r.width; * height = r.h
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

落子无悔!

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值