C++深度解析 引用的本質分析（4）

引用

是另一個變數的別名。（或者是一個已經存在儲存空間的別名）

引用在一些場合可以代替指標。

例項一：

#include <stdio.h>

void swap(int& a, int& b)
{
    int t = a;
    a = b;
    b = t;
}

int main()
{
    int a = 1;
    int b = 2;
    
    swap(a, b);
    
    printf("a = %d, b = %d\n", a, b);   
    
    return 0;
}
 

const引用

用法：const Type& name <<-----等價於------>> Type* const name;

const引用讓變數擁有只讀屬性。

當使用常量對const引用進行初始化時，C++編譯器會為常量值分配空間，並將引用名作為這段空間的別名。

例項一（下列使得變數擁有隻讀屬性）：

#include <stdio.h>

void Example()
{
    printf("Example:\n");
    
    int a = 4;
    const int& b = a;//引用
    int *p = (int *)&b;
    
    //b = 5; //錯誤，b使得a變成只讀變數

    *p = 5;
    
    printf("a = %d\n", a);
    printf("b = %d\n", b);
}

void Demo()
{
    printf("Demo:\n");
    
    //初始化引用為1，這樣子就得到只讀變數c，分配了4個位元組的空間，c就是這4個位元組空間的別名
    const int& c = 1;      //int temp = 1， const int& c = temp
    int *p = (int *)&c;   
    
    //c = 5; //c是隻讀
    
    *p = 5;
    
    printf("c = %d\n", c);
}

int main(int argc, char *argv[])
{
    Example();
    
    printf("\n");
    
    Demo();
    
    return 0;
}
 

引用有自己的儲存空間

注意：

C++編譯器在編譯過程中，用指標常量作為引用的內部實現，因此引用所佔用的空間大小與指標相同。

從使用的角度，引用只是一個別名，C++為了實用性而隱藏了引用的儲存空間這一細節。

示例一：

#include <stdio.h>

struct TRef
{
    char& r;
};

int main(int argc, char *agrv[])
{
    char c = 'c';
    char& rc = c;
    TRef ref = { c };
    
    printf("sizeof(char&) = %d\n", sizeof(char&)); //1
    printf("sizeof(rc) = %d\n", sizeof(rc)); //sizeof(c) => 1
    
    printf("sizeof(TRef) = %d\n", sizeof(TRef));
    printf("sizeof(ref.r) = %d\n", sizeof(ref.r)); //sizeof(c) => 1
}
 

結果如下：

引用的本質是Type&  =  Type* const。所以上述示例中，char& r = char *const r（內部實現的），所以sizeof(TRef) = 4，指標佔用4位元組的空間。

引用的儲存空間

示例程式碼一：

#include <stdio.h>

struct TRef
{
    char *before;//4個位元組  起始地址:0xbfcbc71c
    char& ref;    //4個位元組     0xbfcbc724 - 0xbfcbc71c = 8
    char* after;//4個位元組  起始地址:0xbfcbc724
};

int main(int argc, char *argv[])
{
    char a = 'a';
    char& b = a;
    char c = 'c';
    
    TRef r = {&a, b, &c};
    
    printf("sizeof(r) = %d\n", sizeof(r));
    printf("sizeof(r.before) = %d\n", sizeof(r.before));
    printf("sizeof(r.after) = %d\n", sizeof(r.after));
    printf("&r.before = %p\n", &r.before);
    printf("&r.after = %p\n", &r.after);

}

結果如下：

示例程式碼二：

• 使用常量對const引用初始化時，編譯器會自動分配一段空間，
• 使用變數對const引用初始化時，編譯器不會分配空間，而是將const引用和變數捆綁在一起

#include <stdio.h>
int main()
{
    int c = 0;
    
    const int& a = 1; //定義const引用a，指定a的初始化是個常量1
    const int& b = c; //定義const引用b，指定b的初始化是個變數c
    
    int *p = (int *)&a;
    
    
    //b = 2;          //錯誤，不能直接修改const引用的內容，因為b是個只讀變數
    
    *p = 10;          //改變const引用a的內容
    printf("a = %d, b = %d, c = %d\n", a, b, c);
    
    p = (int *)&b;
    *p = 10;           //改變const引用b的內容
    printf("a = %d, b = %d, c = %d\n", a, b, c);
    
    return 0;
}

結果如下：

• const引用a初始化的是一個常量1，但卻能被修改成功，說明a有自己的一段儲存空間
• 而const引用b被指標修改後，變數c也跟著改變，說明const引用b和變數c的儲存空間是一起的
• 所以，在C++中，const修飾的是常量，而const &修飾的是只讀變數（可以通過指標修改值）

函式返回引用

示例程式一：

#include <stdio.h>

int& demo() //其實返回 int *const（內部實現）
{
    int d = 0;
    
    printf("demo: d = %d\n", d);
    
    return d;//返回區域性變數d的本身 return &d;
}

int& func()
{
    static int s = 0;//儲存在全域性的儲存區
    
    printf("func: s = %d\n", s);
    
    return s;//返回靜態區域性變數的引用 return &s
}

int main(int argc, char* argv[])
{
    int& rd = demo();
    int& rs = func();
    
    printf("\n");
    printf("main: rd = %d\n", rd);//這裡的rd相當與野指標
    printf("main: rs = %d\n", rs);
    printf("\n");
    
    rd = 10;//很危險，demo的區域性變數d已經不存在了
    rs = 11;//對rs的操作，相當於對s的操作
    
    demo();
    func();//靜態區域性變數s的別名rs,對rs的操作，相當於對s的操作
    
    printf("\n");
    printf("main: rd = %d\n", rd);//rd所代表的4位元組空間已經不存在了，沒意義
    printf("main: rs = %d\n", rs);
    printf("\n");
    
    return 0;
}

結果如下：

引用可以在最大程度上，避開記憶體操作的錯誤。引用的本質就是指標。

小結：

引用作為變數別名而存在旨在代替指標

const引用可以使得變數具有隻讀屬性

引用在編譯器內部使用指標常量實現

引用的最終本質為指標

引用可以儘可能的避開記憶體錯誤