C++设计模式

设计原则

工厂模式

简单工厂模式

#include<iostream>
#include<atomic>
#include<memory>
#include<thread>
#include<mutex>
#include<queue>
using namespace std;
//基类
class COperation {
public:
	int m_First;
	int m_Second;
	virtual double GetResult() {
		double dResult = 0;
		return dResult;
	}
};
//加法
class AddOperation :public COperation {
public:
	virtual double GetResult() {
		return m_First + m_Second;
	}
};
//减法
class SubOperation :public COperation {
public:
	virtual double GetResult() {
		return m_First - m_Second;
	}
};
//工厂类
class CCalculatorFactory {
public:
	static COperation* Create(char cOperator) {
		switch (cOperator) {
		case'+':
			return new AddOperation;
		case '-':
			return new SubOperation;
		default:
			return nullptr;
		}
	}
};

int main() {
	int a, b;
	cin >> a >> b;
	COperation* op = CCalculatorFactory::Create('+');
	if (op) {
		op->m_First = a;
		op->m_Second = b;
		cout << "result:" << op->GetResult() << endl;
	}
	else {
		cout << "Invalid operator" << endl;
	}
	delete op;

	return 0;
}

工厂方法模式

#include<iostream>
#include<atomic>
#include<memory>
#include<thread>
#include<mutex>
#include<queue>
using namespace std;
//基类
class COperation {
public:
	int m_First;
	int m_Second;
	virtual double GetResult() = 0;
	virtual ~COperation() {};
	
};
//加法类
class AddOperation :public COperation {
public:
	virtual double GetResult() override {
		return m_First + m_Second;
	}
};
//减法类
class SubOperation :public COperation {
public:
	virtual double GetResult()override {
		return m_First - m_Second;
	}
};
//工厂基类
class COperationFactory {
public:
	virtual COperation* CreateOperation() = 0;
	virtual ~COperationFactory(){}
};
//加法工厂
class AddOperationFactory :public COperationFactory {
	COperation* CreateOperation()override {
		return new AddOperation;
	}
};
//减法工厂
class SubOperationFactory :public COperationFactory {
	COperation* CreateOperation()override {
		return new SubOperation;
	}
};


int main() {
	int a, b;
	cin >> a >> b;

	COperationFactory* factory = new AddOperationFactory();
	COperation* op = factory->CreateOperation();
	
	op->m_First = a;
	op->m_Second = b;
	cout << "result:" << op->GetResult() << endl;

	delete op;
	delete factory;
	return 0;
}

单例模式

饿汉模式

#include<iostream>

using namespace std;

class TaskQueue {
public:
	TaskQueue(const TaskQueue& t) = delete;
	TaskQueue& operator=(const TaskQueue& t) = delete;

	static TaskQueue* getInstance() {
		return _taskQ;
	}

	void print() {
		cout << "我是一个实例" << endl;
	}

private:
	TaskQueue() = default;
	static TaskQueue* _taskQ;
};
TaskQueue* TaskQueue::_taskQ = new TaskQueue;

int main() {
	TaskQueue* queue = TaskQueue::getInstance();
	queue->print();

	return 0;
}

#include<iostream>
using namespace std;

class TaskQueue {
public:
    static TaskQueue* getInstance() {
        if (_taskQ == nullptr) { // 第一次调用时，初始化实例
            _taskQ = new TaskQueue;
        }
        return _taskQ;
    }

    void print() {
        cout << "我是一个实例" << endl;
    }

private:
    // 构造函数私有
    TaskQueue() = default;
    TaskQueue(const TaskQueue& t) = delete;
    TaskQueue& operator=(const TaskQueue& t) = delete;

    // 静态实例指针
    static TaskQueue* _taskQ;
};

// 初始化静态成员指针为nullptr
TaskQueue* TaskQueue::_taskQ = nullptr;

int main() {
    TaskQueue* queue = TaskQueue::getInstance(); // 第一次使用时创建实例
    queue->print();

    // 由于示例代码中没有提供删除单例的实现，实际使用中应考虑内存管理和程序退出时清理单例
    // 这里我们假定程序的生命周期内单例始终存在，因此不删除它
    // 在实际的应用中，可能需要在适当的位置删除单例以避免内存泄漏
    // delete queue;

    return 0;
}

懒汉模式

#include<iostream>
#include<atomic>
#include<memory>
#include<thread>
#include<mutex>

using namespace std;

class TaskQueue {
public:
	TaskQueue(const TaskQueue& t) = delete;
	TaskQueue& operator=(const TaskQueue& t) = delete;

	static TaskQueue* getInstance() {
		TaskQueue* q = _taskQ.load();
		if (q == nullptr) {
			lock_guard<mutex> locker(_mutex);
			if (q == nullptr) {
				q = new TaskQueue;
				_taskQ.store(q);
			}
		}
		return q;
	}

	void print() {
		cout << "我是一个实例" << endl;
	}

private:
	static atomic<TaskQueue*> _taskQ;
	TaskQueue() = default;
	static mutex _mutex;
};
atomic<TaskQueue*>TaskQueue::_taskQ;
static mutex _mutex;

int main() {
	TaskQueue* queue = TaskQueue::getInstance();
	queue->print();

	return 0;
}

静态局部变量

#include<iostream>
#include<atomic>
#include<memory>
#include<thread>
#include<mutex>

using namespace std;

class TaskQueue {
public:
	TaskQueue(const TaskQueue& t) = delete;
	TaskQueue& operator=(const TaskQueue& t) = delete;

	static TaskQueue* getInstance() {
		static TaskQueue taskQ;
		return &taskQ;
	}

	void print() {
		cout << "我是一个实例" << endl;
	}

private:
	TaskQueue() = default;
};

int main() {
	TaskQueue* queue = TaskQueue::getInstance();
	queue->print();

	return 0;
}