static静态数据2

 前言：  
  　　本文只是本人对C++中关于静态类型的一个总结，如错误之处，请大家帮我改正。我分两个方面来总结，第一方面主要是相对于面向过程而言，即在这方面不涉及到类，第二方面相对于面向对象而言，主要说明static在类中的作用。  
   
  一、在面向过程设计中的static关键字  
   
  1、静态全局变量  
   
  定义：在全局变量前，加上关键字   static   该变量就被定义成为了一个静态全局变量。  
   
  特点：  
  　　A、该变量在全局数据区分配内存。  
  　　B、初始化：如果不显式初始化，那么将被隐式初始化为0。  
  　　C、访变量只在本源文件可见，严格的讲应该为定义之处开始到本文件结束。    
   
  　　例（摘于C++程序设计教程---钱能主编P103）：   　　　　　　　　//file1.cpp    
  　　　　　　　　#include<iostream.h>  
  　　　　　　　　void   fn();  
  　　　　　　　　extern   int   n;  
  　　　　　　　　void   main()  
  　　　　　　　　{  
  　　　　　　　　　　n=20;  
  　　　　　　　　　　cout   <<   n   <<   endl;  
  　　　　　　　　　　fn();  
  　　　　　　　　}    
   
  　　　　　　　　//file2.cpp  
  　　　　　　　　#include<iostream.h>  
   
  　　　　　　　　static   int   n;   //定义静态全局变量，初始化为0；  
  　　　　　　　　void   fn()  
  　　　　　　　　{  
  　　　　　　　　　　n++;  
  　　　　　　　　　　cout   <<   n   <<   endl;  
  　　　　　　　　}  
   
  　　文件分别编译能通过，但连接时file1.cpp   中的变量n找不到定义，产生连接错误。  
   
  　　D、文件作用域下声明的const的常量默认为static存储类型。  
   
  2、静态局部变量  
   
  定义：在局部变量前加上static关键字时，就定义了静态局部变量。  
   
  特点：  
  　　A、该变量在全局数据区分配内存。  
  　　B、初始化：如果不显式初始化，那么将被隐式初始化为0。  
  　　C、它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或　语句块结束时，其作用域随之结束。  
   
  3、静态函数（注意与类的静态成员函数区别）  
   
  定义：在函数的返回类型前加上static关键字，函数即被定义成静态函数。  
   
  特点：  
  　　A、静态函数只能在本源文件中使用（这是与普通函数区别）  
  　　例（摘于C++程序设计教程---钱能主编P103）：   　　　　　　　　//file1.cpp  
  　　　　　　　　void   fn();  
  　　　　　　　　void   staticFn()  
   
  　　　　　　　　void   main()  
  　　　　　　　　{  
   
  　　　　　　　　　　fn();  
  　　　　　　　　　　staticFn();  
  　　　　　　　　}  
   
  　　　　　　　　//file2.cpp  
  　　　　　　　　#include<iostream.h>  
   
  　　　　　　　　static   void   staticFn();  
  　　　　　　　　void   fn();  
   
  　　　　　　　　void   fn()  
  　　　　　　　　{  
  　　　　　　　　　　staticFn();  
  　　　　　　　　　　cout   <<   "this   is   fn()   /n";  
  　　　　　　　　}  
   
  　　　　　　　　void   staticFn()  
  　　　　　　　　{  
  　　　　　　　　　　cout   <<   "this   is   staticFn()   /n";  
  　　　　　　　　}    
  连接时，将产生找不到函数staticFn()定义的错误。  
   
  　　B、主意事项  
   
  　　在文件作用域下声明的inline函数默认为static类型。  
   
  二、面象对象中的static关键字（主要指类中的static关键字）  
   
  1、静态数据成员  
   
  特点：  
  　　A、内存分配：在程序的全局数据区分配。  
  　　B、初始化和定义：  
  　　　a、静态数据成员定义时要分配空间，所以不能在类声明中定义。  
  　　　b、为了避免在多个使用该类的源文件中，对其重复定义，所在，不能在类的头文件中  
  　　　　定义。    
  　　　c、静态数据成员因为程序一开始运行就必需存在，所以其初始化的最佳位置在类的内部实现。  
  　　C、特点  
  　　　a、对相于   public，protected，private   关键字的影响它和普通数据成员一样，    
  　　　b、因为其空间在全局数据区分配，属于所有本类的对象共享，所以，它不属于特定的类对象，在没产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它。  
   
  　　D、访问形式  
  　　　a、   类对象名.静态数据成员名  
  　　　b、   类类型名::   静态数据成员名  
   
  　　E、静态数据成员，主要用在类的所有实例都拥有的属性上。比如，对于一个存款类，帐号相对　　　于每个实例都是不同的，但每个实例的利息是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局区的内存，所以节省存贮空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了，因为它们实际上是共用一个东西。  
   
  2、静态成员函数  
   
  特点：  
  　　A、静态成员函数与类相联系，不与类的对象相联系。  
  　　B、静态成员函数不能访问非静态数据成员。原因很简单，非静态数据成员属于特定的类实例。  
   
  作用：  
  　　主要用于对静态数据成员的操作。  
  调用形式：  
  　　A、类对象名.静态成员函数名（）  
  　　B、类类型名::   静态成员函数名（）   
   

 

