【轉載】 c++中static的用法詳解

標籤：執行   佔用   區別   iostream   ext   為什麼   log   類對象   font   

出處：

http://blog.csdn.net/majianfei1023/article/details/45290467

 

C 語言的 static 關鍵字有三種（具體來說是兩種）用途：

1. 靜態局部變數：用於函數體內部修飾變數，這種變數的生存期長於該函數。、

int foo(){      static int i = 1; // note:1      //int i = 1;  // note:2      i += 1;      return i;  }  

要明白這個用法，我們首先要瞭解c/c++的記憶體分布，以及static所在的區間。

對於一個完整的程式，在記憶體中的分布情況如：　 
1.棧區： 由編譯器自動分配釋放，像局部變數，函數參數，都是在棧區。會隨著作用於退出而釋放空間。
3.堆區：程式員分配並釋放的地區，像malloc(c),new(c++) 
3.全域資料區(靜態區)：全域變數和靜態便令的儲存是放在一塊的，初始化的全域變數和靜態變數在一塊地區，未初始化的全域變數和未初始化的靜態變數在相鄰的另一塊地區。程式結束釋放。
4.代碼區

所以上面note:1的static是在全域資料區分配的,那麼它存在的意思是什嗎？又是什麼時候初始化的呢？

首先回答第一個問題：它存在的意義就是隨著第一次函數的調用而初始化，卻不隨著函數的調用結束而銷毀(如果把以上的note:1換成note:2,那麼i就是在棧區分配了，會隨著foo的調用結束而釋放)。
那麼第二個問題也就浮出水面了，它是在第一次調用進入note:1的時候初始化（當初面試被坑過，我居然說是一開始就初始化了，汗！！）。且只初始化一次，也就是你第二次調用foo(),不會繼續初始化，而會直接跳過。


那麼它跟定義一個全域變數有什麼區別呢，同樣是初始化一次，連續調用foo()的結果是一樣的，但是，使用全域變數的話，變數就不屬於函數本身了，不再僅受函數的控制，給程式的維護帶來不便。
　　靜態局部變數正好可以解決這個問題。靜態局部變數儲存在全域資料區，而不是儲存在棧中，每次的值保持到下一次調用，直到下次賦新值。


那麼我們總結一下，靜態局部變數的特點（括弧內為note:2,也就是局部變數的對比）：
（1）該變數在全域資料區分配記憶體(局部變數在棧區分配記憶體);
（2）靜態局部變數在程式執行到該對象的聲明處時被首次初始化，即以後的函數調用不再進行初始化(局部變數每次函數調用都會被初始化);
（3）靜態局部變數一般在聲明處初始化，如果沒有顯式初始化，會被程式自動初始化為0(局部變數不會被初始化);
（4）它始終駐留在全域資料區，直到程式運行結束。但其範圍為局部範圍，也就是不能在函數體外面使用它(局部變數在棧區，在函數結束後立即釋放記憶體);


2.靜態全域變數：定義在函數體外，用於修飾全域變數，表示該變數只在本檔案可見。

static int i = 1;  //note:3  //int i = 1;  //note:4      int foo()  {      i += 1;      return i;  }  

note:3和note:4有什麼差異呢？你調用foo(),無論調用幾次，他們的結果都是一樣的。也就是說在本檔案內調用他們是完全相同的。那麼他們的區別是什麼呢？
檔案隔離！

 

假設我有一個檔案a.c,我們再建立一個b.c,內容如下。

//file a.c    //static int n = 15;  //note:5  int n = 15;  //note:6    //file b.c  #include <stdio.h>    extern int n;    void fn()  {      n++;      printf("after: %d\n",n);  }      void main()  {      printf("before: %d\n",n);      fn();  }  

我們先使用note:6,也就是非靜態全域變數，發現輸出為:
before: 15
after: 16


也就是我們的b.c通過extern使用了a.c定義的全域變數。
那麼我們改成使用note:5,也就是使用靜態全域變數呢？

 

gcc a.c b.c -o output.out

會出現類似undeference to "n"的報錯，它是找不到n的，因為static進行了檔案隔離，你是沒辦法訪問a.c定義的靜態全域變數的，當然你用 #include "a.c",那就不一樣了。

以上我們就可以得出靜態全域變數的特點：

靜態全域變數不能被其它檔案所用(全域變數可以);
其它檔案中可以定義相同名字的變數，不會發生衝突(自然了，因為static隔離了檔案，其它檔案使用相同的名字的變數，也跟它沒關係了);


3.靜態函數：準確的說，靜態函數跟靜態全域變數的作用類似：

//file a.c  #include <stdio.h>      void fn()  {      printf("this is non-static func in a");  }      //file b.c  #include <stdio.h>      extern void fn();  //我們用extern聲明其他檔案的fn(),供本檔案使用。      void main()  {      fn();  }  

可以正常輸出：this is non-static func in a。
當給void fn()加上static的關鍵字之後呢？ undefined reference to "fn".

所以，靜態函數的好處跟靜態全域變數的好處就類似了：
1.靜態函數不能被其它檔案所用;
2.其它檔案中可以定義相同名字的函數，不會發生衝突;

上面一共說了三種用法，為什麼說準確來說是兩種呢？
1.一種是修飾變數，一種是修飾函數，所以說是兩種（這種解釋不多）。
2.靜態全域變數和修飾靜態函數的作用是一樣的，一般合并為一種。（這是比較多的分法）。



C++ 語言的 static 關鍵字有二種用途：
當然以上的幾種，也可以用在c++中。還有額外的兩種用法：

1.待用資料成員：用於修飾 class 的資料成員，即所謂“靜態成員”。這種資料成員的生存期大於 class 的對象（實體 instance）。待用資料成員是每個 class 有一份，普通資料成員是每個 instance 有一份，因此待用資料成員也叫做類變數，而普通資料成員也叫做執行個體變數。

#include<iostream>      using namespace std;      class Rectangle  {  private:      int m_w,m_h;      static int s_sum;        public:      Rectangle(int w,int h)      {          this->m_w = w;          this->m_h = h;          s_sum += (this->m_w * this->m_h);      }          void GetSum()      {          cout<<"sum = "<<s_sum<<endl;      }      };      int Rectangle::s_sum = 0;  //初始化          int main()  {      cout<<"sizeof(Rectangle)="<<sizeof(Rectangle)<<endl;      Rectangle *rect1 = new Rectangle(3,4);      rect1->GetSum();      cout<<"sizeof(rect1)="<<sizeof(*rect1)<<endl;      Rectangle rect2(2,3);      rect2.GetSum();      cout<<"sizeof(rect2)="<<sizeof(rect2)<<endl;            system("pause");      return 0;  }  

結果如下：

由圖可知：sizeof(Rectangle)=8bytes=sizeof(m_w)+sizeof(m_h)。也就是說 static 並不佔用Rectangle的記憶體空間。
那麼static在哪裡分配記憶體的呢？是的，全域資料區(靜態區)。
再看看GetSum()，第一次12=3*4，第二次18=12+2*3。由此可得，static只會被初始化一次，於執行個體無關。

結論：

對於非待用資料成員，每個類對象(執行個體)都有自己的拷貝。而待用資料成員被當作是類的成員，由該類型的所有對象共用訪問,對該類的多個對象來說，待用資料成員只分配一次記憶體。
待用資料成員儲存在全域資料區。待用資料成員定義時要分配空間，所以不能在類聲明中定義。

也就是說，你每new一個Rectangle，並不會為static int s_sum的構建一份記憶體拷貝，它是不管你new了多少Rectangle的執行個體，因為它只與類Rectangle掛鈎，而跟你每一個Rectangle的對象沒關係。

2、靜態成員函數：用於修飾 class 的成員函數。
我們對上面的例子稍加改動：

#include<iostream>      using namespace std;      class Rectangle  {  private:      int m_w,m_h;      static int s_sum;        public:      Rectangle(int w,int h)      {          this->m_w = w;          this->m_h = h;          s_sum += (this->m_w * this->m_h);      }          static void GetSum()  //這裡加上static      {          cout<<"sum = "<<s_sum<<endl;      }      };      int Rectangle::s_sum = 0;  //初始化          int main()  {      cout<<"sizeof(Rectangle)="<<sizeof(Rectangle)<<endl;      Rectangle *rect1 = new Rectangle(3,4);      rect1->GetSum();      cout<<"sizeof(rect1)="<<sizeof(*rect1)<<endl;      Rectangle rect2(2,3);      rect2.GetSum();  //可以用對象名.函數名訪問      cout<<"sizeof(rect2)="<<sizeof(rect2)<<endl;      Rectangle::GetSum();  //也可以可以用類名::函數名訪問          system("pause");      return 0;  }  

上面注釋可見:對GetSum()加上static，使它變成一個靜態成員函數，可以用類名::函數名進行訪問。
那麼靜態成員函數有特點呢？
1.靜態成員之間可以相互訪問，包括靜態成員函數訪問待用資料成員和訪問靜態成員函數;
2.非靜態成員函數可以任意地訪問靜態成員函數和待用資料成員;
3.靜態成員函數不能訪問非靜態成員函數和非待用資料成員;
4.調用靜態成員函數，可以用成員訪問操作符(.)和(->)為一個類的對象或指向類對象的指標調用靜態成員函數,也可以用類名::函數名調用(因為他本來就是屬於類的，用類名調用很正常)


前三點其實是一點：靜態成員函數不能訪問非靜態(包括成員函數和資料成員)，但是非靜態可以訪問靜態，有點暈嗎？沒關係，我給你個解釋，
因為靜態是屬於類的，它是不知道你建立了10個還是100個對象，所以它對你對象的函數或者資料是一無所知的，所以它沒辦法調用，而反過來，你建立的對象是對類一清二楚的(不然你怎麼從它那裡執行個體化呢)，所以你是可以調用類函數和類成員的，就像不管GetSum是不是static，都可以調用static的s_sum一樣。

 

【轉載】 c++中static的用法詳解