C++ switch/case的替換方案

switch語句改為多態結構更好些。

1. 常規switch

#include <iostream>
enum EnumType
{
	enumOne,
	enumTwo,
	enumThree
};
 
void showMessage(int type)
{
	switch (type)
	{
	case enumOne:
		printf("This is message one\n");
		break;
	case enumTwo:
		printf("This is message two\n");
		break;
	case enumThree:
		printf("This is message three\n");
		break;
	default:
		printf("This is wrong message\n");
		break;
	}
}
 
int main()
{
	//常規switch 
	showMessage(enumOne);
	showMessage(enumTwo);
	showMessage(enumThree);
 
	return 0;
}

2.多態+std::map取代switch

#include <map> 
 
enum EnumType
{
	enumOne,
	enumTwo,
	enumThree
};
 
class Base
{
public:
	Base() {}
	virtual ~Base() {}
	virtual void showMessage() {}
};
 
class MessageOne :public Base
{
public:
	MessageOne() {}
	~MessageOne() {}
	void showMessage()
	{
		printf("This is message one\n");
	}
};
 
class MessageTwo :public Base
{
public:
	MessageTwo() {}
	~MessageTwo() {}
	void showMessage()
	{
		printf("This is message two\n");
	}
};
 
class MessageThree :public Base
{
public:
	MessageThree() {}
	~MessageThree() {}
	void showMessage()
	{
		printf("This is message three\n");
	}
};
 
int main()
{
	//多態+std::map取代switch 
	std::map<int, Base*> baseMap;
	baseMap.insert(std::make_pair(enumOne, new MessageOne));
	baseMap.insert(std::make_pair(enumTwo, new MessageTwo));
	baseMap.insert(std::make_pair(enumThree, new MessageThree));
	baseMap[enumOne]->showMessage();
	baseMap[enumTwo]->showMessage();
	baseMap[enumThree]->showMessage();
 
	return 0;
}

上述完全是一個面向過程到面向對象的轉變：將每個case分支都作為一個子對象，然后用C++語言的多態性去動態綁定。這樣做確實是帶來了性能上的損失，但是在當今的CPU計算能力而言，這是可以忽略的，而它帶來的好處卻很有用：
(1)分支的增減只要繼續派生即可；
(2)子類代表了一個case，比必須用type去硬編碼的case語句更加具有可讀性；
(3)代碼的可讀性增強，使得分支的維護性增加；
(4)面向對象的思想更加符合人看世界的方式；

(5)避免了漏寫break語句造成的隱蔽錯誤。

3.函數指針+std::map取代switch

#include <map> 
   
enum EnumType 
{ 
    enumOne, 
    enumTwo, 
    enumThree 
}; 
   
void showMessageOne() 
{ 
    printf("This is message one\n"); 
} 
   
void showMessageTwo() 
{ 
    printf("This is message two\n"); 
} 
   
void showMessageThree() 
{ 
    printf("This is message three\n"); 
} 
   
int main() 
{ 
//函數指針+std::map取代switch 
    typedef void (*func)(); 
   
    std::map<int,func> funcMap; 
    funcMap.insert(std::make_pair(enumOne,showMessageOne)); 
    funcMap.insert(std::make_pair(enumTwo,showMessageTwo)); 
    funcMap.insert(std::make_pair(enumThree,showMessageThree)); 
    funcMap[enumOne](); 
    funcMap[enumTwo](); 
    funcMap[enumThree](); 
   
    return 0; 
} 

4.狀態模式取代switch

#include <stdio.h> 
class Context;
class State
{
public:
	State() {}
	virtual ~State() {}
	virtual void showMessage(Context *pContext) = 0;
};
 
class MessageOne :public State
{
public:
	MessageOne() {}
	~MessageOne() {}
	void showMessage(Context *pContext)
	{
		printf("This is message one\n");
	}
};
 
class MessageTwo :public State
{
public:
	MessageTwo() {}
	~MessageTwo() {}
	void showMessage(Context *pContext)
	{
		printf("This is message two\n");
	}
};
 
class MessageThree :public State
{
public:
	MessageThree() {}
	~MessageThree() {}
	void showMessage(Context *pContext)
	{
		printf("This is message three\n");
	}
};
 
class Context
{
public:
	Context(State *pState) : m_pState(pState) {}
 
	void Request()
	{
		if (m_pState)
		{
			m_pState->showMessage(this);
		}
	}
 
	void ChangeState(State *pState)
	{
		m_pState = pState;
	}
 
private:
	State *m_pState;
};
 
int main()
{
	State *pStateA = new MessageOne();
	State *pStateB = new MessageTwo();
	State *pStateC = new MessageThree();
	Context *pContext = new Context(pStateA);
	pContext->Request();
 
	pContext->ChangeState(pStateB);
	pContext->Request();
 
	pContext->ChangeState(pStateC);
	pContext->Request();
 
	delete pContext;
	delete pStateC;
	delete pStateB;
	delete pStateA;
 
	return 0;
}

5. 多態+模板取代switch

#include <map> 
 
enum EnumType
{
	enumOne,
	enumTwo,
	enumThree
};
 
class Base
{
public:
	Base() {}
	virtual ~Base() {}
	virtual void showMessage() {}
};
 
class MessageOne :public Base
{
public:
	MessageOne() {}
	~MessageOne() {}
	void showMessage()
	{
		printf("This is message one\n");
	}
};
 
class MessageTwo :public Base
{
public:
	MessageTwo() {}
	~MessageTwo() {}
	void showMessage()
	{
		printf("This is message two\n");
	}
};
 
class MessageThree :public Base
{
public:
	MessageThree() {}
	~MessageThree() {}
	void showMessage()
	{
		printf("This is message three\n");
	}
};
 
template <class S>
void show( S shape)
{
	shape.showMessage();
}
 
int main()
{
	MessageOne shape1;
	MessageTwo shape2;
	MessageThree shape3;
	show(shape1);
	show(shape2);
	show(shape3);
 
	return 0;
}

參考： JoannaJuanCV