今日研究c++简单的设计模式;
1.单例模式：
单例模式是一种保证一个类只有一个实例的设计模式。
常见的实现方式有两种：饿汉式和懒汉式。
饿汉式：在类初始化时就已经创建了实例；
懒汉式：则在需要时才创建实例。
单例模式可以保证系统中只有一个实例，从而避免了频繁地创建对象，提高了系统的性能。
2.工厂模式：
2.1简单工厂模式：
在这个示例中，Shape 是一个接口类，Circle 和 Rectangle 是具体的类。ShapeFactory 是工厂类，它根据传入的类型参数创建相应的对象并返回。在 main 函数中，我们通过 ShapeFactory::createShape 方法创建了两个不同的对象，并调用它们的 draw 方法来执行相应的操作。
以下是一个简单的 C++ 工厂模式示例代码：
c++
#include <iostream>
using namespace std;
// 接口类
class Shape {
public:
virtual void draw() = 0;
};
// 具体类
class Circle : public Shape {
public:
void draw() {
cout << "Drawing Circle" << endl;
}
};
class Rectangle : public Shape {
public:
void draw() {
cout << "Drawing Rectangle" << endl;
}
};
// 工厂类
class ShapeFactory {
public:
static Shape* createShape(string type) {
if (type == "Circle") {
return new Circle();
} else if (type == "Rectangle") {
return new Rectangle();
}
return nullptr;
}
};
int main() {
Shape* shape1 = ShapeFactory::createShape("Circle");
shape1->draw();
Shape* shape2 = ShapeFactory::createShape("Rectangle");
shape2->draw();
return 0;
}
2.2 抽象工厂模式：
在这个示例中，Shape 是接口类，Circle、Rectangle和square是具体的类。Factory 是抽象工厂类，它定义了创建产品的接口。CircleFactory、RectangleFactory和squareFactory是具体的工厂类，它们分别创建不同的产品类。Client 是客户端类，它通过工厂方法创建产品并使用。在 main 函数中，我们创建了三个不同的客户端对象，并分别使用它们创建了不同的产品对象。
以下是一个简单的抽象工厂模式 C++ 代码示例：
c++
#include <iostream>
using namespace std;
// 接口类
class Shape {
public:
virtual void draw() = 0;
};
// 具体产品类
class Circle : public Shape {
public:
void draw() {
cout << "Drawing Circle" << endl;
}
};
class Rectangle : public Shape {
public:
void draw() {
cout << "Drawing Rectangle" << endl;
}
};
class Square : public Shape {
public:
void draw() {
cout << "Drawing Square" << endl;
}
};
// 抽象工厂类
class Factory {
public:
virtual Shape* createShape() = 0;
};
// 具体工厂类
class CircleFactory : public Factory {
public:
Shape* createShape() {
return new Circle();
}
};
class RectangleFactory : public Factory {
public:
Shape* createShape() {
return new Rectangle();
}
};
class SquareFactory : public Factory {
public:
Shape* createShape() {
return new square();
}
};
// 客户端类
class Client {
private:
Factory* factory;
public:
Client(Factory* factory) {
this->factory = factory;
}
void useShape() {
Shape* shape = factory->createShape();
shape->draw();
}
};
int main() {
CircleFactory* circleFactory = new CircleFactory();
Client* circleClient = new Client(circleFactory);
circleClient->useShape(); // 输出 "Drawing Circle"
RectangleFactory* rectangleFactory = new RectangleFactory();
Client* rectangleClient = new Client(rectangleFactory);
rectangleClient->useShape(); // 输出 "Drawing Rectangle"
squareFactory* squareFactory = new squareFactory();
Client* squareClient = new Client(squareFactory);
squareClient->useShape(); // 输出 "Drawing square"
delete circleClient;
delete rectangleClient;
delete squareClient;
delete circleFactory;
delete rectangleFactory;
delete squareFactory;
return 0;
}
3.适配器模式
在示例中，我们有一个目标接口 ITarget，一个适配者类 Adaptee，以及一个适配器类 Adapter。适配器类实现了目标接口，并持有一个适配者对象的指针。在适配器类的 targetMethod 方法中，它调用适配者对象的 targetMethod 方法来实现适配器功能。文章来源：https://www.toymoban.com/news/detail-606188.html
在客户端代码中，我们首先创建一个适配者对象，然后创建一个适配器对象，并将适配者对象传入适配器构造函数的参数中。最后，我们调用适配器对象的 targetMethod 方法，实际上是调用适配者对象的 targetMethod 方法。文章来源地址https://www.toymoban.com/news/detail-606188.html
以下是一个简单的适配器模式的C++代码示例：
c++
#include <iostream>
using namespace std;
// 目标接口
class ITarget {
void targetMethod();
};
// 适配者类
class Adaptee : public ITarget {
public:
void targetMethod() {
cout << "Adaptee's targetMethod" << endl;
}
};
// 适配器类
class Adapter : public ITarget {
public:
Adapter(Adaptee *adaptee) : m_adaptee(adaptee) {}
void targetMethod() {
m_adaptee->targetMethod();
}
private:
Adaptee *m_adaptee;
};
// 客户端代码
int main() {
// 创建一个适配者对象
Adaptee adaptee;
// 创建一个适配器对象，并将适配者对象传入适配器构造函数
Adapter adapter(&adaptee);
// 调用适配器的方法，实际上是调用适配者的方法
adapter.targetMethod();
return 0;
}
到了这里，关于每日C++小程序小研究·3·2023.7.26的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
