不用 乘除法_for_while_if_else_条件表达式 求 1+2+3……+N 的函数指针方法

之前网上我见到，加上自己想的，一共三种方法：

一、利用N个构造函数的初始化工作，完成类内部静态变量的累加。

具体就是类的内部设两个变量N和Sum。在构造函数中完成N++和Sum += N的操作。然后通过C++的new操作符，构造N个这样的对象，完成累加。

思路属于利用编译器，替人完成累加。

二、利用两个函数。

既然不能用分支语句，不能判断是不是应该终止递归，我们不妨定义两个函数。
一个函数充当递归函数的角色，另一个函数处理终止递归的情况，
我们需要做的就是在两个函数里二选一。代码如下：

#include <iostream.h>
class A;
A* Array[2];
class A
{
public:
    virtual int Sum (int n) { return 0; }
};
class B: public A
{
public:
    virtual int Sum (int n) { return Array[!!n]->Sum(n-1)+n; }
};
int solution2_Sum(int n)
{
    A a;
    B b;
    Array[0] = &a;
    Array[1] = &b;
    int value = Array[1]->Sum(n); 
    //利用虚函数的特性，当Array[1]为0时，即Array[0] = &a; 执行A::Sum，
    //当Array[1]不为0时，                即Array[1] = &b; 执行B::Sum。
    return value;
}
int main()
{
    cout<<solution2_Sum(100)<<endl;
    return 0;
}

利用了多态的性质，相当于“加了一个统一的壳子——Sum”，用同一个“接口”实现两种调用。

三、利用模板元编程里面的特化的概念。

思路跟一有相通之处，即利用编译器的帮助，完成计算。

然后，受到第二种思路的启发，我在想，能不能稍微对两个函数的“接口”做些改动，利用C的函数指针完成对两个函数调用的形式上的“封装”。

思路是，同样定义两个不同的函数，然后用一个 函数指针数组 存储这两个函数。然后再加点儿小技巧完成调用哪一个的“决策”。

代码如下：

#include <iostream>
int foo(int);
int bar(int);
int (*a[])(int) = {foo, bar};
int n = 100, Sum = 0;
int foo(int n)
{
	return 0;
}
int bar(int n)
{
	return n + (*a[!!(n-1)])(n-1);
}
int main()
{
	Sum += (*a[!!n])(n);	
	std::cout << Sum;
	return 0;
}