常用的设计模式（单例模式和工厂模式）

设计模式

单例模式

• 1. 私有构造函数，防止外部直接实例化
  2. 静态成员函数，返回唯一实例的引用
  3. 静态局部变量，在程序生命周期内

#include<iostream>
#include<map>
using namespace std;


class shoppingCartManager {
public:
// 获取购物车实例
// 2. 静态成员函数， 返回唯一实例的引用
static shoppingCartManager& getInstance(){
static shoppingCartManager instance;// 3. 静态局部变量，在程序生命周期内只被创建一次，因此，每次调用getInstance，都返回相同的实例
return instance;
}

void addToChart(const string& itemName, int quantity) {
cart[itemName] += quantity;
}

void viewCart() const {
for (const auto& item : cart) {
cout << item.first << "" << item.second << endl;
}
}

private:
// 1, 私有构造函数，防止外部直接实例化
shoppingCartManager() {}
map<string, int>cart;
};

int main() {
string itemName;
int quantity;
shoppingCartManager& ca = shoppingCartManager::getInstance();
ca.addToChart("aaa", 3);
while (cin >> itemName >> quantity) {
if (itemName == "end") break;
shoppingCartManager& cart = shoppingCartManager::getInstance();
cart.addToChart(itemName, quantity);
}

const shoppingCartManager& cart = shoppingCartManager::getInstance();
cart.viewCart();

return 0;
}

工厂模式

• 对类内部数据的只读访问

  const vector<Block*> & getBlocks() const{
  return blocks;
  }
  

• 创建型设计模式，引入抽象类和具体类

• 一个工厂方法可以创建一个具体产品

#include <iostream>
#include <vector>

using namespace std;

// 抽象积木接口
class Block {
public:
virtual void produce() = 0;
};

// 具体圆形积木实现
class CircleBlock :public Block {
public:
void produce() override {
cout << "Circle Block." << endl;
}
};

// 具体方形积木实现
class SquareBlock : public Block {
public:
void produce() override {
cout << "Square Block." << endl;
}
};

// 抽象积木工厂接口
class BlockFactory {
public:
virtual Block* createBlock() = 0;
};

// 具体圆形积木实现
class CircleFactory : public BlockFactory {
public:
Block* createBlock() override {
return new CircleBlock();
}
};


// 具体方形积木实现
class SquareFactory : public BlockFactory {
public:
Block* createBlock() override {
return new SquareBlock();
}
};


// 积木工厂系统
class BlockFactorySystem {
private:
vector<Block*> blocks;
public:
void produceBlocks(BlockFactory* factory, int quantity) {
for (int i = 0; i < quantity; i++) {
Block* block = factory->createBlock();
blocks.push_back(block);
block->produce();
}
}

// 对类内部数据的只读访问
const vector<Block*>& getBlocks() const {
return blocks;
}

~BlockFactorySystem() {
for (Block* block : blocks) {
delete block;
}
}
};

int main() {
BlockFactorySystem factorySystem;

int productionCount;
cin >> productionCount;

for (int i = 0; i < productionCount; i++) {
string blockType;
int quantity;
cin >> blockType >> quantity;

if (blockType == "Circle") {
factorySystem.produceBlocks(new CircleFactory(), quantity);
}
else {
factorySystem.produceBlocks(new SquareFactory(), quantity);
}
}
const vector<Block*>& blocks = factorySystem.getBlocks();
for (auto& block : blocks) {
block->produce();
}

return 0;
}

抽象工厂模式

• 一个工厂方法可以创建一类具体产品
• 应用场景：使用抽象工厂模式来创建不同数据库的连接对象

#include <iostream>
#include <string>

using namespace std;

// 抽象椅子类
class Chair {
public:
virtual void showInfo() = 0;
};

class ModernChair : public Chair {
public:
void showInfo()override {
cout << "modern chair" << endl;
}
};

class ClassicalChair : public Chair {
void showInfo() override {
cout << "classical chair" << endl;
}
};

class Sofa {
public:
virtual void displayInfo() = 0;
};

class ModernSofa : public Sofa {
public:
void displayInfo() override{
cout << "display sofa" << endl;
}
};

class ClassicalSofa : public Sofa {
public:
void displayInfo() override {
cout << "classical sofa" << endl;
}
};

// 抽象家具工厂接口
class furnitureFactory {
public:
virtual Chair* createChair() = 0;
virtual Sofa* createSofa() = 0;
};

// 现代家具工厂接口
class ModernFurnitureFactory : public furnitureFactory {
public:
Chair* createChair() override {
return new ModernChair();
}
Sofa* createSofa() override {
return new ModernSofa();
}
};


// 传统家具工厂接口
class ClassicalFunitureFactory : public furnitureFactory {
public:
Chair* createChair() override {
return new ClassicalChair();
}
Sofa* createSofa() override {
return new ClassicalSofa();
}
};

int main() {
int N;
cin >> N;

for (int i = 0; i < N; i++) {
string furnitureType;
cin >> furnitureType;

furnitureFactory* factory = nullptr;
if (furnitureType == "Modern") {
factory = new ModernFurnitureFactory();
}
else if (furnitureType == "Classical") {
factory = new ClassicalFunitureFactory();
}

Chair* chair = factory->createChair();
Sofa* sofa = factory->createSofa();

chair->showInfo();
sofa->displayInfo();

delete chair;
delete sofa;
delete factory;
}
return 0;
}

原文地址：https://blog.csdn.net/fangqi100/article/details/137246820

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！