一、静态成员变量?

如何计算A定义了多少个对象？

#include<iostream>
using namespace std;

class A
{
private:
	static int _n;//仅仅只是声明，_n存在于静态区，属于整个类，也属于类的所有对象
};

int main()
{
	A a1;
	A a2;
	A();

    return 0;
}

所有对象要么是构造出来的，要么是拷贝构造出来的，因此要声明一个全局的成员变量，生命周期也必须是全局的，那么生命周期被改变了，这个成员变量就需要用static进行修饰，即静态成员变量，static int _n;

1.静态成员变量必须在类外定义和初始化的原因

那么如何对_n进行定义初始化呢？如果在类内初始化，会导致每个对象都包含该静态成员。静态成员变量必须在类外定义和初始化的原因：

（1）声明不分配内存，定义会分配内存，如果在类内定义静态成员变量，那么每个对象初始化时都要为静态成员变量分配一块空间，会造成重复定义。

（2）静态成员和类处于同一级别，普通成员和对象处于同一级别。类级别的成员，应先于类对象的存在而存在，且静态成员变量应被所有类对象共享，所以静态成员变量不能放在类内当对象初始化时才初始化。

如何在类外定义和初始化？虽然是私有静态成员变量，但是不受访问限定符限制：

#include<iostream>
using namespace std;

class A
{
public:
    A()//构造函数
	{
		++_n;
	}

	A(const A& a)//拷贝构造函数
	{
		++_n;
	}
private:
	static int _n;//n存在于静态区，属于整个类，不属于某个对象
};

//静态成员变量不受访问限定符限制，否则就没办法初始化了；声明时已经加了static，这里不需要再加static
int A::_n = 0;//在全局指定类域为A，并把值初始化为1

int main()
{
	A a1;
	A a2;
	A();

    return 0;
}

现在只需要获取_n的值就可以了，它是私有的，我们获取不了。

2.如何在类外面访问静态成员变量

有两种方式可以在类外面访问静态成员变量：

（1）修改静态成员变量的访问限定符，注掉private，就可以在类外获取_n的值：

①类名::静态成员变量

②对象.静态成员变量

#include<iostream>
using namespace std;

class A
{
public:
	A()//构造函数
	{
		++_n;
	}

	A(const A& a)//拷贝构造函数
	{
		++_n;
	}

//private:
	static int _n;//n存在于静态区，属于整个类，不属于某个对象
};

int A::_n = 0;

int main()
{
	A a1;
	A a2;
	A();

	//这三行访问的都是全局的_n，因此打印结果都一样
    cout << A::_n << endl;//类名::静态成员变量
	cout << a1._n << endl;//对象.静态成员变量
	cout << a2._n << endl;//对象.静态成员变量
}

?（2）在类外面访问要看访问限定符：如果这个静态成员变量_n就是私有的，在类外面无法访问，需要定义一个公有的成员函数访问静态成员变量，通过对象调用成员函数获取_n的值：

#include<iostream>
using namespace std;

class A
{
public:
	A()//构造函数
	{
		++_n;
	}

	A(const A& a)//拷贝构造函数
	{
		++_n;
	}

	//获取静态成员变量的值
	int getN()
	{
		return _n;
	}

private:
	static int _n;//n存在于静态区，属于整个类，不属于某个对象
};

int A::_n = 0;

int main()
{
	A a1;
	A a2;

	//这两行访问的都是全局的_n，因此打印结果都一样
	cout << A().getN() << endl;
	cout << a1.getN() << endl;
	cout << a2.getN() << endl;
}

二、静态成员函数?

静态成员函数跟普通函数区别：没有this指针，不能访问非静态成员。能访问静态成员是由于静态成员属于整个类，只要突破类域就能访问，突破类域有两种方式：

（1）对象可以帮助静态成员突破类域

（2）指定静态成员的类

因此一般定义一个静态成员函数来访问静态成员变量。

#include<iostream>
using namespace std;

class A
{
public:
	A()//构造函数
	{
		++_n;
	}

	A(const A& a)//拷贝构造函数
	{
		++_n;
	}

