引入类型别名的两种方式

    1. typedef int MyInt;
    2. using MyInt = int;

    使用using引入类型别名的方式更好

    1. typedef char MyCharArr[4];
    2. using MyCharArr char[4];

    类型别名与指针、引用的关系

    1. 注意类型别名不是简单的替换:

    第一段代码完全没问题,是可以运行的

    1. #include <iostream>
    3. int main()
    4. {
    5.     int x = 4;
    6.     const int* ptr = &x;
    7.     int y = 5;
    8.     ptr = &y; // 可以改变指针ptr的指向
    9.     //*ptr = 7;  这一行是会报错的,注意第6行
    10. }

    第二段代码出现了问题

    1. #include <iostream>
    3. using IntPtr = int*;
    5. int main()
    6. {
    7.     int x = 4;
    8.     const IntPtr ptr = &x;
    9.     int y = 5;
    10.     ptr = &y;
    11. }

    image.png
    注意 “variable ‘ptr’ declared const here”,显然和我们的预期不符合;
    替换后的效果反而和下面的代码一样:

    1. #include <iostream>
    3. //using IntPtr = int*;
    5. int main()
    6. {
    7.     int x = 4;
    8.     int* const  ptr = &x;
    9.     int y = 5;
    10.     ptr = &y;
    11. }

    image.png
    我们可以进一步验证：

    1. #include <iostream>
    3. using IntPtr = int*;
    5. int main()
    6. {
    7.     int x = 4;
    8.     const IntPtr ptr = &x;
    9.     *ptr = 7;
    10.     std::cout << x;
    11. }

    image.png

    因此，我们应该将指针类型别名视为一个整体，在此基础上引入常量表示指针为常量的类型

    1. 不能通过类型别名构造引用的引用

    下面这段代码：

    1. #include <iostream>
    2. #include <type_traits>
    4. using RefInt = int&;
    5. using RefRefInt = RefInt&;
    7. int main()
    8. {
    9.     std::cout << std::is_same_v<RefInt,RefRefInt> << std::endl;
    10. }

    image.png
    可见 int& 和 RefInt 、RefRefInt是同一种类型