c++中static的用法詳解

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>=8

sum=12

sizeof<rect1>=8

sum=18

sizeof<rect2>=8

由圖可知：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的對象不要緊。

二、靜態成員函數：用於修飾 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同樣。  ————————————————  原文連接：https://blog.csdn.net/majianfei1023/article/details/45290467