    //静态成员函数，没有this指针，不能访问非静态成员
	static int GetN()
	{
		//_a = 1;//不能访问非静态成员
		return _n;
	}

private:
	static int _n;//n存在于静态区，属于整个类，不属于某个对象
	int _a;
};

int A::_n = 0;

int main()
{
	A a1;
	A a2;
	
	//这三行访问的都是全局的_n，因此打印结果都一样
    cout << A().GetN() << endl;//匿名对象可以帮助静态成员突破类域
	cout << a1.GetN() << endl;//对象可以帮助静态成员突破类域
	cout << A::GetN() << endl;//指定静态成员的类，让编译器到类里面去找

}

三、static成员特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象实例
2. 静态成员变量必须在类外定义，定义时不添加static关键字
3. 类静态成员可用类名::静态成员来访问，也可以用对象.静态成员来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以有返回值6. 普通成员只能通过对象访问，不能通过类名访问。
7. 静态成员函数与普通成员函数的根本区别在于：普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）
?

四、static成员OJ题

1.求1+2+3+......+n?OJ链接

分析：根据要求，不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）

（1）为了让函数执行n次，可以定义n个类对象，自动调用n次构造函数，在构造函数里面实现i自增和连续求和。

（2）为了使变量自增到n，使用i++，i不能作为成员变量，否则每个对象都有一个i，应该让所有对象都共享这个i，i应被定义成static。

#include<iostream>//调试用
using namespace std;//调试用

class Add
{
public:
    Add()//构造函数内实现i自增和连续求和
    {
        _ret += _i;
        _i++;
    }
    
    static int GetRet()
    {
        return _ret;
    }

private:
    static int _i;
    static int _ret;
};

int Add::_i = 1;
int Add::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Add arr[n];//为了调用n次构造函数，c++11支持，如果编译器不支持，就用Add *p = new Add[n];
        return Add::GetRet();
    }
};

//以下代码用于自己调试验证，不需要提交至OJ
int main()
{
    Solution s;
    cout << s.Sum_Solution(3) << endl;
    return 0;
}

如果把静态成员变量定义成公有的，那么在Add类外可以直接访问这两个静态成员变量，就不需要在类里面获取静态变量的值了

#include<iostream>//调试用
using namespace std;//调试用

class Add
{
public:
    Add()
    {
        _ret += _i;
        _i++;
    }
    
    //定义成公有静态成员变量,不需要在类里面获取静态变量值的函数
    static int _i;
    static int _ret;
};

int Add::_i = 1;
int Add::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        Add::_i = 1;
        Add::_ret = 0;
        Add *p = new Add[n];

        return Add::_ret;
    }
};

//以下代码用于自己调试验证，不需要提交至OJ
int main()
{
    Solution s;
    cout << s.Sum_Solution(3) << endl;
    return 0;
}

也可以把Solution类定义成Add类的友元：

#include<iostream>
using namespace std; 

class Add
{
public:
    friend class Solution;
    Add()//构造函数内实现i自增和连续求和
    {
        _ret += _i;
        _i++;
    }

private:
    static int _i;
    static int _ret;
};

int Add::_i = 1;
int Add::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) {
        
        Add* p = new Add[n];
        return Add::_ret;
    }
};

//以下代码用于自己调试验证，不需要提交至OJ
int main()
{
    Solution s;
    cout << s.Sum_Solution(8) << endl;
    return 0;
}

2.计算日期到天数转换 OJ链接

分析：（1）数组不存放每月天数，而是存放1月1日到该月月底的天数；

? ? ? ? ? ? （2）闰年要特殊处理

#include<iostream>
using namespace std;

int main()
{
    int year, month, day;
    cin>>year>>month>>day;

    //直接存放1月1日到该月月底的天数
    int daysArray[13] = {0,31,59,90,120,151,181,212,243,273,304,334,365};
    int n;
    
    n = daysArray[month-1]+day;
    
    //闰年时，月份大于2时，天数需要+1
    if(month > 2 && ((year%4==0 && year%100!=0) || (year%400==0)))
    {
        n += 1;
    }
    
    cout << n<< endl;
    
}