【C++】C++入门（下）-阿里云开发者社区

【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。

【C++】C++入门（下）