方法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;
}
}