目录
原型模式（Prototype Pattern）
原型模式是一种创建型设计模式，它允许你通过复制现有对象来创建新的对象，而不是通过类实例化来创建对象。这种模式在开发时需要大量类似对象的情况下非常有用。原型模式的核心是一个具有克隆方法的接口，通过实现该接口，不同的对象可以被复制。
实际应用
在C++中，原型模式通常使用一个基类（原型接口）和具体实现类来实现。基类包含一个纯虚拟的克隆方法，每个具体类实现该方法以返回自己的克隆。
克隆形状对象
假设我们有一个`Shape`基类和一些具体的形状类，如`Circle`和`Rectangle`。
#include <iostream>
#include <memory>
#include <unordered_map>
// Shape基类，包含一个纯虚拟的克隆方法
class Shape {
public:
virtual ~Shape() = default;
virtual std::unique_ptr<Shape> clone() const = 0;
virtual void draw() const = 0;
};
// Circle类，继承自Shape并实现克隆方法
class Circle : public Shape {
private:
int radius;
public:
Circle(int r) : radius(r) {}
std::unique_ptr<Shape> clone() const override {
return std::make_unique<Circle>(*this);
}
void draw() const override {
std::cout << "Drawing a Circle with radius " << radius << "\n";
}
};
// Rectangle类，继承自Shape并实现克隆方法
class Rectangle : public Shape {
private:
int width, height;
public:
Rectangle(int w, int h) : width(w), height(h) {}
std::unique_ptr<Shape> clone() const override {
return std::make_unique<Rectangle>(*this);
}
void draw() const override {
std::cout << "Drawing a Rectangle with width " << width << " and height " << height << "\n";
}
};
int main() {
// 创建原型对象
std::unordered_map<std::string, std::unique_ptr<Shape>> prototypes;
prototypes["circle"] = std::make_unique<Circle>(10);
prototypes["rectangle"] = std::make_unique<Rectangle>(20, 30);
// 克隆对象
std::unique_ptr<Shape> shape1 = prototypes["circle"]->clone();
std::unique_ptr<Shape> shape2 = prototypes["rectangle"]->clone();
// 绘制克隆的对象
shape1->draw();
shape2->draw();
return 0;
}
克隆计算机对象
假设我们有一个`Computer`基类和一些具体的计算机类，如`Laptop`和`Desktop`。
#include <iostream>
#include <memory>
#include <unordered_map>
// Computer基类，包含一个纯虚拟的克隆方法
class Computer {
public:
virtual ~Computer() = default;
virtual std::unique_ptr<Computer> clone() const = 0;
virtual void display() const = 0;
};
// Laptop类，继承自Computer并实现克隆方法
class Laptop : public Computer {
private:
int batteryLife;
public:
Laptop(int battery) : batteryLife(battery) {}
std::unique_ptr<Computer> clone() const override {
return std::make_unique<Laptop>(*this);
}
void display() const override {
std::cout << "Displaying a Laptop with battery life " << batteryLife << " hours\n";
}
};
// Desktop类，继承自Computer并实现克隆方法
class Desktop : public Computer {
private:
bool hasMonitor;
public:
Desktop(bool monitor) : hasMonitor(monitor) {}
std::unique_ptr<Computer> clone() const override {
return std::make_unique<Desktop>(*this);
}
void display() const override {
std::cout << "Displaying a Desktop " << (hasMonitor ? "with" : "without") << " monitor\n";
}
};
int main() {
// 创建原型对象
std::unordered_map<std::string, std::unique_ptr<Computer>> prototypes;
prototypes["laptop"] = std::make_unique<Laptop>(8);
prototypes["desktop"] = std::make_unique<Desktop>(true);
// 克隆对象
std::unique_ptr<Computer> comp1 = prototypes["laptop"]->clone();
std::unique_ptr<Computer> comp2 = prototypes["desktop"]->clone();
// 显示克隆的对象
comp1->display();
comp2->display();
return 0;
}
克隆文档对象
假设我们有一个`Document`基类和一些具体的文档类，如`WordDocument`和`PDFDocument`。
#include <iostream>
#include <memory>
#include <unordered_map>
// Document基类，包含一个纯虚拟的克隆方法
class Document {
public:
virtual ~Document() = default;
virtual std::unique_ptr<Document> clone() const = 0;
virtual void print() const = 0;
};
// WordDocument类，继承自Document并实现克隆方法
class WordDocument : public Document {
private:
int wordCount;
public:
WordDocument(int words) : wordCount(words) {}
std::unique_ptr<Document> clone() const override {
return std::make_unique<WordDocument>(*this);
}
void print() const override {
std::cout << "Printing a Word Document with word count " << wordCount << "\n";
}
};
// PDFDocument类，继承自Document并实现克隆方法
class PDFDocument : public Document {
private:
int pageCount;
public:
PDFDocument(int pages) : pageCount(pages) {}
std::unique_ptr<Document> clone() const override {
return std::make_unique<PDFDocument>(*this);
}
void print() const override {
std::cout << "Printing a PDF Document with page count " << pageCount << "\n";
}
};
int main() {
// 创建原型对象
std::unordered_map<std::string, std::unique_ptr<Document>> prototypes;
prototypes["word"] = std::make_unique<WordDocument>(5000);
prototypes["pdf"] = std::make_unique<PDFDocument>(100);
// 克隆对象
std::unique_ptr<Document> doc1 = prototypes["word"]->clone();
std::unique_ptr<Document> doc2 = prototypes["pdf"]->clone();
// 打印克隆的对象
doc1->print();
doc2->print();
return 0;
}
总结
每个原型类实现自己的克隆方法，从而确保了对象的正确复制。
