每日博客

原型模式

本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：

1、理解原型模式的动机，掌握该模式的结构；

2、能够利用原型模式解决实际问题。

 

 

[实验任务一]：向量的原型

用C++完成数学中向量的封装，其中，用指针和动态申请支持向量长度的改变，使用浅克隆和深克隆复制向量类，比较这两种克隆方式的异同。

C++版

#include <iostream>
#include <string>
#include <memory>

using namespace std;

template<class T>
class ICloneable
{
public:
virtual T* clone() = 0;
};
//深拷贝
class CResume : public ICloneable<CResume>
{
public:
CResume(){}
~CResume()
{
cout << "CResume析构 "<<endl;
}

void setInfo(const double& a, const double& b)
{
m_a = a;
m_b = b;
}

CResume* clone()
{
CResume* resume = new CResume;
resume->setInfo(m_a, m_b);
return resume;
}

void printInfo()
{
cout << "(" << m_a<<","<<m_b<<")" << endl;
}
protected:
double m_a;
double m_b;
};
void testPrototype()
{
CResume re;
re.setInfo(1,2);
re.printInfo();

CResume* pClone = re.clone();
pClone->setInfo(1,3);
pClone->printInfo();

delete pClone;
pClone = NULL;
}
//浅拷贝
class CWorkExperience
{
public:
CWorkExperience(){}
CWorkExperience(const double& a,const double& b)
{
m_a = a;
m_b = b;
}

CWorkExperience(const CWorkExperience& right)
{
m_a = right.m_a;
m_b = right.m_b;
}

~CWorkExperience()
{
cout << "CWorkExperience析构" << endl;
printInfo();
}

void setCompany(const double& a)
{
m_a = a;
}

const double& getCompany() const
{
return m_a;
}

void setWorkTime(const double& b)
{
m_b = b;
}

const double& getWorkTime() const
{
return m_b;
}

void printInfo()
{
cout << "(" << m_a<<","<<m_b<<")" << endl;
}

private:
double m_a; // company name
double m_b; // work time
};
class Resume : public ICloneable<Resume>
{
private:
Resume(){m_experience = NULL;}
public:
// 带参构造函数
Resume(CWorkExperience* pWorkExperience)
{
m_experience = pWorkExperience;
}

// 带参拷贝构造函数
Resume(const Resume& right)
{
// 注意这里是指针赋值 属于浅拷贝
m_experience = right.m_experience;
}

~Resume()
{
cout << "Resume析构 " << endl;
}

void setExperience(const double& a,const double& b)
{
m_experience->setCompany(a);
m_experience->setWorkTime(b);
}

Resume* clone()
{
// 调用拷贝构造函数 浅拷贝
Resume* resume = new Resume(*this);
return resume;
}

void printInfo()
{
m_experience->printInfo();
cout << endl;
}
protected:
CWorkExperience* m_experience;// 指针 聚合
};

void Prototype()
{
CWorkExperience* pWorkExperience = new CWorkExperience(1,2);
Resume re(pWorkExperience); // 只能这样构造 无参构造被屏蔽掉了
re.printInfo();

Resume* pClone = re.clone(); // 指针赋值 浅拷贝
//delete pWorkExperience; // 这里如果调用delete 程序会崩溃(因为是共享)
pClone->setExperience(1,3);
pClone->printInfo();

re.printInfo(); // 我们发现原对象的workExperience属性已经被修改

delete pClone;
delete pWorkExperience;
pClone = NULL;
pWorkExperience = NULL;
}
main()
{
testPrototype();
Prototype();
}