[C++]變數聲明與定義的規則

聲明與定義分離

Tips：變數能且僅能被定義一次，但是可以被多次聲明。

為了支援分離式編譯，C++將定義和聲明區分開。其中聲明規定了變數的類型和名字，定義除此功能外還會申請存儲空間並可能為變數賦一個初始值。

extern

如果想聲明一個變數而非定義它，就使用關鍵字extern並且不要顯式地初始化變數：

extern int i;      // 聲明i而非定義i
extern int i = 1;  // 定義i, 這樣做抵消了extern的作用

static

當我們在C/C++用static修飾變數或函數時，主要有三種用途：

  • 局部靜態變數
  • 外部靜態變數/函數
  • 類內靜態數據成員/成員函數

其中第三種只有C++中有，我們後續在面向對象程式設計中再探討，這裡只討論靜態局部/全局變數。

1. 靜態局部變數

在局部變數前面加上static說明符就構成靜態局部變數，例如：

// 聲明局部靜態變數
static int a;
static int array[5] = {1, 2, 3, 4, 5};
  • 靜態局部變數在函數內定義，但不像自動變數那樣當函數被調用時就存在，調用結束就消失，靜態變數的生存期為整個源程式
  • 靜態變數的生存期雖然為整個源程式，但是作用域與自動變數相同，即只能在定義該變數的函數內使用該變數，退出函數後雖然變數還存在，但不能夠使用它
  • 對基本類型的靜態局部變數如果在聲明時未賦初始值，則系統自動賦0值；而對普通局部變數不賦初始值，那麼它的值是不確定的

根據靜態局部變數的特點，它的生存期為整個源程式，在離開定義它的函數（作用域）但再次調用定義它的函數時，它又可繼續使用，而且保存了前次被調用後留下的值。因此，當多次調用一個函數且要求在調用之間保留某些變數的值時，可考慮採用靜態局部變數，雖然用全局變數也可以達到上述目的，但全局變數有時會造成意外的副作用，因此最好採用局部靜態變數。例如：

#include <iostream>

void foo() {
    int j = 0;         // 普通局部變數
    static int k = 0;  // 靜態局部變數
    ++j;
    ++k;
    printf("j:%d, k:%d\n", j, k);
}

int main(void)
{
    for (int i = 1; i <= 5; i++) {
        foo();
    }
}

// 輸出:
j:1, k:1
j:1, k:2
j:1, k:3
j:1, k:4
j:1, k:5

2. 靜態全局變數（C++廢棄，用匿名命名空間替代）

Tips：對於全局變數，不管是否被static修飾，它的存儲區域都是在靜態存儲區，生存期為整個源程式。只不過加上static後限制這個全局變數的作用域只能在定義該變數的源文件內。

全局變數（外部變數）的聲明之前加上static就構成了靜態的全局變數，全局變數本身就是靜態存儲變數，靜態全局變數當然也是靜態存儲方式。這兩者在存儲方式上並無不同，這兩者的區別在於非靜態全局變數的作用域是整個源程式。當一個源程式由多個源程式組成時，非靜態的全局變數在各個源文件中都是有效的，而靜態全局變數則限制了其作用域，即只在定義該變數的源文件內有效，在同一源程式的其他源文件中不能使用它。

這種在文件中進行靜態聲明的做法是從C語言繼承而來的，在C語言中聲明為static的全局變數在其所在的文件外不可見。這種做法已經被C++標準取消了，現在的替代做法是使用匿名命名空間。

匿名命名空間：指關鍵字namespace後緊跟花括弧括起來的一系列聲明語句，具有如下特點：

  • 在匿名命名空間內定義的變數具有靜態生命周期
  • 匿名空間在某個給定的文件內可以不連續，但是不能跨越多個文件
  • 每個文件定義自己的匿名命名空間，不同文件匿名命名空間中定義的名字對應不同實體
  • 如果在一個頭文件中定義了匿名命名空間，則該命名空間內定義的名字在每個包含該頭文件的文件中對應不同實體
namespace {
    int i;  // 匿名命名空間內定義的變數具有靜態生命周期, 作用域僅限於當前文件
}

3. 總結

static這個說明符在不同地方所起的作用域是不同的，比如把局部變數改變為靜態變數後是改變了它的存儲方式即改變了它的生存期，把全局變數改變為靜態變數後是改變了它的作用域，限制了它的使用範圍。

auto

1. C++98中auto用法（C++11已廢棄）

C++98 auto用於聲明變數為自動變數（擁有自動的生命周期），C++11已經刪除了該用法，取而代之的是「變數的自動類型推斷方法」。

// c++ 98:
int a = 10;         // 擁有自動生命期
auto int b = 20;    // 擁有自動生命期(C++11編譯不過)
static int c = 30;  // 延長了生命期

C++11新標準引入了auto類型說明符，讓編譯器通過初始值來自動推斷變數類型（這意味著通過auto定義的變數必須有初始值）。

// c++ 11:
int a = 10;
auto auto_a = a;  // 自動類型推斷為int類型

2. auto會去除變數的引用語義

當引用對象作為初始值時，真正參與初始化的是引用對象的值，此時編譯器會以引用對象的類型作為auto推算的類型：

int main(void) {
    int i = 10;
    int &ri = i;
    auto auto_i = ri;  // 去除引用語義, 自動推斷為int
}

如果希望推斷出來的auto類型包含引用語義，我們需要用&明確指出：

int main(void) {
    int i = 10;
    auto &auto_i = i;  // 加上引用語義, 自動推斷為int&
}

3. auto忽略頂層const

auto一般會忽略掉頂層const，同時底層const會被保留下來：

