求1加到n的发散思维方法

方法1：运用构造函数，

#include "stdafx.h"
#include <iostream>
using namespace std;

//构造函数法，利用static的特性
//类的静态成员变量被所有对象共享
class temp{
private:
	static int num;
	static int sum;//声明两个静态变量
	//定义一些公有函数来操纵它们
public:
	static void reset()//定义静态成员函数，使得在没有生产任何对象前
	{                 //由类也可以调用这个函数
		num = 0;
		sum = 0;
	}
	temp()//构造函数，对两个静态成员变量操纵
	{
		num++;
		sum += num;
	}
	static int get()
	{
		return sum;
	}
	
};
//静态成员要在类外和生成第一个对象之前初始化
int temp::num = 0;
int temp::sum = 0;
int _tmain(int argc, _TCHAR* argv[])
{
	temp::reset();//这里就可以直接调用
	int n = 100;
	temp* s = new temp[n];
	delete[] s;//这里是释放s的空间，同时调用temp的析构函数
	          //析构100个temp对象
	s = NULL;//避免悬垂指针
	//但是静态变量存储在静态存储区，属于类，不属于任何对象，所以还可用
	int sum = temp::get();
	cout << sum << endl;
	system("pause");
	return 0;
}

2，虚函数方法

#include "stdafx.h"
#include <iostream>
using namespace std;

//虚函数方法
//利用思想：基类的指针或引用可以指向继承类的对象
//若基类中公有虚函数，并且继承类中重写了，那么基类
//的指针或引用调用这个虚函数可以实现多态

struct A{
	virtual int sum(int n)
	{
		return 0;
	}
};
A* arr[2];
//就是要实现在n=0时，是调用基类A中的sum函数
//其他时候都是调用继承类B中的sum函数
struct B: A
{
	int sum(int n)
	{
		return arr[!!n]->sum(n-1) + n;
	}
};

int main()
{
	A a;
	B b;
	arr[0] = &a;
	arr[1] = &b;
	int n = 100;
	int sum = arr[!!n]->sum(n);
	cout << sum << endl;
	system("pause");
	return 0;
}

3，函数指针

#include "stdafx.h"
#include <iostream>
using namespace std;

//函数指针方法
//就是利用函数指针声明一个数组，0号位置是一个函数
//1号位置又是一个函数，当n不为0时都是调用1号位置函数
//当n为0时才调用0号位置函数

typedef int (*fun)(int);//规定就是这么写，把返回值为int类型，参数
                        //为int类型的函数都起一个别名*fun
int function1(int n)
{
	return 0;
}
int function2(int n)
{
    fun a[2] = {function1, function2};
	return a[!!n](n-1)+n;
}
int main()
{
	int n = 100;
	int sum = function2(n);
	cout << sum << endl;
	system("pause");
	return 0;
}

4，利用&&操作符的判断顺序

class solution{

public:

      int sum(int n)

     {

           int temp = n;

          bool a = (n > 0) && (temp += sum(n-1));//当n大于0时一直往下递归，当n=0时，a再判断了第一个条件为假时，就不再判断第二个条件了，这时候开始返回

          return temp;

      }

}