C++系列之类的静态成员

静态成员函数中不能调用非静态成员，非静态成员函数中可以调用静态成员，因为静态成员在编译时已经存在，先于对象而存在，因而无法使用对象的成员函数

静态成员变量使用前必须先初始化，否则会在linker时出错

静态成员的特性：不管这个类创建了多少个对象，而其静态成员只有一个拷贝（副本），这个拷贝被所有属于这个类的对象共享。

1.静态数据成员

     定义格式：在普通的数据成员定义前加static

           static 数据类型 静态数据成员名；

     初始化格式：

           数据类型类名：：静态数据成员名 =  初始化值；

     公有静态数据成员的访问格式：

           1. 类名：：静态数据成员名

           2. 对象.静态数据成员名

           3. 对象指针->静态数据成员名

      说明：

            1. 静态数据成员属于类，普通数据成员属于某一对象；

            2. 在类中不给静态数据成员分配内存空间；

            3. 静态数据成员与静态变量一样，是在编译时创建并初始化，它在该类的任何对象被建立之前就存在；

            4. 静态数据成员不能在类中进行初始化，必须在类外的其他地方为它提供定义；一般在main()开始之前、类的声明之后的特殊地带为它提供定义和初始化；

            5. 私有静态数据成员不能被类外部函数访问，也不能用对象进行访问。事实上，私有的任何数据成员和成员函数都不能被类外部函数访问，也不能用对象进行访问。

 

       例子：

#include <iostream> 

using namespace std; 

 

class KMyClass 

{ 

private: 

   static int i;                      //声明i为私有静态数据成员 

public: 

   static int j;                      //声明j为公有静态数据成员 

   int Geti() 

   { 

       return i; 

   } 

   int Getj() 

   { 

       return j; 

   } 

}; 

 

int KMyClass::i = 0;                         //静态数据成员初始化 

int KMyClass::j = 0; 

 

int main() 

{ 

   KMyClass::j = 200;                 //公有静态数据成员可以在对象定义之前被访问 

   cout<<"KMyClass::j ="<<KMyClass::j<<endl; 

   KMyClass ob1, ob2; 

   cout<<"ob1.i = "<<ob1.Geti()<<endl; 

   cout<<"ob1.j = "<<ob1.Getj()<<endl; 

   cout<<"ob2.i = "<<ob2.Geti()<<endl; 

   cout<<"ob2.j = "<<ob2.Getj()<<endl; 

   ob1.j = 300;                         //公有静态数据成员也可通过对象进行访问 

   cout<<"ob1.j = "<<ob1.Getj()<<endl;   //静态数据成员是对象的共享数据项 

   cout<<"ob2.j = "<<ob2.Getj()<<endl; 

   return 0; 

} 

 

            程序结果：

                    MyClass：：j = 200;

                    ob1.i = 0;

                    ob1.j = 200;

                    ob2.i = 0;

                    ob2.j = 200;

                    ob1.j = 300;

                    ob2.j = 300;

 

2.静态成员函数

     定义格式：

           static 返回类型静态成员函数名（形参表）；

     公有静态数据成员的访问格式：

 

           1. 类名：：静态成员函数名（形参表）

           2. 对象.静态成员函数名（形参表）

           3. 对象指针->静态成员函数名（形参表）

      说明：

            1. 静态成员函数可以定义成内嵌的，也可以在类外定义（在类外定义时，不要用static前缀，出于习惯考虑cao）；

            2. 一般情况下，静态成员函数主要用来返回全局变量或同一个类中的静态数据成员（当它与静态数据成员一起使用时，达到了对同一个类中对象之间共享数据进行维护的目的）；

            3. 编译系统将静态成员函数限定为内部连接，即，与现行文件相连接的其他文件中的同名函数不会与该函数发生冲突，维护了该函数使用的安全性，这是使用静态成员函数的另一个原因；

            4. 在一般的成员函数中，都隐含有一个this指针，用来指向对象自身，而在静态成员函数中是没有this指针的，因为它不与特定的对象相联系，调用时使用如下格式较好：     类名：：静态成员函数名（）；

            5. 私有静态成员函数不能被类外部函数和对象访问。

 

       例子：

#include <iostream>  

using namespace std; 

 

class Small_Cat 

{ 

private: 

   double weight; 

   static double total_weight; 

   static double total_number; 

public: 

   Small_Cat(double w) 

   { 

       weight = w; 

       total_weight += w; 

       total_number++; 

   } 

 

   void Display() 

   { 

       cout<<"The small_cat weights"<<weight<<" pounds\n"; 

   } 

 

   static void Total_Disp()              //静态成员函数，显示小猫的只数和总重量 

   { 

       cout<<total_number<<" small_cat total weight"<<total_weight<<" pounds"<<endl; 

   } 

}; 

 

double Small_Cat::total_weight = 0; 

double Small_Cat::total_number = 0; 

 

int main() 

{ 

   Small_Cat w1(1.8), w2(1.6), w3(1.5); 

   w1.Display(); 

   w1.Total_Disp(); 

   w2.Display(); 

   w2.Total_Disp(); 

   w3.Display(); 

   w3.Total_Disp(); 

   Small_Cat::Total_Disp(); 

   return 0; 

} 

 

           程序结果：

                 The small_cat weights 1.8pounds

                 3 small_cat total weight 4.9pounds

                 The small_cat weights 1.6pounds

                 3 small_cat total weight 4.9 pounds

                 The small_cat weights 1.5pounds

                 3 small_cat total weight 4.9pounds

                 3 small_cat total weight 4.9pounds