牛客题目分享：JZ64 求1+2+3+...+n（用static成员和构造函数的方法）（C++）

题目看上去很简单，因为用循环、递归、等差数列就能了了几行解决这个问题，但就如题目所说的， 如果都这些方法都用不了呢？

如果只限制题目所说的条件，其实是没有限制递归的，只不过递归所需要的判断条件的if else被禁了而已，我们可以用&&代替，但这并不是出题人的真正意图，本篇将用C++中的构造函数和static成员的特性来解决！

思路：

学过类和对象的都知道，每次实例化一个类时都会调用一次构造函数（也包括了拷贝构造）

先思考一个问题：

设计出一个类A，可以计算这个类总计产生了多少对象

既然在实例化对象时都会调用(拷贝)构造函数，那么只需要在(拷贝)构造函数体内有一个++操作的变量就可以了，如下：

#include <iostream>
using namespace std;
//面试题：设计出一个类A，可以计算这个类总计产生了多少对象
class A
{
public:
	int GetN()//获取当前类总计产生了多少对象
	{
		return _n;
	}
	A()//构造函数
	{
		_n++;
	}
	A(const A& a)//拷贝构造函数
	{
		_n++;
	}
private:
	int _n;
};
const A fun(const A a)
{
	return a;
}

int main()
{
	A a;
	A a2;
	cout << a.GetN() << endl;
	return 0;
}

但是运行结果却是1，明明实例化了2个对象啊？

这是因为类中的成员变量_n是局部的，存储在栈区，每个对象都会创建出一个_n，那自然都是1，所以我们要让_n变成全局的

#include <iostream>
using namespace std;
//面试题：设计出一个类A，可以计算这个类总计产生了多少对象
int _n;
class A
{
public:
	int GetN()//获取当前类总计产生了多少对象
	{
		return _n;
	}
	A()//构造函数
	{
		_n++;
	}
	A(const A& a)//拷贝构造函数
	{
		_n++;
	}
};
const A fun(const A a)
{
	return a;
}

int main()
{
	A a;
	A a2;
	cout << a.GetN() << endl;
	return 0;
}

现在的代码运行的确是2了，但现在的_n随便都可以被更改，有没有什么办法可以让_n被封装起来？让它不能被轻易更改？

那肯定还是要把_n放在类里面，但类里面就成局部变量了，这时候就需要static出场了

只要是static修饰的成员变量，它就会属于这个类，而不是一个对象，并且是存储在数据段(静态区)的

#include <iostream>
using namespace std;
//面试题：设计出一个类A，可以计算这个类总计产生了多少对象
class A
{
public:
	int GetN()
	{
		return _n;
	}
	A()//构造函数
	{
		_n++;
	}
	A(const A& a)//拷贝构造函数
	{
		_n++;
	}
private:
	static int _n;//声明 不是属于某个对象，是属于类的所有对象，属于这个类
	//n不在对象中，n在静态区
};
int A::_n = 0;//定义
const A fun(const A a)
{
	return a;
}

int main()
{
	A a;
	A a2;
	fun(a);
	fun(a2);
	cout << a.GetN() << endl;
	return 0;
}

那现在呢？会发现他输出的是6，可是我们只创建了2个对象，这块的main函数和上面的唯一区别就是多加了两次fun()的调用，为什么会多加4次？

仔细看一下fun函数的定义，会发现它的返回值和参数都是传值，而只要是传值返回/传参，都会被调用一次拷贝构造函数，所以一次fun()就让_n加了2，只要把返回和参数都改成引用，就不会调用拷贝构造了

#include <iostream>
using namespace std;
//面试题：设计出一个类A，可以计算这个类总计产生了多少对象
class A
{
public:
	int GetN()
	{
		return _n;
	}
	A()//构造函数
	{
		_n++;
	}
	A(const A& a)//拷贝构造函数
	{
		_n++;
	}
private:
	static int _n;//声明 不是属于某个对象，是属于类的所有对象，属于这个类
	//n不在对象中，n在静态区
};
int A::_n = 0;//定义
const A& fun(const A& a)
{
	return a;
}

int main()
{
	A a;
	A a2;
	fun(a);
	fun(a2);
	cout << a.GetN() << endl;
	return 0;
}

现在就完美了，完全符合题目要求了

现在再回来想想，是不是有点头绪了？只要通过调用n次(拷贝)构造函数，再把他们调用时的每一个数加起来，不就是1+2+3+...+n了？

现在的问题是，怎么才能调用n次(拷贝)构造函数

A a[n];

没错，只要创建一个为n的A类数组，就会调用n次构造函数！

示例代码：

#include <regex>
class Sum
{
public:
    static int GetN()//设置成静态成员函数，是属于这个类的，可以直接通过类名突破类域访问
    {
        return _sum;//返回结果
    } 
    Sum()//构造函数
    {
        _sum+=_n;//累加
        _n++;
    }
private:
    static int _n;
    static int _sum;
};
int Sum::_n=1;//静态成员变量必须在类外初始化
int Sum::_sum=0;
class Solution // 题目
{
public:
    int Sum_Solution(int n) 
    {
        Sum a[n];
        return Sum::GetN();
    }
};