以C/C++语法浅谈六大设计原则（二）——开闭原则（Open Closed Principle）

0.写在前面

在平时的软件开发过程中，项目的需求变动、代码的修改都是非常普遍的，如果我们一味的去根据需求而不断的修改我们的代码逻辑，这对我们开发来说，不仅仅增加了我们的工作量，而且对我们软产品的稳定性的影响也是非常大的。因此，我们怎么才能高效的解决在工作中遇到的这些问题呢。今天本篇我们以几个场景来细说设计原则之开闭原则。

1.基本概述

开闭原则是指对于扩展是开放的，对于更改是封闭的。面对新的客户需求，对程序的改动是通过添加新代码而完成的，避免更改现有的代码。

2.具体实例

场景1
我们需要写一个类来知道三个数中的最大数和最小数是多少，可以这样设计：

enum TYPE{MAX,MIN};
class Calculate
{
public:
	Calculate(int x,int y,int z)
	:m_a(x),m_b(y),m_c(z),m_max(0),m_min(0)
	{
		 m_max = (m_a > m_b?m_a:m_b) > m_c?(m_a > m_b?m_a:m_b):m_c;
		 m_min = (m_a > m_b?m_a:m_b) > m_c?(m_a > m_b?m_a:m_b):m_c;
	}
	~Calculate(){}

public:
	const int GetNum(const TYPE type)
	{
		switch(type)
		{
		case MAX:
			{
			   return m_max;
			}break;
		case MIN:
			{
			   return m_min;
			}break;
		default:break;
		}
	}
private:
	int m_a;
	int m_b;
	int m_c;
	int m_max;
	int m_min;
};

场景2
接下来我们需要求这三个数中最大值与最小值得和以及最大值与最小值的差，我们可以在原代码里这样修改：

enum TYPE{MAX,MIN,SUM,SUB};
class Calculate
{
public:
	Calculate(int x,int y,int z)
	:m_a(x),m_b(y),m_c(z),m_max(0),m_min(0)
	{
		 m_max = (m_a > m_b?m_a:m_b) > m_c?(m_a > m_b?m_a:m_b):m_c;
		 m_min = (m_a < m_b?m_a:m_b)  <  m_c?(m_a < m_b?m_a:m_b):m_c;
	}
	~Calculate(){}

public:
	const int GetNum(const TYPE type)
	{
		switch(type)
		{
		//最大值
		case MAX:
			{
			   return m_max;
			}break;
		//最小值
		case MIN:
			{
			   return m_min;
			}break;
		//最大值与最小值之和
		case SUM:
			{
				return m_max + m_min;
			}break;
		//最大值与最小值之差
		case SUB:
			{
				return m_max - m_min;
			}break;
		default:break;
		}
	}
private:
	int m_a;
	int m_b;
	int m_c;
	int m_max;
	int m_min;
};

场景3
接下来我们要求中间数、要求三个数的和、要求最大数与中间值的平方……等等，如果我们还通过更改原代码来实现的话，明显违背了开闭原则，我们对我们的类进行更改：

class ICalculatorBase
{
public:
	ICalculatorBase(int x,int y,int z)
		:m_a(x),m_b(y),m_c(z),m_max(0),m_min(0)
	{
		m_max = (m_a > m_b?m_a:m_b) > m_c?(m_a > m_b?m_a:m_b):m_c;
		m_min = (m_a < m_b?m_a:m_b) < m_c?(m_a < m_b?m_a:m_b):m_c;
	}
	virtual ~ICalculatorBase(){}

public:
	virtual const int GetNum()
	{
		return 0;
	}
public:
	int m_a;
	int m_b;
	int m_c;
	int m_max;
	int m_min;

};

//最大值
class Max : public ICalculatorBase
{
public:
	Max(int x,int y,int z)
		:ICalculatorBase(x,y,z){}
	~Max(){}
public:
	virtual const int GetNum()
	{
		return m_max;
	}
};

//最小值
class Min : public ICalculatorBase
{
public:
	Min(int x,int y,int z)
		:ICalculatorBase(x,y,z){}
	~Min(){}
public:
	virtual const int GetNum()
	{
		return m_min;
	}
};

//最大值与最小值之和
class Sum : public ICalculatorBase
{
public:
	Sum(int x,int y,int z)
	:ICalculatorBase(x,y,z){}
	~Sum(){}
public:
	virtual const int GetNum()
	{
		return m_max + m_min;
	}
};

//最大值与最小值之差
class Mub : public ICalculatorBase
{
public:
	Mub(int x,int y,int z)
		:ICalculatorBase(x,y,z){}
	~Mub(){}
public:
	virtual const int GetNum()
	{
		return m_max - m_min;
	}
};

//……

我们如果在增加了需求，我们直接继承我们的基类重新写属于新需求的类就可以了，完全不用再去修改我们原来的代码，遵守开闭原则。

【上一篇：】以C/C++语法浅谈六大设计原则（一）——依赖倒置原则（Dependence Inversion Principle）
https://blog.csdn.net/weixin_39951988/article/details/85704400
【下一篇：】以C/C++语法浅谈六大设计原则（三）——单一职责原则（Single Responsibility Principle）
https://blog.csdn.net/weixin_39951988/article/details/86491097