C++设计模式之工厂模式

本文探讨了C++中的设计模式,重点讲解了简单工厂模式和抽象工厂模式。简单工厂模式通过纯虚函数和抽象类实现接口,允许派生类提供不同实现。而抽象工厂模式则更进一步,提供了创建相关或依赖对象的家族,无需指定它们的具体类。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

设计模式之工厂模式

一. 简单工厂模式:定义一个用于创建对象的接口。
简单工厂模式
纯虚函数和抽象类
1、纯虚函数: 在函数原型后面加上符号 “=0”
1)纯虚函数是一个在基类中只有声明的虚函数,在基类中无定义。要求在任何派生类中都定义自己的版本;
2)纯虚函数为各派生类提供一个公共界面(接口的封装和设计,软件的模块功能划分);
2、抽象类:包含纯虚函数的类成为抽象类,用于为派生类提供一个基本框架和一个公共的对外接口,派生类(或派生类的派生类…),应对抽象基类的所有纯虚成员函数进行实现。
a)抽象类对象不能做函数参数,不能创建对象,不能作为函数返回类型;
b)可以声明抽象类指针,可以声明抽象类的引用;
c)子类必须继承父类的纯虚函数才能创建对象。

1 C++没有接口的概念,可以使用纯虚函数实现接口,接口类中只有函数原型的定义,没有任何数据的定义。
2 实际表明: 多继承接口不会带来二义性和复杂性等问题;多重继承可以通过设计好的单继承和接口代替;接口类只是一个功能说明,不是功能实现;子类需要根据功能说明定义功能的实现。
3 多继承—->单继承+继承多个接口

#pragma once
#include <iostream>

enum class PRODUCT{A,B,C};

class AbstractProduct
{
public:
	virtual ~AbstractProduct(){}
	virtual void concreteProduct() = 0;
};

class ConcreteProductA : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "a" << std::endl; }
};

class ConcreteProductB : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "b" << std::endl; }
};

class ConcreteProductC : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "c" << std::endl; }
};

class Factory
{
public:
	AbstractProduct* createProduct(PRODUCT type)
	{
		switch (type)
		{
		case A:
			return new ConcreteProductA();
			break;
		case B:
			return new ConcreteProductB();
			break;
		case C:
			return new ConcreteProductC();
			break;
		default:
			break;
		}
	}
};
int main()
{
	Factory fac;
	AbstractProduct* a = fac.createProduct(A);
	a->concreteProduct();
	AbstractProduct* b = fac.createProduct(B);
	b->concreteProduct();
	AbstractProduct* c = fac.createProduct(C);
	c->concreteProduct();
	delete a; delete b; delete c;
	return 0;
}

二.工厂模式
在这里插入图片描述

#pragma once

#include <iostream>

class AbstractProduct
{
public:
	virtual ~AbstractProduct() = 0;
	virtual void concreteProduct() = 0;
};

class ConcreteProductA : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "a" << std::endl; }
};

class ConcreteProductB : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "b" << std::endl; }
};

class ConcreteProductC : public AbstractProduct
{
public:
	virtual void concreteProduct() { std::cout << "c" << std::endl; }
};

class AbstractFactory
{
public:
	virtual ~AbstractFactory() = 0;
	virtual AbstractProduct* CreateProduct() = 0;
};

class ConcreteFactoryA : public AbstractFactory
{
public:
	AbstractProduct* CreateProduct() { return new ConcreteProductA(); }
};
class ConcreteFactoryB : public AbstractFactory
{
public:
	AbstractProduct* CreateProduct() { return new ConcreteProductB(); }
};
class ConcreteFactoryC : public AbstractFactory
{
public:
	AbstractProduct* CreateProduct() { return new ConcreteProductC(); }
};
int main()
{
	ConcreteFactoryA faca;
	AbstractProduct* a = faca.CreateProduct();
	a->concreteProduct();
	ConcreteFactoryB facb;
	AbstractProduct* b = facb.CreateProduct();
	b->concreteProduct();
	ConcreteFactoryC facc;
	AbstractProduct* c = facc.CreateProduct();
	c->concreteProduct();
	delete a; delete b; delete c;
	return 0;
}

三.抽象工厂模式
在这里插入图片描述

#pragma once
#include <iostream>

class AbstractProduct1
{
public:
	virtual void concreteProduct() = 0;
};

class ConcreteProductA : public AbstractProduct1
{
public:
	void concreteProduct() { std::cout << "a" << std::endl; }
};

class ConcreteProductB : public AbstractProduct1
{
public:
	void concreteProduct() { std::cout << "b" << std::endl; }
};

class AbstractProduct2
{
public:
	virtual void concreteProduct2() = 0;
};

class ConcreteProductC : public AbstractProduct2
{
public:
	void concreteProduct2() { std::cout << "c" << std::endl; }
};

class ConcreteProductD : public AbstractProduct2
{
public:
	void concreteProduct2() { std::cout << "d" << std::endl; }
};

class AbstractFactory
{
public:
	virtual AbstractProduct1* createFactory1() = 0;
	virtual AbstractProduct2* createFactory2() = 0;
};

class ConcreteFactory1 : public AbstractFactory
{
public:
	AbstractProduct1* createFactory1() { return new ConcreteProductA(); }
	AbstractProduct2* createFactory2() { return new ConcreteProductC(); }
};
class ConcreteFactory2 :public AbstractFactory
{
public:
	AbstractProduct1* createFactory1() { return new ConcreteProductB(); }
	AbstractProduct2* createFactory2() { return new ConcreteProductD(); }
};

int main()
{
	ConcreteFactory1 f1;
	ConcreteFactory2 f2;

	AbstractProduct1* p1 = f1.createFactory1();
	p1->concreteProduct();
	AbstractProduct2* p2 = f1.createFactory2();
	p2->concreteProduct2();

	AbstractProduct1* p3 = f2.createFactory1();
	p3->concreteProduct();
	AbstractProduct2* p4 = f2.createFactory2();
	p4->concreteProduct2();
	delete p1; delete p2; delete p3; delete p4;
	system("pause");
	return 0;
}
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

比滕

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值