int main(void) {
    const int ci = 10;    // 常量int
    auto auto_ci = ci;    // auto_ci被推斷為int類型
    auto_ci = 20;         // 正確: auto_ci非常量

    const int &cr = ci;   // cr是指向常量int的常量引用
    auto auto_cr = cr;    // auto_cr被推斷為int類型: 去除了引用語義 + 去除了頂層const
    auto_cr = 20;         // 正確: auto_cr非常量

    const int *cp = &ci;  // cp是指向常量int(底層)的常量指針(頂層)
    auto auto_cp = cp;    // auto_cp被推斷為const int*類型(指向常量int的指針): 去除了頂層const + 保留底層const
    // *auto_cp = 10;     // 錯誤: 不能修改auto_cp指向的常量
}

如果希望推斷出來的auto類型是一個頂層const，我們需要通過const關鍵字明確指出：

int main(void) {
    const int ci = 10;          // 常量int
    const auto auto_ci = ci;    // auto_ci被推斷為const int類型
    // auto_ci = 20;            // 錯誤: auto_ci是一個常量, 禁止修改
}

const

有時我們希望定義一個不能被改變值的變數，可以使用關鍵字const對變數類型加以限定。

1. const對象必須初始化

因為const對象一經創建後其值就不能再改變，所以const對象必須初始化，但是初始值可以是任意複雜的表達式：

const int i = get_size();  // 正確: 運行時初始化
const int j = 42;          // 正確: 編譯時初始化
const int k;               // 錯誤: k是一個未經初始化的常量

2. 默認情況下const僅在文件內有效

舉個例子，我們在編譯時初始化一個const對象：

const int i = 10;

編譯器會在編譯過程把用到該變數的地方都替換為對應的值。為了執行這個替換，編譯器必須知道變數的初始值，如果程式包含多個文件，那麼每個用了這個const對象的文件都必須得能訪問到它的初始值才行（即每個文件都要定義const對象）。為了避免對同一變數的重複定義，當多個文件中出現同名的const對象時，其實等同於在不同文件中分別定義了獨立的變數。

/*
 * 下面是合法的, 不存在變數i重複定義問題
 */

// foo.cpp
const int i = 10;

// bar.cpp
const int i = 5;

如果想在多個文件之間共享const對象，那麼必須在變數的定義之前添加extern關鍵字：

/*
 * 下面是合法的, main.cpp和foo.cpp中的const int對象是同一個
 */

// foo.cpp
extern const int i = 10;

// main.cpp
#include <iostream>

int main(void) {
    extern int i;
    std::cout << "i:" << i << std::endl;
}

3. 允許常量引用綁定非常量對象、字面值甚至一般表達式

一般而言，引用的類型必須與其所引用對象的類型一致，但是有兩個例外：

  • 初始化常量引用時允許用任意表達式作為初始值，只要該表達式的結果能轉換成引用類型即可，允許為一個常量引用綁定非常量的對象、字面值甚至是一個一般表達式（如下）
  • 可以將基類的指針或引用綁定到派生類對象上（後續面向對象章節再探討）
int i = 10;

const int &ri1 = i;      // 合法: 綁定到非常量對象
const int &ri2 = 100;    // 合法: 綁定到字面值
const int &ri3 = 1 + 1;  // 合法: 綁定到一般表達式

4. 頂層const與底層const

指針本身是一個對象，因此指針本身是不是常量與指針所指對象是不是常量是兩個獨立的問題，前者被稱為頂層const，後者被稱為底層const。

Tips：指針類型既可以是頂層const也可以是底層const，其他類型要麼是頂層常量要麼是底層常量。

頂層const用於表示任意的對象是常量，包括算數類型、類和指針等，底層const用於表示引用和指針等複合類型的基本類型部分是否是常量。

int i = 10;

int *const p1 = &i;        // 頂層const: 不能改變p1的值
const int *p2 = &i;        // 底層const: 不能通過p2改變i的值
const int *const p3 = &i;  // 底層const + 頂層const

const int &r1 = i;         // 底層const: 不能通過r1改變i的值

constexpr

C++11引入了常量表達式constexpr的概念，指的是值不會改變並且在編譯期間就能得到計算結果的表達式。

const int i = 10;          // 常量表達式
const int j = i + 1;       // 常量表達式
const int k = size();      // 僅當size()是一個constexpr函數時才是常量表達式, 運行時才能獲得具體值就不是常量表達式

在一個複雜系統中，我們很難分辨一個初始值是否是常量表達式，通過constexpr關鍵字聲明一個變數，我們可以讓編譯器來驗證變數的值是否是一個常量表達式。

1. 字面值是常量表達式

算術類型、引用和指針都屬於字面值類型，自定義類則不屬於字面值類型，因此也無法被定義為constexpr。

Tips：儘管指針和引用都能被定義成constexpr，但它們的初始值卻受到嚴格限制。一個constexpr指針的初始值必須是nullptr、0或者是存儲於某個固定地址中的對象。

2. constexpr是對指針的限制

在constexpr聲明中定義了一個指針，限定符constexpr僅對指針有效，與指針所指對象無關：

const int *pi1 = nullptr;      // 底層const: pi1是指向整型常量的普通指針
constexpr int *pi2 = nullptr;  // 頂層const: pi2是指向整型的常量指針

我們也可以讓constexpr指針指向常量：

constexpr int i = 10;
constexpr const int *pi = &i;  // 頂層const + 底層const

Reference

[1] //www.cnblogs.com/lca1826/p/6503194.html

[2] //blog.csdn.net/u012679707/article/details/80188124

[3] C++ Primer

Tags:

VirMach 便宜 VPS

QNews

QNews