C++ Primer：引用、指针和const的用法总结

「爱情、让人受尽委屈。」 2023-06-28 06:29 8阅读 0赞

--------------------

# 1. 背景 #

在看《C++ Primer》第二章的引用、指针、和const时，发现看的有些迷糊，现总结一下引用、指针和const的用法。

# 2 引用 #

1.  引用并非对象，只是别名。
2.  引用必须在定义时初始化，且只能绑定一个对象。
3.  引用只能绑定对象，不能绑定字面值或表达式的计算结果。引用的类型必须与其所绑定对象的类型精确匹配（有2个例外，对常量的引用和对基类的引用）。

#include <iostream>
    using namespace std;
    
    int main()
    {
        int i = 1;
        double d = 3.14;
    
        //引用必须在定义时初始化
        int &r1 = i;
        int &r2; // r2未初始化
    
        //引用只能绑定对象（左值），不能绑定字面值或表达式的计算结果（右值）
        int &x1 = i;
        int &x2 = 1; // 错误，引用不能绑定字面值
        int &x3 = 3 + i; //错误，引用不能绑定计算结果
    
        //引用的类型必须与其所绑定对象的类型匹配
        int &y1 = i;
        int &y2 = d;//错误，类型不匹配，y2绑定int，而d是double
    
        //引用即别名
        r1 = 10;//i1=10
    
        return 0;
    }

# 3. 指针 #

1.  指针是对象，可指向不同对象，可以不在定义时赋初值。
2.  指针的类型必须与其所指对象的类型一致（有2个例外，指向常量的指针和指向基类的指针）。
3.  void \*指针可以存放任意类型的指针，但无法操作其指向的对象。

#include <iostream>
    using namespace std;
    
    int main()
    {
        int i1 = 1, i2 = 2;
        double d = 3.14;
    
        // 指针可以不在定义时初始化
        int *p1;
    
        // 指针可以指向不同对象
        p1 = &i1;
        p1 = &i2;
    
        //指针的类型必须与其所指对象的类型一致
        int *p2 = &i1;
        int *p3 = &d; // 错误，类型不匹配，p3指向int，d是double
    
        // void*可以存放任意类型的指针，但无法操作其指向的对象
        void *p4 = &i1;
        p4 = &d;
        cout << p4 << endl;
        cout << *p4 << endl;// 错误，p4是void *，无法操作其所指的对象
    
        return 0;
    }

# 4. const #

1.  const定义时必须初始化，且不可修改。
2.  引用特例：只要表达式能转换成引用的类型，对常量的引用就允许以它作为初始值。
3.  指针特例：指向常量的指针可以指向一个相应的非常量对象。

#include <iostream>
    using namespace std;
    
    int main()
    {
        int i = 0;
        double d = 3.14;
    
        // const必须在定义时初始化
        const int ci = 3;
    
        // const对象不可修改
        ci = z1;
    
        //对常量的引用
        const int &r1 = ci;
    
        //引用特例：若表达式能转换成引用类型，则对常量的引用允许以它作为初始值
        const int &r2 = 30; //30是字面值，可类型转换成const int
        //等价于
        const int temp2 = 30; //类型转换
        const int &r2 = temp2;
    
        const int &r3 = d; //d可从double转换成const int
        //等价于
        const int temp3 = d; //类型转换
        const int &r3 = temp3;
    
        int &r4 = d; //假设表达式正确，则可以通过修改r4来修改d
        //等价于
        int temp4 = d;   //r4指向int，d是double，需先进行类型转换
        int &r4 = temp4; //此时，r4绑定temp，而通过修改r4只能修改temp4，无法修改d。结果与假设矛盾
    
        //指向常量的指针
        const int *p1 = &ci;
        //指针特例：指向常量的指针可以指向一个相应的非常量对象，
        const int *p2 = &i; // 正确，特例，     p2指向const int，i是int
        const int *p3 = &d; // 错误，类型不匹配，p3指向const int，d是double
    
        //本身是常量的指针
        int *const x1 = &i;
        int *const x2 = &ci; // 错误，类型不匹配，x2指向int，ci是const int
        int *const x3 = &d;  // 错误，类型不匹配，x3指向int，d是double
    
        const int *const y1 = &ci;
        const int *const y2 = &i; // 正确，指针特例：y2指向const int，i是int
        const int *const y3 = &d; // 错误，类型不匹配，y3指向const int，d是double
    
        return 0;
    }