设计原则
工厂模式
简单工厂模式
#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;
}