每日C++小程序小研究·3·2023.7.26

今日研究c++简单的设计模式;

1.单例模式：

        单例模式是一种保证一个类只有一个实例的设计模式。

        常见的实现方式有两种：饿汉式和懒汉式。

        饿汉式：在类初始化时就已经创建了实例；

        懒汉式：则在需要时才创建实例。

        单例模式可以保证系统中只有一个实例，从而避免了频繁地创建对象，提高了系统的性能。

2.工厂模式：

 2.1简单工厂模式：

在这个示例中，Shape 是一个接口类，Circle 和 Rectangle 是具体的类。ShapeFactory 是工厂类，它根据传入的类型参数创建相应的对象并返回。在 main 函数中，我们通过 ShapeFactory::createShape 方法创建了两个不同的对象，并调用它们的 draw 方法来执行相应的操作。

以下是一个简单的 C++ 工厂模式示例代码：

c++
#include 
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 
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 方法来实现适配器功能。

在客户端代码中，我们首先创建一个适配者对象，然后创建一个适配器对象，并将适配者对象传入适配器构造函数的参数中。最后，我们调用适配器对象的 targetMethod 方法，实际上是调用适配者对象的 targetMethod 方法。

以下是一个简单的适配器模式的C++代码示例：

c++
#include 
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;
}