静态成员函数一般情况下只能访问静态成员变量，因为不接受隐含的this指针。  
  另外作为类的静态成员函数，不用声明对象，便可直接调用，例如类A的静态成员函数fun();  
  A::fun();  
   
  1、主要用于封装全局变量和全局函数。以避免在文件作用域内包含带外部连接的数据。  
  例如全局变量：int   path;int   para1;  
  解决办法：设计一个全局类，并将这些全局名称声明为静态变量，并编写静态函数来调用这些变量。  
          class   Global{  
                    static   int   s_path;  
                    static   int   s_para;  
                private:  
                    Global();//不实现，避免无意中的实例化  
                public:  
                    //manipulators  
                    static   void   setPath(int   path){s_path   =   path;}  
                    static   void   setPara(int   para){s_para   =   para;}  
                    //accessors  
                    static   int   getPath(){return   s_path;}  
                    static   int   getPara(){return   s_para;}  
          }  
  2、对自由函数的封装  
  在.h文件的文件作用域内避免使用自由函数（运算符函数除外）；在.c文件中避免使用带有外部连接的自由函数，因此可以使用静态成员函数进行处理。  
  例如：int   getPara();int   getPath();我们可以通过声明一个结构的静态方法代替：  
          struct   SysUtil{  
              static   int   getPath();  
              static   int   getPara();  
          }这样，唯一有冲突危险的就是出现类名SysUtil了。  

 

