声明为static的类成员叫做类的静态成员，分为两种：
（1）静态成员变量：用static修饰的成员变量
（2）静态成员函数：用static修饰的成员函数
一、静态成员变量
如何计算A定义了多少个对象？
1. #include<iostream> 2. using namespace std; 3. 4. class A 5. { 6. private: 7. static int _n;//仅仅只是声明，_n存在于静态区，属于整个类，也属于类的所有对象 8. }; 9. 10. int main() 11. { 12. A a1; 13. A a2; 14. A(); 15. 16. return 0; 17. }
所有对象要么是构造出来的，要么是拷贝构造出来的，因此要声明一个全局的成员变量，生命周期也必须是全局的，那么生命周期被改变了，这个成员变量就需要用static进行修饰，即静态成员变量，static int _n;
那么如何对_n进行定义初始化呢？如果在类内初始化，会导致每个对象都包含该静态成员。静态成员变量必须在类外定义和初始化的原因：
（1）声明不分配内存，定义会分配内存，如果在类内定义静态成员变量，那么每个对象初始化时都要为静态成员变量分配一块空间，会造成重复定义。
（2）静态成员和类处于同一级别，普通成员和对象处于同一级别。 类级别的成员，应先于类对象的存在而存在，且静态成员变量应被所有类对象共享，所以静态成员变量不能放在类内当对象初始化时才初始化。
如何在类外定义和初始化？虽然是私有静态成员变量，但是不受访问限定符限制：
1. #include<iostream> 2. using namespace std; 3. 4. class A 5. { 6. public: 7. A()//构造函数 8. { 9. ++_n; 10. } 11. 12. A(const A& a)//拷贝构造函数 13. { 14. ++_n; 15. } 16. private: 17. static int _n;//n存在于静态区，属于整个类，不属于某个对象 18. }; 19. 20. //静态成员变量不受访问限定符限制，否则就没办法初始化了；声明时已经加了static，这里不需要再加static 21. int A::_n = 0;//在全局指定类域为A，并把值初始化为1 22. 23. int main() 24. { 25. A a1; 26. A a2; 27. A(); 28. 29. return 0; 30. }
现在只需要获取_n的值就可以了，它是私有的，我们获取不了。
有两种方式可以在类外面访问静态成员变量：
（1）修改静态成员变量的访问限定符，注掉private，就可以在类外获取_n的值：
①类名::静态成员变量
②对象.静态成员变量
1. #include<iostream> 2. using namespace std; 3. 4. class A 5. { 6. public: 7. A()//构造函数 8. { 9. ++_n; 10. } 11. 12. A(const A& a)//拷贝构造函数 13. { 14. ++_n; 15. } 16. 17. //private: 18. static int _n;//n存在于静态区，属于整个类，不属于某个对象 19. }; 20. 21. int A::_n = 0; 22. 23. int main() 24. { 25. A a1; 26. A a2; 27. A(); 28. 29. //这三行访问的都是全局的_n，因此打印结果都一样 30. cout << A::_n << endl;//类名::静态成员变量 31. cout << a1._n << endl;//对象.静态成员变量 32. cout << a2._n << endl;//对象.静态成员变量 33. }
（2）在类外面访问要看访问限定符：如果这个静态成员变量_n就是私有的，在类外面无法访问，需要定义一个公有的成员函数访问静态成员变量，通过对象调用成员函数获取_n的值：
1. #include<iostream> 2. using namespace std; 3. 4. class A 5. { 6. public: 7. A()//构造函数 8. { 9. ++_n; 10. } 11. 12. A(const A& a)//拷贝构造函数 13. { 14. ++_n; 15. } 16. 17. //获取静态成员变量的值 18. int getN() 19. { 20. return _n; 21. } 22. 23. private: 24. static int _n;//n存在于静态区，属于整个类，不属于某个对象 25. }; 26. 27. int A::_n = 0; 28. 29. int main() 30. { 31. A a1; 32. A a2; 33. 34. //这两行访问的都是全局的_n，因此打印结果都一样 35. cout << A().getN() << endl; 36. cout << a1.getN() << endl; 37. cout << a2.getN() << endl; 38. }
二、静态成员函数
静态成员函数跟普通函数区别：没有this指针，不能访问非静态成员。能访问静态成员是由于静态成员属于整个类，只要突破类域就能访问，突破类域有两种方式：
（1）对象可以帮助静态成员突破类域
（2）指定静态成员的类
因此一般定义一个静态成员函数来访问静态成员变量。
1. #include<iostream> 2. using namespace std; 3. 4. class A 5. { 6. public: 7. A()//构造函数 8. { 9. ++_n; 10. } 11. 12. A(const A& a)//拷贝构造函数 13. { 14. ++_n; 15. } 16. 17. //静态成员函数，没有this指针，不能访问非静态成员 18. static int GetN() 19. { 20. //_a = 1;//不能访问非静态成员 21. return _n; 22. } 23. 24. private: 25. static int _n;//n存在于静态区，属于整个类，不属于某个对象 26. int _a; 27. }; 28. 29. int A::_n = 0; 30. 31. int main() 32. { 33. A a1; 34. A a2; 35. 36. //这三行访问的都是全局的_n，因此打印结果都一样 37. cout << A().GetN() << endl;//匿名对象可以帮助静态成员突破类域 38. cout << a1.GetN() << endl;//对象可以帮助静态成员突破类域 39. cout << A::GetN() << endl;//指定静态成员的类，让编译器到类里面去找 40. 41. }
三、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。
1. #include<iostream>//调试用 2. using namespace std;//调试用 3. 4. class Add 5. { 6. public: 7. Add()//构造函数内实现i自增和连续求和 8. { 9. _ret += _i; 10. _i++; 11. } 12. 13. static int GetRet() 14. { 15. return _ret; 16. } 17. 18. private: 19. static int _i; 20. static int _ret; 21. }; 22. 23. int Add::_i = 1; 24. int Add::_ret = 0; 25. 26. class Solution { 27. public: 28. int Sum_Solution(int n) { 29. Add arr[n];//为了调用n次构造函数，c++11支持，如果编译器不支持，就用Add *p = new Add[n]; 30. return Add::GetRet(); 31. } 32. }; 33. 34. //以下代码用于自己调试验证，不需要提交至OJ 35. int main() 36. { 37. Solution s; 38. cout << s.Sum_Solution(3) << endl; 39. return 0; 40. }
如果把静态成员变量定义成公有的，那么在Add类外可以直接访问这两个静态成员变量，就不需要在类里面获取静态变量的值了
1. #include<iostream>//调试用 2. using namespace std;//调试用 3. 4. class Add 5. { 6. public: 7. Add() 8. { 9. _ret += _i; 10. _i++; 11. } 12. 13. //定义成公有静态成员变量,不需要在类里面获取静态变量值的函数 14. static int _i; 15. static int _ret; 16. }; 17. 18. int Add::_i = 1; 19. int Add::_ret = 0; 20. 21. class Solution { 22. public: 23. int Sum_Solution(int n) { 24. Add::_i = 1; 25. Add::_ret = 0; 26. Add *p = new Add[n]; 27. 28. return Add::_ret; 29. } 30. }; 31. 32. //以下代码用于自己调试验证，不需要提交至OJ 33. int main() 34. { 35. Solution s; 36. cout << s.Sum_Solution(3) << endl; 37. return 0; 38. }
也可以把Solution类定义成Add类的友元：
1. #include<iostream> 2. using namespace std; 3. 4. class Add 5. { 6. public: 7. friend class Solution; 8. Add()//构造函数内实现i自增和连续求和 9. { 10. _ret += _i; 11. _i++; 12. } 13. 14. private: 15. static int _i; 16. static int _ret; 17. }; 18. 19. int Add::_i = 1; 20. int Add::_ret = 0; 21. 22. class Solution { 23. public: 24. int Sum_Solution(int n) { 25. 26. Add* p = new Add[n]; 27. return Add::_ret; 28. } 29. }; 30. 31. //以下代码用于自己调试验证，不需要提交至OJ 32. int main() 33. { 34. Solution s; 35. cout << s.Sum_Solution(8) << endl; 36. return 0; 37. }
2.计算日期到天数转换 OJ链接
分析： （1）数组不存放每月天数，而是存放1月1日到该月月底的天数；
（2）闰年要特殊处理
1. #include<iostream> 2. using namespace std; 3. 4. int main() 5. { 6. int year, month, day; 7. cin>>year>>month>>day; 8. 9. //直接存放1月1日到该月月底的天数 10. int daysArray[13] = {0,31,59,90,120,151,181,212,243,273,304,334,365}; 11. int n; 12. 13. n = daysArray[month-1]+day; 14. 15. //闰年时，月份大于2时，天数需要+1 16. if(month > 2 && ((year%4==0 && year%100!=0) || (year%400==0))) 17. { 18. n += 1; 19. } 20. 21. cout << n<< endl; 22. 23. }
