实现加法算法

源代码转载的网上的CSDN《每天一道算法题》，原址：http://blog.csdn.net/qianhen123/article/details/45641875。自己为其添加了注释，自己是C++新手，希望能从中获取进步。若有明显错误，望指出。

使用函数指针，递归实现加法算法：

1. typedef int (*function)(int);  //使用typedef声明一个名为function的函数指针数组类型
2. int func1(int n){  
3.     return 0;  
4. }  
5. int func2(int n){  
6.     function f[2]={func1,func2};  //用此类型定义一个函数指针数组变量并初始化
7. return n+f[!!n](n-1);//数组重载（!!n表示把int类型转换为shortint类型），再递归，直到n=0跳出递归。
8. }  
9. void main(){  
10.     cout<<func2(10);  
11. }  

使用构造函数：

c++为类提供的构造函数可自动完成对象的初始化任务，全局对象和静态对象的构造函数在main（）函数之前就被调用，局部静态对象的构造函数是当程序第一次执行到相应语句才被调用。

1. class test{  
2.     static int N;  
3.     static int sum;  
4. public :  
5.     test(){sum+=++N;}  
6.     static void reset(){N=sum=0;}  
7.     static int getSum(){return sum;}  
8. };  
9. int test::N = 0;  
10. int test::sum = 0;  
11.   
12. void main(){  
13.     test::reset();  
14.     test *p=new test[10];//分配大小为10的数组空间，每分配一次就调用一次构造函数
15.     cout<<test::getSum();  
16.     delete []p;  //释放test数组空间
17. }  

使用虚函数的编译多态性

被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，用专业术语来解释就是实现多态性，多态性是将接口与实现进行分离。指向基类的指针在操作它的多态类对象时，会根据不同的类对象，调用其相应的函数，这个函数就是虚函数。

1. class A{  
2.   public:  
3.     virtual int sum(int n){return 0;};  
4. };  
5. class B:public A  
6. {  
7.     public:  
8.     int sum(int n){  
9.        A a;B b;  
10.        A *p[2]={&a,&b};  
11.        return n+p[!!(n-1)]->sum(n-1);}  
12. };  
13.   
14. void main(){  
15.     B b;  
16.     cout<<b.sum(10);   
17. }  

其原理与函数指针的方法类似。