C++类静态数据成员与类静态成员函数  
  在没有讲述本章内容之前如果我们想要在一个范围内共享某一个数据，那么我们会设立全局对象，但面向对象的程序是由对象构成的，我们如何才能在类范围内共享数据呢？    
   
  　　这个问题便是本章的重点：    
   
  　　声明为static的类成员或者成员函数便能在类的范围内共同享，我们把这样的成员称做静态成员和静态成员函数。    
   
  　　下面我们用几个实例来说明这个问题，类的成员需要保护，通常情况下为了不违背类的封装特性，我们是把类成员设置为protected（保护状态）的，但是我们为了简化代码，使要说明的问题更为直观，更容易理解，我们在此处都设置为public。    
   
  　　以下程序我们来做一个模拟访问的例子,在程序中，每建立一个对象我们设置的类静态成员变自动加一，代码如下：  
   
  #include   <iostream>      
  using   namespace   std;      
       
  class   Internet      
  {      
  public:      
          Internet(char   *name,char   *address)      
          {      
                  strcpy(Internet::name,name);      
                  strcpy(Internet::address,address);      
                  count++;      
          }      
          static   void   Internet::Sc()//静态成员函数      
          {      
                  cout<<count<<endl;      
          }      
          Internet   &Rq();      
  public:      
          char   name[20];      
          char   address[20];      
          static   int   count;//这里如果写成static   int   count=0;就是错误的      
  };      
       
  Internet&   Internet::Rq()//返回引用的成员函数      
  {      
          return   *this;      
  }      
       
  int   Internet::count   =   0;//静态成员的初始化      
  void   vist()      
  {      
          Internet   a1("中国软件开发实验室","www.cndev-lab.com");      
          Internet   a2("中国软件开发实验室","www.cndev-lab.com");      
  }      
  void   fn(Internet   &s)      
  {      
          cout<<s.Rq().count;      
  }      
  void   main()      
  {      
          cout<<Internet::count<<endl;//静态成员值的输出      
          vist();      
          Internet::Sc();//静态成员函数的调用      
          Internet   b("中国软件开发实验室","www.cndev-lab.com");      
          Internet::Sc();      
          fn(b);      
          cin.get();      
  }  
   
  　　上面代码我们用了几种常用的方式建立对象，当建立新对象并调用其构造函数的时候，静态成员cout便运行加1操作,静态成员的初始化应该在主函数调用之前，并且不能在类的声明中出现，通过运行过程的观察我们发现，静态成员count的状态并不会随着一个新的对象的新建而重新定义，尽而我们了解到类的静态成员是属于类的而不是属于哪一个对象的，所以静态成员的使用应该是类名称加域区分符加成员名称的，在上面的代码中就是Internet::count，虽然我们仍然可以使用对象名加点操作符号加成员名称的方式使用，但是不推荐的，静态态类成员的特性就是属于类而不专属于某一个对象。    
   
  　　静态成员函数的特性类似于静态成员的使用,同样与对象无关，调用方法为类名称加域区分符加成员函数名称，在上面的代码中就是Internet::Sc();，静态成员函数由于与对象无关系，所以在其中是不能对类的普通成员进行直接操作的。    
   
  　　如果上面的   static   void   Internet::Sc()修改成为：    
   
   
  static   void   Internet::Sc()//静态成员函数      
  {      
          cout<<name<<endl;//错误      
          cout<<count<<endl;      
  }    
   
  　　静态成员函数与普通成员函数的差别就在于缺少this指针，没有这个this指针自然也就无从知道name是哪一个对象的成员了。  
   
  　　根据类静态成员的特性我们可以简单归纳出几点，静态成员的使用范围：    
   
  　　1.用来保存对象的个数。    
   
  　　2.作为一个标记，标记一些动作是否发生，比如：文件的打开状态，打印机的使用状态，等等。    
   
  　　3.存储链表的第一个或者最后一个成员的内存地址。    
   
  　　为了做一些必要的练习，深入的掌握静态对象的存在的意义，我们以前面的结构体的教程为基础，用类的方式描述一个线性链表，用于存储若干学生的姓名，代码如下：  
   
  #include   <iostream>      
  using   namespace   std;      
       
  class   Student      
  {      
  public:      
          Student   (char   *name);      
          ~Student();      
  public:      
          char   name[30];      
          Student   *next;      
          static   Student   *point;      
  };      
       
  Student::Student   (char   *name)      
  {      
          strcpy(Student::name,name);      
          this->next=point;      
          point=this;      
  }      
       
  Student::~Student   ()//析构过程就是节点的脱离过程      
  {      
          cout<<"析构:"<<name<<endl;      
       
          if(point==this)      
          {      
                  point=this->next;      
                  cin.get();      
                  return;      
          }      
          for(Student   *ps=point;ps;ps=ps->next)      
          {      
                  if(ps->next==this)      
                  {      
                  cout<<ps->next<<"|"<<this->next<<endl;      
                  ps->next=next;//=next也可以写成this->next;      
                  cin.get();      
                  return;      
                  }      
          }      
          cin.get();      
  }      
       
  Student*   Student::point=NULL;      
  void   main()      
  {      
          Student   *c   =   new   Student("marry");      
          Student   a("colin");      
          Student   b("jamesji");      
          delete   c;      
          Student   *fp=Student::point;      
          while(fp!=NULL)      
          {      
                  cout<<fp->name<<endl;      
                  fp=fp->next;      
          }      
          cin.get();      
  }  
   
  　　从上面的代码来看，原来单纯结构化编程需要的一个链表进入全局指针在这里被类的静态成员指针所替代(类的静态成员完全可以替代全局变量)，这个例子的理解重点主要是要注意观察类成员的析构顺序，通过对析构顺序的理解，使用析构函数来进行节点的脱链操作。