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

设计模式

单例模式

• 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;
}