利用多态实现计算器的好处
    1，组织结构清晰
    2，可读性强
    3，对于前期和后期的扩展以及维护性高

    1. #include<iostream>
    2. #include<string>
    3. using namespace std;
    4. class Calculator
    5. {
    6.     public:
    7.         int getResult(string oper)
    8.         {
    9.             if(oper=="+")
    10.             {
    11.                 return m_a+m_b;
    12.             }
    13.             if(oper=="-")
    14.             {
    15.                 return m_a-m_b;
    16.             }
    17.             if(oper=="*")
    18.             {
    19.                 return m_a*m_b;
    20.             }
    21.             return 0;
    22.         }
    23.         int m_a;
    24.         int m_b;
    25. };
    26. void show()
    27. {
    28.     Calculator p;
    29.     p.m_a=20;
    30.     p.m_b=30;
    31.     cout<<p.m_a<<"+"<<p.m_b<<"="<<p.getResult("+")<<endl;
    32.     cout<<p.m_a<<"-"<<p.m_b<<"="<<p.getResult("-")<<endl;
    33.     cout<<p.m_a<<"*"<<p.m_b<<"="<<p.getResult("*")<<endl; 
    34. }
    37. //利用多态实现计算器的好处
    38. //1，组织结构清晰
    39. //2，可读性强
    40. //3，对于前期和后期的扩展以及维护性高。 
    41. class abstract
    42. {
    43.     public:
    44.         virtual int getResult()
    45.         {
    46.             return 0;
    47.         }
    48.     virtual ~abstract()
    49.     {
    50.         cout<<"析构函数"<<endl;
    51.     }
    52.         int m_a;
    53.         int m_b;
    54. };
    56. class Addabstract:public abstract
    57. {
    58.     public:
    59.         int getResult()
    60.         {
    61.             return m_a+m_b;
    62.         }
    63. }; 
    65. class subabstract:public abstract
    66. {
    67.     public:
    68.         int getResult()
    69.         {
    70.             return m_a-m_b;
    71.         }
    72. };
    74. class Mulabstract:public abstract
    75. {
    76.     public:
    77.         int getResult()
    78.         {
    79.             return m_a*m_b;
    80.         }
    81. };
    82. void test()
    83. {
    84.     //多态的使用条件。 
    85.     //父类的(指针)或者(引用)指向子类的对象。 
    86.     abstract *p;
    87.     p=new Addabstract;
    88.     p->m_a=10;
    89.     p->m_b=10;
    90.     cout<<p->m_a<<"+"<<p->m_b<<"="<<p->getResult()<<endl;
    91.     delete p;
    92.     p=new subabstract;
    93.     p->m_a=102;
    94.     p->m_b=10;
    95.     cout<<p->m_a<<"-"<<p->m_b<<"="<<p->getResult()<<endl;
    96.     //用完后记得销毁，   这里的话如果用了指针且开辟了空间就是（p=new Addabstract;）句话 
    97.     //需要在虚基类(抽象类)中定义虚析构函数否则的话他只会调用抽象类的析构函数不会调用子类的析构函数。
    98.     //如果不用的话编译器会进行报错。      
    99.     delete p;
    100.     p=new Mulabstract;
    101.     p->m_a=5;
    102.     p->m_b=10;
    103.     cout<<p->m_a<<"*"<<p->m_b<<"="<<p->getResult()<<endl;
    104.     delete p;
    105. }
    106. // 如果想扩展新的功能，需求修改源码
    107. // 在正式开发中  提倡  开闭原则
    108. // 开闭原则：对扩展进行开放，对修改进行关闭。 
    109. int main()
    110. {
    111.     show();
    112.     test();
    113.     return 0;
    114. }

    网址：链接