【C++】C++入门（上）https://developer.aliyun.com/article/1514546?spm=a2c6h.13148508.setting.23.4b904f0ejdbHoA
3、const 常引用
const 修饰的原理：缩小了原有的读写权限，由可读可写变成了只能读不能写。
void test() { // 我变成你的别名的条件：不变或者缩小你的读写权限是可以的，放大你的读写权限是不行的 const int a = 10; //int& ra = a; // 编译出错，ra变成a的别名，能读能写，放大了读写权限 const int& ra = a; //int& b = 10; // 编译出错，b为常量 const int& b = 10; double d = 12.34; //int& rd = d; // 编译出错，类型不同 const int& rd = d; }
int i = 10; //double& r = i; //错误 const double& r = i; //正确
在 C++ 中，引用必须与其引用的对象具有相同的类型，或者可以通过隐式类型转换来匹配。
- 函数传参如果想减少拷贝使用引用传参，如果函数中不改变这个参数最好使用 const 引用传参。
- const 引用的好处是保护实参，避免被误改，且它可以传普通对象也可以传 const 对象。
int main() { char ch = 0xff; int j = 0xff; if (ch == j) // ch被整型提升成int类型，生成一个int类型的临时变量与j比较 { cout << "相同" << endl; } else { cout << "不相同" << endl; // 隐式类型转换也会产生临时变量，所以程序运行结果是：不相同 } return 0; }
4、使用场景
（1）做函数参数
a. 形参变量的改变，要影响到实参，用指针或引用解决
// 交换两数的值(指针做参数) -- 原来的写法 void Swap(int* p1, int* p2) { int tmp = *p1; *p1 = *p2; *p2 = tmp; } // 交换两数的值(引用做参数) -- 现在的写法 void Swap(int& ra, int& rb) { int tmp = ra; ra = rb; rb = tmp; } int main() { int a = 3, b = 5; //Swap(&a, &b); Swap(a, b); return 0; }
b. 引用在顺序栈中应用，如果为了减少传参时的拷贝，提高效率，以及保护形参不会被改变，用const 常引用
typedef struct Stack { int* a; int top; int capacity; }Stack; // 这里的引用是为了通过改变形参来影响实参 void StackInit(Stack& s) { // ... // 栈的初始化会改变指针的指向 } // 这里的常引用是为了减少传参时的拷贝，提高效率，以及保护形参不会被改变 void StackPrint(const Stack& s) { // ... } int main() { Stack st; StackInit(st); StackPrint(st); return 0; }
c. const 常引用做参数的第二个好处，既可以接收变量，也可以接收常量
void func(const int& n) { //... } int main() { int i = 10; func(i); // 传变量 func(20); // 传常量 const int j = 30; func(j); // 传常变量 return 0; }
【总结】
- 引用做参数，通过改变形参来影响实参。
- 引用做参数，减少传参时的拷贝，提高效率（尤其是当参数变量比较大时）。
- 如果函数中不改变形参的话，建议用 const 常引用做参数，因为：
- 可以保护形参避免被误改变。
- 即可以传普通对象，还可以传 const 对象。
（2）做函数返回值
int& Add(int a, int b) { int c = a + b; return c; // 函数结束后，c变量就没有意义了 } int main() { int& ret = Add(1, 2); // 引用Add函数返回值 Add(3, 4); cout << "Add(1, 2) is :" << ret << endl; // 7 // 具体得看平台销毁栈帧时是否会清理栈帧空间，但是这种写法本身就是越界的，是错误的 return 0; }
- 函数运行时，系统需要给该函数开辟独立的栈空间，用来保存该函数的形参，局部变量以及一些寄存器信息等。
- 函数运行结束后，该函数对应的栈空间就被系统回收了。
- 空间被回收指该块栈空间暂时不能使用，但是内存本身还在。
注意 ：
如果函数返回时，出了函数的作用域，如果返回对象还在（还没还给系统），则可以使用 引用返回 ；
如果已经还给系统了，则必须使用 传值返回 。
5、传值、传引用比较
（1）传值、传引用的效率比较
#include <iostream> #include <time.h> using namespace std; struct A { int a[10000]; // 4万字节的空间 }; // 传值，会拷贝4万字节的空间 void TestFunc1(A a) {} // 传引用 void TestFunc2(A& a) {} void TestRefAndValue() { A a; // 1、以值作为函数参数 size_t begin1 = clock(); for (size_t i = 0; i < 10000; ++i) { TestFunc1(a); } size_t end1 = clock(); // 2、以引用作为函数参数 size_t begin2 = clock(); for (size_t i = 0; i < 10000; ++i) { TestFunc2(a); } size_t end2 = clock(); // 分别计算两个函数运行结束后的时间： cout << "TestFunc1(A)-time:" << end1 - begin1 << endl; cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl; } int main() { TestRefAndValue(); return 0; }
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
（2）值返回和引用返回的性能比较
#include <iostream> #include <time.h> using namespace std; struct A { int a[10000]; // 4万字节的空间 }; A a; // 值返回，会产生临时变量，且发生一次临时变量的拷贝 A TestFunc1() { return a; } // 引用返回 A& TestFunc2() { return a; } void TestReturnByRefOrValue() { // 1、以值作为函数的返回值类型 size_t begin1 = clock(); for (size_t i = 0; i < 100000; ++i) { TestFunc1(); } size_t end1 = clock(); // 2、以引用作为函数的返回值类型 size_t begin2 = clock(); for (size_t i = 0; i < 100000; ++i) { TestFunc2(); } size_t end2 = clock(); // 计算两个函数运算完成之后的时间 cout << "TestFunc1 time:" << end1 - begin1 << endl; cout << "TestFunc2 time:" << end2 - begin2 << endl; } int main() { TestReturnByRefOrValue(); return 0; }
通过上述代码运行后的结果比较，发现传值和指针在作为传参以及返回值类型上效率相差很大，传值返回效率很低。
6、引用和指针的区别
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。底层实现意思就是编译转换成汇编去实现这个语法（VS 调式模式打开反汇编代码）。
int main() { int a = 10; int& ra = a; ra = 20; int* pa = &a; *pa = 20; return 0; }
引用和指针的汇编代码对比：
【引用和指针的不同点】
- 引用概念上定义一个变量的别名，指针存储一个变量地址。
- 引用在定义时必须初始化，指针没有要求。
- 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
- 没有 NULL 引用，但有 NULL 指针。
- 在 sizeof 中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位平台下占4个字节，64 位平台下占 8 个字节）。
- 引用自加即引用的实体增加 1，指针自加即指针向后偏移一个类型的大小。
- 有多级指针，但是没有多级引用。
- 访问实体方式不同，指针需要显式解引用，引用是编译器自己处理。
- 引用比指针使用起来相对更安全，指针容易出现野指针、空指针等非法访问问题。
七、内联函数
1、概念
以 inline 修饰的函数叫做 内联函数 ，编译时 C++ 编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。
如果在上述函数前增加 inline 关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。
查看方式：
- 在 release 模式下，查看编译器生成的汇编代码中是否存在 call Add。
- 在 debug 模式下，需要对编译器进行设置，否则不会展开（因为在 debug 模式下，编译器默认不会对代码进行优化，下面给出 VS2019 的设置方式）。
2、特性
- inline 是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
- inline 对于编译器而言只是一个建议，不同编译器关于 inline 实现机制可能不同，一般建 议：将函数规模较小（即函数不是很长，具体没有准确的说法，取决于编译器内部实现）、不是递归、且频繁调用的函数采用 inline 修饰，否则编译器会忽略 inline 特性。下图为 《C++prime》 第五版关于 inline 的建议：
- inline 不建议声明和定义分离，分离会导致链接错误。因为 inline 被展开，就没有函数地址了，链接就会找不到。
// test.h #include <iostream> using namespace std; inline void f(int i); // test.cpp #include "test.h" void f(int i) { cout << i << endl; } // main.cpp #include "test.h" int main() { f(10); return 0; }
链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用。
【回顾】宏的优缺点？
优点：
- 增强代码的复用性。
- 提高性能。
缺点：
- 不方便调试宏。（因为预编译阶段进行了替换）
- 导致代码可读性差，可维护性差，容易误用。
- 没有类型安全的检查 。
C++ 有哪些技术替代宏？
- 常量定义换用 const enum 。
- 短小函数定义换用内联函数。
八、auto关键字（C++11）
1、类型别名思考
由于接触到的程序愈变复杂，导致类型难于拼写 ，含义不明确导致容易出错。
#include <string> #include <map> int main() { std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange", "橙子" }, {"pear","梨"} }; std::map<std::string, std::string>::iterator it = m.begin(); while (it != m.end()) { //.... } return 0; }
std::map::iterator 是一个类型，但是该类型太长了，很容易写错，我们可以通过 typedef 给类型取别名，比如：
#include <string> #include <map> typedef std::map<std::string, std::string> Map; int main() { Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} }; Map::iterator it = m.begin(); while (it != m.end()) { //.... } return 0; }
使用 typedef 给类型取别名确实可以简化代码，但是 typedef 有会遇到新的难题：
typedef char* pstring; int main() { const pstring p1; const pstring* p2; return 0; }
编译结果失败。在上述代码中，pstring 被定义为指向 char 类型的指针，而 const pstring p1; 则表示 p1 是一个常量指针，指向的值不能更改。然而， 在定义常量指针时，必须给它进行初始化，而这里没有对 p1 进行初始化，因此会导致编译失败。同样地，const pstring* p2; 表示 p2 是一个指向常量指针的指针，同样需要进行初始化。编译器会报错提示缺少初始化。
在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的
类型。
2、auto简介
在早期 C / C++ 中 auto 的含义是：使用 auto 修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它，为什么呢？
因为在 C / C++ 中，如果没有使用任何存储类别关键字（如 auto、static、extern 等），则变量默认为自动存储类别。因此，使用 auto 关键字对于自动存储类别的变量来说没有实际意义。
C++11 中，标准委员会赋予了 auto 全新的含义即：auto 不再是一个存储类型指示符，而是作为一 个新的类型指示符来指示编译器，auto 声明的变量必须由编译器在编译时期推导而得。
int TestAuto() { return 10; } int main() { int a = 10; auto b = a; auto c = 'a'; auto d = TestAuto(); cout << typeid(b).name() << endl; // int cout << typeid(c).name() << endl; // char cout << typeid(d).name() << endl; // int // auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化 return 0; }
注意 ： 使用 auto 定义变量时必须对其进行初始化 ，在编译阶段编译器需要根据初始化表达式来推导 auto 的实际类型。因此 auto 并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在 编译 期会将 auto 替换为变量实际的类型。
3、auto 的使用细则
（1）auto 与指针和引用结合起来使用
用 auto 声明指针类型时， 用 auto 和 auto* 没有任何区别 ，但用 auto 声明引用类型 时则必须 加 & 。
int main() { int x = 10; auto a = &x; auto* b = &x; auto& c = x; cout << typeid(a).name() << endl; // int* cout << typeid(b).name() << endl; // int* cout << typeid(c).name() << endl; // int *a = 20; *b = 30; c = 40; return 0; }
（2）在同一行定义多个变量
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错。因为 编译
器实际只对第一个类型进行推导 ，然后用推导出来的类型来定义其他的变量。
void TestAuto() { auto a = 1, b = 2; // 编译成功 auto c = 3, d = 4.0; // 编译失败，因为c和d的初始化表达式类型不同 }
（3）auto 不能推导的场景
- auto 不能作为函数的参数。
void TestAuto(auto a) {} // 编译失败：auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
- auto 不能直接用来声明数组。
void TestAuto() { int a[] = {1, 2, 3}; auto b[] = {4，5，6}; // error }
- 为了避免与 C++98 中的 auto 发生混淆，C++11 只保留了 auto 作为类型指示符的用法。
- auto 在实际中最常见的优势用法就是跟以后会讲到的 C++11 提供的新式 for 循环，还有在 lambda 表达式等进行配合使用。
九、基于范围的for循环（C++11）
1、范围for的语法
在 C++98 中如果要遍历一个数组，可以按照以下方式进行：
void TestFor() { int array[] = {1, 2, 3, 4, 5}; // 通过数组下标遍历，修改每个元素的值 for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i) { array[i] *= 2; } // 通过指针遍历打印 for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p) { cout << *p << endl; } }
对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因
此 C++11 中引入了基于范围的 for 循环。
for 循环后的括号由冒号 ":" 分为两部分：第一部分是 范围内用于迭代的变量 ，第二部分则表示 被迭代的范围 。
void TestFor() { int array[] = {1, 2, 3, 4, 5}; // 自动依次取数组中的元素赋值给e，e是别名，e的改变就是数组的改变 for(auto& e : array) { e *= 2; } // 自动依次取数组中的值赋值给e，自动判断结束 for(auto e : array) { cout << e << " "; } return 0; }
注意：与普通循环类似，可以用 continue 来结束本次循环，也可以用 break 来跳出整个循环。
2、范围 for 的使用条件
范围 for实际上是通过编译器转换成汇编代码，底层和普通遍历等是一样。
（1）for 循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供 begin 和 end 的方法，begin 和 end 就是 for 循环迭代的范围。
void TestFor(int array[]) { // array在这里已经不是一个数组了，数组名一传递就退化成指针了，无法判断大小 for(auto& e : array) { cout << e << endl; } cout << endl; }
（2）迭代的对象要实现 ++ 和 == 的操作
十、指针空值 nullptr（C++11）
指针其实就是一个编号，指针本质是以字节为单位内存空间的编号，空指针并不是不存在，而是内存的第一个字节的编号，一般我们不使用这个字节存有效数据，用空指针一般是用来初始化，表示指针指向一块没有存有效数据的而空间。
1、C++98 中的指针空值
在良好的 C / C++ 编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现
不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
void TestPtr() { int* p1 = NULL; int* p2 = 0; // …… }
NULL 实际是一个宏，在传统的 C 头文件（stddef.h）中，可以看到如下代码：
#ifndef NULL #ifdef __cplusplus #define NULL 0 #else #define NULL ((void *)0) #endif #endif
可以看到，NULL 可能被定义为字面常量 0，或者被定义为无类型指针 (void*) 的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：
void f(int) { cout << "f(int)" << endl; } void f(int*) { cout << "f(int*)" << endl; } int main() { f(0); f(NULL); f((int*)NULL); return 0; }
程序本意是想通过 f(NULL) 调用指针版本的 f(int*) 函数，但是由于 NULL 被定义成 0，因此与程序的初衷相悖。在 C++98 中，字面常量 0 既可以是一个整形数字，也可以是无类型的指针 (void*) 常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转 (void*)0 。
2、C++11 中的指针空值
- 在使用 nullptr 表示指针空值时，不需要包含头文件，因为 nullptr 是 C++11 作为新关键字引入的。
- 在 C++11 中，sizeof(nullptr) 与 sizeof((void*)0) 所占的字节数相同。
- 为了提高代码的健壮性，在后续表示指针空值时建议最好使用 nullptr。
