介紹

在C語言中，使用指針(Pointer)可以間接獲取、修改某個變量的值;
在C++中，使用引用(Reference)可以起到跟指針類似的功能

int age = 10;
// rAge就是一個引用
int &rAge = age;

注意點

• 引用相當(dāng)于是變量的別名(基本數(shù)據(jù)類型、枚舉、結(jié)構(gòu)體、類、指針、數(shù)組等，都可以有引用)
  基本數(shù)據(jù)類型:

int age = 10;
    int &rAge = age;
    rAge = 30;
    
    cout << age << endl; /// 30

枚舉:

enum Seasion {
    Spring,
    Summer,
    Fall,
    Winter
};

int main(int argc, const char * argv[]) {
    Seasion seasion;
    Seasion &rSeasion = seasion;
    rSeasion = Fall;
    
    cout << seasion << endl; // 2
    
    return 0;
}

結(jié)構(gòu)體：

struct Student {
    int num;
    int score;
};

int main(int argc, const char * argv[]) {
    
    Student stu;
    Student &rStu = stu;
    rStu.num = 20;
    
    cout << stu.num << endl;
    
    return 0;
}

指針:

int main(int argc, const char * argv[]) {
    int a = 10;
    int b = 30;
    int *p = &a;
    int *&rp = p;
    rp = &b;
    *p = 20;
    
    cout << a << endl;
    cout << b << endl;
    return 0;
}

數(shù)組：

int main(int argc, const char * argv[]) {
    
    int array[4] = {10, 30};
    int (&rArray)[4] = array;
    rArray[3] = 20;
    
    cout << array[3] << endl;
    
    return 0;
}

• 對引用做計算，就是對引用所指向的變量做計算
• 在定義的時候就必須初始化，一旦指向了某個變量，就不可以再改變，“從一而終”
• 可以利用引用初始化另一個引用，相當(dāng)于某個變量的多個別名

int main(int argc, const char * argv[]) {
    
    int age = 10;
/// rAge、rAge1、rAge2、rAge3都是對age的引用
    int &rAge = age;
    int &rAge1 = rAge;
    int &rAge2 = rAge1;
    int &rAge3 = rAge2;
    
    rAge3 = 20;
    
    cout << age << endl;
    
    return 0;
}

• 不存在【引用的引用、指向引用的指針、引用數(shù)組】

int age = 10;
int &rAge = age;
int &&rAge1 = &rAge;  /// 此行是錯誤的
int *&rAge2 = &rAge;  /// 此行是錯誤的
int array[4] = {10, 30};
int &rArray[4] = array;  /// 此行是錯誤的

引用存在的價值之一：比指針更安全、函數(shù)返回值可以被賦值

• 交換兩個變量的值

void switchValue(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

int main(int argc, const char * argv[]) {
    int v1 = 20;
    int v2 = 30;
    
    switchPosition(v1, v2);
    
    cout << "v1 is " << v1 << endl;
    cout << "v2 is " << v2 << endl;
    
    return 0;
}

const

const是常量的意思，被其修飾的變量不可修改；
如果修飾的是類、結(jié)構(gòu)體(的指針)，其成員也不可以更改
const修飾的是其右邊的內(nèi)容：

    // *p0是常量，p0不是常量
    const int *p0 = &age;
    // *p1是常量，p1不是常量
    int const *p1 = &age;
    // p2是常量，*p2不是常量
    int * const p2 = &age;
    // *p3是常量，p3是常量
    const int * const p3 = &age;
    // *p4是常量，p4是常量
    int const * const p4 = &age;

常引用

定義
被const修飾的引用，且const必須在&的左邊

const引用的特點

• 可以指向臨時數(shù)據(jù)(常量、表達(dá)式、函數(shù)返回值等)

int func() {
    return 10;
}

int main(int argc, const char * argv[]) {
    
    int a = 10;
    int b = 20;
    
    const int &c = a + b;
    const int &d = func();
    cout << c << endl;
    cout << d << endl;
    
    return 0;
}

• 可以指向不同類型的數(shù)據(jù)，此種情況在編譯階段，會生成一個臨時變量，當(dāng)修改被引用的變量的值時，引用變量的值仍然保留（稍后補(bǔ)匯編截圖）

    int age = 10;
    const double &rAge = age;
    age = 30;
    cout << age << endl; /// 30
    cout << rAge << endl; /// 10

• 作為函數(shù)參數(shù)時(此規(guī)則也適用于const指針)
  可以接受const和非const實參(非const引用，只能接受非const實參)
  可以跟非const引用構(gòu)成重載

int sum(const int &a, const int &b) {
    cout << "sum(const int &a, const int &b)" << endl;
    return a + b;
}

int sum(int &a, int &b) {
    cout << "sum(int &a, int &b)" << endl;
    return a + b;
}

int main(int argc, const char * argv[]) {
    
    int a = 10;
    int b = 20;
    cout << sum(a, b) << endl;
    cout << sum(20, 30) << endl;
    
    return 0;
}

當(dāng)常引用指向了不同類型的數(shù)據(jù)時，會產(chǎn)生臨時變量，即引用指向的并不是初始化時的那個變量

數(shù)組的引用

int array[] = {10, 20, 30};
int (&rArray)[3] = array;
int * const &rArray2 = array;

引用的本質(zhì)：

• 就是指針，只是編譯器削弱了它的功能，所以引用就是弱化了的指針
• 一個引用占用一個指針的大小
• 如何證明？
  從代碼角度

struct Student {
    int &age;
};

int main(int argc, const char * argv[]) {
    
    cout << sizeof(Student) << endl;
    return 0;
}

從匯編角度