【C++修炼之路】1. 初窥门径

C++之初窥门径

• 1. 命名空间
• • 1.1 命名空间定义
  • 1.2 命名空间的使用
• 2. C++输入&输出
• • 输入输出的三种方式
• 3. 缺省参数
• • 3.1 缺省参数的概念
  • 3.2 缺省参数分类
• 4. 函数重载
• • 4.1 函数重载的概念
  • 4.2 函数重载和缺省参数混用
  • 4.3 C++支持函数重载的原理--名字修饰
• 5. 引用（重点）
• • 5.1 引用概念
  • 5.2 引用特性
  • 5.3 常引用
  • 5.4 使用场景
  • #5.4深入错误代码的栈帧剖析
  • #5.4 引用与重载之间发生的矛盾关系
  • 5.5 函数返回值为引用的优点及作用
  • 5.6 传值、传引用效率比较
  • 5.7 引用和指针的区别
• 6. 内联函数
• • 6.1 概念
  • 6.2 特性
  • 6.3 内联函数的适用范围
• 7. auto关键字(C++11)
• • 7.1 类型别名思考
  • 7.2 auto简介
  • 7.3 auto的使用细则
  • 8.3 auto不能推导的场景
• 8. 基于范围的for循环(C++11)
• • 8.1 范围for的语法
  • 8.2 范围for的使用条件
• 9. 指针空值nullptr(C++11)
• • 9.1 C++98中的指针空值
• 10. 总结

1. 命名空间

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

#include <stdio.h>
#include <stdlib.h>
int rand = 10;
// C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决
int main()
{
    printf("%d\n", rand);
    return 0;
}
// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”

由于在头文件<stdlib.h>中，存在着rand()函数，因此当我们定义全局变量rand = 10时，就会产生命名冲突，因为rand原本已经代表着函数名，是函数的地址，因此上述定义会报错。

1.1 命名空间定义

示例 1：限定域

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

#include<stdio.h>
#include<stdlib.h>

    // 不影响变量生命周期，只是限定域，编译查找规则
    // 默认查找规则。先在局部查找，再全局找

namespace bit
{
    int rand = 10;
    int x = 1;
}
void func()
{
    printf("%p\n", rand);
    printf("%d\n", bit::x);
    printf("%d\n", bit::rand);
}
int main()
{
    func();
    printf("%p\n", rand);
}

当我们将上述的全局变量外部加上namespace 限定之后，其仍然代表全局变量，但有了限定域，想使用定义的rand变量，就需要用bit::rand

才能代表这个变量，直接用rand变量就会是<stdlib.h>中的函数的地址,示例如下：

image-20220915011432597

示例2： 命名冲突

当我们定义了两个相同的函数名，但是里面涵盖的计算方法不同，为了防止命名冲突，可以用两个限定域分别限定：

// bit是命名空间的名字，一般开发中是用项目名字做命名空间名。
// 避免命名冲突
// 
namespace bit
{
    // 命名空间中可以定义变量/函数/类型
    int rand = 10;
    int Add(int left, int right)
    {
        return left + right;
    }
    struct Node
    {
        struct Node* next;
        int val;
    };
}
namespace byte
{
	int add(int left, int right)
	{
		return left * 10 + right * 10;
	}

	struct Node
	{
		struct Node* left;
		struct Node* right;
		int val;
	};
}

int main()
{
    printf("%d\n", bit::Add(1, 2));
    struct bit::Node node;
    struct byte::Node dnode;

}

通过限定符，就可以将两个函数进行区分，需要注意的是，对于结构体来说，其限定之后，再利用需要注意将限定符放在struct 之后，名称之前，即：struct bit::Node node;

示例3：命名空间嵌套

namespace N1
{
    int a;
    int b;
    int Add(int left, int right)
    {
        return left + right;
    }
    namespace N2
    {
        int c;
        int d;
        int Sub(int left, int right)
        {
            return left - right;
        }
    }
}

int main()
{
    N1::a = 1;
    N1::N2::c = 2;
    return 0;

}

命名空间是可以进行嵌套的，即可以无限的进行套娃下去。

示例4：命名空间的合并

同一个工程中允许存在多个相同名称的命名空间，编译器最后会合成同一个命名空间中。一个工程中的Stack.h和上面Queue.h中两个N1会被合并成一个：

image-20220915013157122

需要注意的是，对于合并来说，必须是同级的才能进行合并，不是同级的但名字相同虽然语法没有错误，但是仔细想一想，这种方式是不可取的，会发生歧义，即一家人中的父亲和孩子不可能叫同一个名字，因此，像下面的例子这样是没有必要的：

namespace N1 // 没意义，语法上可以，但是不能合并，因为不是同级
{
	int a = 0;
	namespace N1
	{
		int b = 0;
	}
}

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

1.2 命名空间的使用

对于下面的代码，命名空间应该如何使用呢？

namespace bit
{
    // 命名空间中可以定义变量/函数/类型
    int a = 0;
    int b = 1;
    int Add(int left, int right)
    {
        return left + right;
    }
    struct Node
    {
        struct Node* next;
        int val;
    };
}
int main()
{
    // 编译报错：error C2065: “a”: 未声明的标识符
    printf("%d\n", a);
    return 0;

对于上面的输出a，由于并没有声明他所在的限定域，因此找不到a,并且会报错。

因此引入命名空间使用的三种方式：

• 加命名空间名称及作用域限定符

int main()
{
  printf("%d\n", N::a);
  return 0;  
}

• 使用using将命名空间中的某个成员引入

using N::b;
int main()
{
  printf("%d\n", N::a);
  printf("%d\n", b);
  return 0;  
}

• 使用using namespace 命名空间名称引入

using namespce N;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;  
}

2. C++输入&输出

先来看一下C++是如何问候的：

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中，std相当于已经定义好的限定域，并且里面都已经定义了各种关键字和函数等
using namespace std;
int main()
{
    cout<<"Hello world!!!"<<endl;
    return 0;
}

说明：

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。(三种方法)
2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含<iostream>头文件中。
3. <<是流插入运算符，>>是流提取运算符。
4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。
5. 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，这些知识我们我们后续才会学习，所以我们这里只是简单学习他们的使用。后面我们还有有一个章节更深入的学习IO流用法及原理。

注意：

早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用<iostream>+std的方式。

#include <iostream>
using namespace std;
int main()
{
    int a;
    double b;
    char c;

    // 可以自动识别变量的类型
    cin>>a;
    cin>>b>>c;

    cout<<a<<endl;
    cout<<b<<" "<<c<<endl;
    return 0;
}

关于cout和cin还有很多更复杂的用法，比如控制浮点数输出精度，控制整形输出进制格式等等。因为C++兼容C语言的用法，这些又用得不是很多,因此，当我们需要控制格式以及精度时，仍然可以利用printf得形式输出。

std命名空间使用惯例：

std是C++标准库的命名空间，如何展开std使用更合理呢？

1. 在日常练习中，建议直接using namespace std即可，这样就很方便。
2. using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对 象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 +using std::cout展开常用的库对象/类型等方式。

输入输出的三种方式

• 直接用限定符

#include <iostream>

int main()
{
	std::cout << "hello world" << std::endl;
	std::cout << "hello world" << std::endl;
	std::cout << "hello world" << std::endl;

	return 0;
}

• 通过拆离隔离墙

#include <iostream>

using namespace std;
// 用起来就方便了，命名的隔离墙拆了
// 日常练习，小程序，这么用可以，项目最好不要这么用

int cout = 0;

int main()
{
	cout << "hello world" << endl;
	cout << "hello world" << endl;
	//std::cout << "hello world" << std::endl;

    return 0;
}

• 指定展开

#include <iostream>
// 指定展开 -- 常用展开，自己定义的时候避免跟常用重名即可
using std::cout;

int main()
{
	cout << "hello world" << std::endl;
	cout << "hello world" << std::endl;
    std::cout << "hello world" << std::endl;

	return 0;
}

std是一个域名，不过这个域是在文件iostream中已经限定好的，因此当我们需要std,就需要iostream

3. 缺省参数

3.1 缺省参数的概念

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

void Func(int a = 0)
{
    cout<<a<<endl;
}

int main()
{
    Func();   // 没有传参时，使用参数的默认值  0
    Func(10);  // 传参时，使用指定的实参   10
    return 0;
}

3.2 缺省参数分类

• 全缺省参数

void Func(int a = 10, int b = 20, int c = 30)
{
  cout<<"a = "<<a<<endl;
  cout<<"b = "<<b<<endl;
  cout<<"c = "<<c<<endl;
}

• 半缺省参数

void Func(int a, int b = 10, int c = 20)
{
  cout<<"a = "<<a<<endl;
  cout<<"b = "<<b<<endl;
  cout<<"c = "<<c<<endl;
}

需要注意的是：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义的同时出现，因为一旦缺省的数量和值不同，就会造成歧义，引发错误。

//a.h
 void Func(int a = 10);
 // a.cpp
 void Func(int a = 20)
{}
 // 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用哪个缺省值。

1. 缺省值必须是常量或者全局变量
2. C语言不支持（编译器不支持）缺省

4. 函数重载

自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。比如：以前有一个笑话，国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前者是“谁也赢不了！”，后者是“谁也赢不了！”

4.1 函数重载的概念

函数重载： 是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的 形参列表(参数个数 或 类型 或 类型顺序) 不同，常用来处理实现功能类似数据类型不同的问题。

1. 参数类型不同

#include<iostream>
using namespace std;

int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}
double Add(double left, double right)
{
    cout << "double Add(double left, double right)" << endl;
    return left + right;
}

对于参数类型，对于这个例子，我们看的不是返回值的类型，而是括号内部的参数类型，由于参数类型不同，我们传参时就可以依据调用时传参的类型来判断是哪个函数在调用。如果括号内部的参数类型相同而返回类型不同的话，我们仍然判断不了应该采用哪个函数，这不满足重载的要求。

1. 参数个数不同

void f()
{
    cout << "f()" << endl;
}
void f(int a)
{
    cout << "f(int a)" << endl;
}

通过在调用时我们发现，如果不传入参数，调用的就是第一个函数，传入一个整形参数，调用的就是第二个。

1. 参数类型顺序不同

void f(int a, char b)
{
    cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
    cout << "f(char b, int a)" << endl;
}

对于参数类型顺序来说，这种方式作为参数传入时会因顺序不同而调对应顺序的函数，在C语言中，char也属于整型变量，而在重载中就有了明显的区分。

下面来演示一下上面函数的例子：

int main()
{
    Add(10, 20);
    Add(10.1, 20.2);
    f();
    f(10);
    f(10, 'a');
    f('a', 10);
    return 0;
}

image-20220915161711899

4.2 函数重载和缺省参数混用

//构成函数重载 -- f()调用会报错，存在歧义
void f()
{
	cout << "f()" << endl;
}

void f(int a = 0, char b = 1)
{
	cout << "f(int a,char b)" << endl;
}

int main()
{
	f(10);
	f(10, 20);

	f(); // 歧义  二义性

	return 0;
}

对于重载和缺省参数混用的时候，缺省参数的引用一样构成重载，但需要注意的是，当按照缺省参数的思想不传入值时，虽然对于缺省满足条件，但同时也对另一个重载函数满足条件，这样无法区分调用的是哪一个函数，因此同时混用时需要注意其中之间的冲突，也被称为二义性。

对于下面的引用也是如此。

4.3 C++支持函数重载的原理–名字修饰

为什么C++支持函数重载，而C语言不支持函数重载呢？

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。（这个具体在程序的编译和链接里讲过）

image-20220915162449538

image-20220915162503943

1. 实际项目通常是由多个头文件和多个源文件构成，而通过C语言阶段学习的编译链接，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？
2. 所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o的符号表中找Add的地址，然后链接到一起。
3. 那么链接时，面对Add函数，链接接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。
4. 由于Windows下vs的修饰规则过于复杂，而Linux下g++的修饰规则简单易懂，下面我们使用了g++演示了这个修饰后的名字。
5. 通过下面我们可以看出gcc的函数修饰后名字不变。而g++的函数修饰后变成【_Z+函数长度+函数名+类型首字母】。

• 采用C语言编译器后的结果

image-20220915162716775

结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

• 采用C++编译器编译后结果

image-20220915162751962

结论：在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。

• Windows下名字修饰规则

image-20220915163028736

对比Linux会发现，windows下vs编译器对函数名字修饰规则相对复杂难懂，但道理都是类似的，我们就不做细致的研究了。

【扩展学习：C/C++函数调用约定和名字修饰规则–，里面有对vs下函数名修饰规则讲解】

[C/C++ 函数调用约定](C/C++ 函数调用约定_低调的狮子的博客-CSDN博客)

1. 通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。
2. 如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。

5. 引用（重点）

5.1 引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

比如：李逵，在家称为 “铁牛” ，江湖上人称 “黑旋风” 。

类型& 引用变量名(对象名) = 引用实体；

void TestRef()
{
  int a = 10;
  int& ra = a;//<====定义引用类型
  printf("%p\n", &a);
  printf("%p\n", &ra);
}

image-20220916083958328

通过运行，得出这两个地址是相同的，也就是说，a和ra是同一块空间的不同名字，即这两个的存储内容也是一样的。

需要注意的是：引用类型必须和引用实体是同种类型的

5.2 引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

void TestRef()
{
    int a = 10;
    // int& ra;  // 该条语句编译时会出错
    int& ra = a;
    int& rra = a;
    printf("%p %p %p\n", &a, &ra, &rra); 
}

在上述代码中，发现a变量可以同时被多个引用，注释的代码去掉注释后，就会产生报错，因为没有初始化，就相当于起小名但是不知道是给谁取小名，这个小名变的毫无意义。

5.3 常引用

void TestConstRef()
{
    const int a = 10;
    //int& ra = a;  // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;
}

对于上述代码来说，涉及到了权限的放大和缩小。

1. 先来看看第一行和下面的注释，当给已经const的a定义别名时，ra是int类型而不是const类型，这代表着权限的放大，因为a的值不能被修改，但这么定义的话就可以通过ra来修改，因此这种定义时错误的，正确的方式是不让他的权限放大，即定义相同类型的别名，如第三行代码所示。
2. 继续向下看，到了第三行的注释，b直接给10取了别名，但是常量10连原本的名字都没有，并且不可修改，取别名是毫无意义的，因此第三行注释掉的是错误的。我们应该在修饰的时候同样利用const限制权限，不让其能够改变，这才是权限不变，不加const代表着权限放大。
3. 到了最后一组，定义d为double类型，当我们通过这样int& rd = d;时，虽然表面上的类型不对是int与double直接的差别，然而事实却不是这样。当把double类型的d赋值给int类型的a,这是一个权限缩小的行为，是可以的。然而，d在赋值给int类型的a时，在底层会发生强转，即double类型强转成int类型，这就涉及到一个新的知识，在强转赋值的时候，并不是直接把d取整赋值给a，而是会产生一个临时的变量来储存d强转后的结果并且赋值给a的也是这个临时变量，这个临时变量具有常性，不能修改，因此，下一行注释掉的代码错误的类型出错不是double变int,而是const int 不能被int直接接受，这属于权限放大，所以最后一行代码前面加上const之后，就修正了这个错误！

除此之外，一些函数定义参数或许也有const void& x 即：

void Func(const int& x)
{
   // ...
}

在只使用不更改的前提下，当我们利用库函数的时候，有的已经定义好函数的参数类型就像这样被封装好，因为引用的效率比指针高。

5.4 使用场景

1. 做参数

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

通过这样定义别名，可以算是指针的另一种替换方式。

引用和指针是重叠的，就像这样：

image-20220916160249492

1. 做返回值（重点）

在正式谈到引用返回之前，先思考一下正常的传值返回，以如下代码举例：

int Count()
{
    static int n = 0;
    n++;
    //...
    return n;
}

因为返回值的引入离不开函数栈帧，因此我们利用这个代码进行解释函数调用：

image-20220916161409707

这段代码的流程：

1. 首先进入到main函数，创建了main函数的栈帧，接下来在这层栈帧中创建ret变量，由于栈是向下生长的，此时在main函数的下一层栈帧中创建了Count函数的栈帧，在这层栈帧中，在静态区创建了n,并且让其++，最后返回n，在这里返回的n不是原来的n，而是n的拷贝（如果这个n值的空间大小最多4个字节，就存储在寄存器中，因为寄存器的内存比较小，如果大于这个内存大小，就会在这层栈帧的某一个位置创建临时空间） ，因为函数结束之后这层栈帧会还给操作系统，当然，此例子的n不会被销毁，因为其创建在静态区。因此这样的传值返回是可以的。
2. 接下来看看下面的代码：

int& Count()
{
    static int n = 0;
    n++;
    // ...
    return n;
}

如果返回的类型变成了int&这代表着最后返回的值是n的别名而不是拷贝，当然，对于此函数栈帧销毁，n仍然存在，因为其是在静态区，不会因为栈帧的销毁而销毁，所以上面的代码也是正确的，值得一提的是上面的代码也减少了拷贝的过程，提高了效率。

#5.4深入错误代码的栈帧剖析

1. 那么问题来了，如果n没有被static修饰但是仍按照int&返回，这样就会产生一系列的问题：（如下代码，此代码为错误示范，并且会解释错误原因）

int& Count()
{
    int n = 0;
    n++;
    // ...
    return n;
}

按照栈帧来讲，Count函数结束会被销毁，并且如果返回值是int，将会创建临时变量拷贝n的值。但此返回值是int&,这也就代表着返回的不是临时变量，而是n的本身，从命名上来讲也是小名，但我们知道，没有被static修饰的n会随着函数栈帧的销毁而随着销毁，销毁不代表空间消失，而是还给了操作系统，空间仍然存在，只是使用权不是我们的了，我们存的数据不被保护（就是你存的变量可能被销毁，可能不被销毁），最形象的解释就是：对于住酒店来说，如果预订了房间，那么此时这个房间就是你的，你可以放任何东西，就相当于函数开辟栈帧之后可以定义变量，但当把房间退掉之后，这个房间将不属于你，还给了酒店，酒店也就相当于操作系统，但是你的东西是有是无取决于后续有没有客人居住。好,经过这样的比喻之后，再看这个返回值，我们不知道后续有没有客人回来，因此，这个返回的n的值是随机的，如果没有客人，那就是1，如果有，那就不确定。

接下来看看有趣的事情：

image-20220916164738033

我们知道这样操作是错误的，但是发现，销毁之后，仍然是这个值，这就是因为在Count()调用之前没有调用别的函数或者没有操作别的变量，也就是相当于后续没有客人居住，也就代表着退房后落下这个房间的东西并没有消失

image-20220916164712564

但当我们继续输出时，下面的第一个cout(函数)会创建栈帧，也就是有新的客人来，这样你的东西就有可能不复存在，因此第二次输出的ret变成了随机值。

（注意图片的序号，下文解释会根据序号说明）

image-20220916165032086

再看看上面的图片，又是一个有趣的事情，先不解释具体原因，继续往下看：

image-20220917114007222

我们发现，这两个的共同之处在于调用函数之后会将ret的随机数变成函数里面的变量，这个奇特的现象的解释需要对函数栈帧具有一定的理解：那我们来分析具体原因吧：

通过上图的右侧的栈帧得出，建立main函数之后，经过一步步运行，创建了Count函数的栈帧，第一次输出的现象已经解释过是由于函数没有继续调用，第二次调用输出是随机值的原因是因为Count所在的栈帧销毁了，即被第一个cout函数覆盖，因此是随机值，对于图1，再调用Count函数时，发现仍能将ret变成1，这个现象的发生就是因为当经过第二个cout函数之后，cout调用之后也会销毁，并且又由Count函数覆盖，这也变相说明了函数开辟栈帧的位置始终没有发生变化。对于图2，也是同样的道理，虽然不是同一个函数，但是其函数开辟栈帧的大小是相同的，并且都是定义了一个变量，（n++并不会额外的开辟空间）因此，这个函数的位置也仍然是之前Count函数的位置，x的地址也是之前n的地址，由于ret是这个地址内部变量的别名，因此其也会变成x对应的值。我们可以打印地址验证一下：

image-20220917115642040

我们会发现x与n的地址是一样的，这就有力的证明了我们之前的思维是正确的。

当然，如果在Func函数中多定义几个变量，那么ret的值不一定会落在哪个变量身上，因为编译器不同，其内部操作是不同的，因此分配到的地址也是不一定的。

需要注意的是，由于编译器的版本不同，对于错误的程序其debug下的运行结果也有可能不同，底层的环境可能由于版本的更替而增加一些改变，但真正的原理不会改变； 由于我使用的是vs2019，第一次没有打印这两个地址的情况下最后打印的并不是100，而在vs2013的环境下，没有打印地址最后出来的是100，当时这让我很是费解，因为按照栈帧的思想，vs2013的结果是正确的，vs2019就和我们预测的结果不一样了，虽然这种实验本身就是错误的，但是错误也会在栈帧上得到的结果也会有一定的规律，因为我知道栈帧有关的知识，因此我也就知道x和n的地址是一样的，而ret作为n的引用，因此ret和x的地址也是一样的，那么就是说，最后打印的应该和x的值一样，而第一次的结果是最后一个数不是100，而是随机值，出现了随机值就意味着两者地址不一样，但这是不对的，于是为了验证，我将两个地址都打印，结果不出所料，两个地址是一样的，而最后打印出现的值也就变成了如上图的100，通过这个一点点的测试，对于我而言，收获是巨大的，我既知道了不同版本编译器的底层实现有所区别，也知道真理不会随着编译器版本的不同而产生差异，而通过自己打印出的地址，我认为这是对编译器的一种提示，提示编译器这两个地址是一样的，从这格提示我又重新定义了编译器，也有可能和人一样，犯一些细节上的错误。

好，上面的总结经验已经分享给大家，接下来看看release下的运行结果是这样：

image-20220917120123834

因为release版本下运行会优化代码程序，会将一些错误进行避免，但对于我们来说，debug环境下才是真正的程序结果。

#5.4 引用与重载之间发生的矛盾关系

这是对重载的一个补充。我们知道，重载的前提条件是函数参数的类型或个数或顺序不同。而如果对于两个函数，这两个函数惟一的区别是参数类型，一个是传引用，一个是传值的情况就会发生歧义现象，因为不知道调用的是哪个函数

image-20220917153651569

因此我们在使用重载是应该避免这样的歧义情况。

5.5 函数返回值为引用的优点及作用

回顾一下之前的顺序表的实现函数

void SLInit(SL* sl);
void SLDestory(SL* sl);
//头插头删，尾插尾删
//push->插
//pop->删
void SLPushBack(SL* psl, SLDataType x);
void SLPushFront(SL* psl, SLDataType x);
void SLPopBack(SL* psl);
void SLPopFront(SL* psl);

void SLPrint(SL* psl);

// 没有找到就返回-1
int SLFind(SL* psl, SLDataType x);
// 顺序表在pos位置插入x
void SLInsert(SL* psl, size_t pos, SLDataType x);
// 顺序表删除pos位置的值
void SLErase(SL* psl, size_t pos);

//修改
void SLModify(SL* psl, size_t pos, SLDataType x);

查看顺序表完整代码

以其中一个函数为例：

void SLModify(SL* psl, size_t pos, SLDataType x)
{
	assert(psl);
	assert(pos < psl->size);
	psl->a[pos] = x;
}

当我们单拿出来SLModify函数时，会发现这个函数在修改时非常的挫，因为如果我们需要实现一个功能：将所有的偶数2，那么事实上对于这个来说，就需要先找到偶数的下标，并且将这个偶数2当做参数传进去才能进行修改。

既然说到这里，也就该到了使用引用的好处了，我们可以再增加两个函数替代SLModify

size_t SLSize(SL* psl)//返回长度
{
	assert(psl);
	return psl->size;
}

SLDataType& SlAt(SL* psl, size_t pos)//介绍这个修改
{
	assert(psl);
	assert(pos < psl->size);

	return psl->a[pos];
}

int main()
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);

	// 偶数*2;
	for (size_t i = 0; i < SLSize(&sl); ++i)
	{
		if (SlAt(&sl, i) % 2 == 0)
		{
			SlAt(&sl, i) *= 2;
		}
	}

	for (size_t i = 0; i < SLSize(&sl); ++i)
	{
		cout << SlAt(&sl, i) << endl;// 1  4  3  8
	}


	SLDestory(&sl);

	return 0;
}

对于SLAt函数，传入的参数是sl的地址,因此当我们返回值时，返回的是这个变量引用，也就是别名，与原来的变量是同一个变量，因此我们通过引用返回之后可以直接对返回值进行修改，最终实现Modify具有的修改功能！

5.6 传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
    A a;
    // 以值作为函数参数
    size_t begin1 = clock();
    for (size_t i = 0; i < 10000; ++i)
        TestFunc1(a);
    size_t end1 = clock();
    // 以引用作为函数参数
    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;
}

image-20220917123102904

通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。

5.7 引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main()
{
    int a = 10;
    int& ra = a;
    cout<<"&a = "<<&a<<endl;
    cout<<"&ra = "<<&ra<<endl;
    return 0;
}

image-20220917123405469

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
    int a = 10;
    int& ra = a;
    ra = 20;
    int* pa = &a;
    *pa = 20;
    return 0;
}

我们来看下引用和指针的汇编代码对比：

image-20220917123530082

发现在引用时，二者的汇编代码是相同的。

引用和指针的不同点：

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

6. 内联函数

6.1 概念

以**inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开**，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

用示例具体解释一下：

先来看看普通的调用函数：

image-20220920110537094

这样调用函数就是我们对函数栈帧了解的常识，通过符号表的地址找到函数的地址并直接进行引用。

由于上面的概念提到，内联函数不建立栈帧，因此，在普通的debug环境下是没办法使用的，因为debug会进行调试，调试就会利用栈帧，因此需要进行一系列的设置或者直接将debug换成release环境。

• 在debug环境下进行一系列设置：

image-20220920111604116

环境配置完之后看看内联之后汇编的变化：

image-20220920111728544

我们发现，这里直接就是mov和add，并没有Add函数地址的声明，因此，内联函数就是将内部之间展开使用，而不是创建栈帧后生成符号表。

6.2 特性

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为《C++prime》第五版关于inline的建议：

image-20220920124824751

• 第二条特性中，为什么建议函数规模较小且不频繁调用的函数才用内联呢？

关于这个，整个第二条特性说的其实都是这个问题，比如像递归那样的函数，由于没有栈帧，其所有的执行情况都会在编译的时候展开使用，这样函数的规模就变得非常大，那么这个问题同样可以变成：为什么函数长了以后不展开呢？ 最准确的回答是因为代码膨胀 ，由于内联函数是直接展开，如果调用次数过多或者函数展开过长，会给程序造成很大的开销，这反而远离了我们使用内联函数的初衷。 对于调用次数过多来举例：假设内联函数有30条指令，如果有10000个调用的地方，我们采用内联函数之后，就会将其一一展开，原本的1行函数就会变成30行，那么总的行数就会变成：30*10000 = 30w行，但如果不使用内联函数，这样就是30+10000 = 10030行，并且编译好的指令影响的是可执行程序的大小，也就是安装包（包括.exe和.dll等静态/动态库); 对于安装包来说，一定是越小越好（更新软件时间越快越好，内存越小越好）。可见，这种情况下，内联的效率远远低于直接调用原本的函数的栈帧的效率。

此外，我们也发现，上述红色框处的Note,这个具体的意思是对于内联来说，如果出现了我们上述叙述的情况，即代码膨胀的情况，编译器将会拒绝这个请求，也就是不按照内联函数展开，而是像原本一样利用函数栈帧，生成符号表，我们看看实操：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>

inline int func(int x, int y)
{
	int ret = x + y;
	ret = x + y;
	ret = x + y;
	ret = x / y;
	ret += x + y;
	ret = x + y;
	ret -= x + y;
	ret = x + y;
	ret = x * y;
	ret = x + y;
	ret = x + y;
	return ret;
}

int main()
{
	int ret = func(10, 20);

	return 0;
}

当我们设置完debug环境后，假设我们在函数中多调用语句：会发现仍然调用了栈帧，产生符号表中函数的地址。

image-20220920131136562

接下来看看如果函数很短的话：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>

inline int func(int x, int y)
{
	int ret = x + y;
	
	return ret;
}

int main()
{
	int ret = func(10, 20);

	return 0;
}

image-20220920131250978

出现的结果就和我们想的一样，直接展开不产生符号表中函数的地址！因此，内联函数是否能够请求成功还是看编译器。

1. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

对于这个问题，上述已经提到过内联之后，函数由于不建立栈帧因此不会产生地址，在链接的时候声明与此函数定义的符号表中的地址也不会合并，通过之前的文章：程序的编译和链接，我们知道在最后链接的过程中，函数定义的地址和函数声明的地址在符号表中最后会合并成定义的地址（因为声明函数的地址不是函数的真正地址），由于内联不产生地址，这最后符号表合并之后的地址也就不是其函数定义的地址，因此这样会引发错误。 当然，如果我们定义内联函数与main()函数在同一个文件中（同一个.cpp)就不会出现链接的情况，所以即便我们定义内联函数，在一个文件中无论形不形成符号表，都不会报错，也就是说无论函数是否建立栈帧生成地址都不会影响，即这样：

image-20220921104256645

image-20220921104443614

6.3 内联函数的适用范围

1. 可以替换宏：
   • 宏的缺点：
     1. 不能进行调试
     2. 没有安全类型检查
     3. 容易写错
2. 频繁调用小函数
   • 类似于经常用到的Swap函数，inline优化后没有栈帧消耗

7. auto关键字(C++11)

7.1 类型别名思考

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

1. 类型难于拼写
2. 含义不明确导致容易出错

#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<std::string, std::string>::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;
}

在这个代码中，第二个是错误的，因为typedef不像define一样在预编译阶段进行文本替换，也就是说并不会在预编译阶段用char*去替换pstring，既然替换不了，那么肯定找不到pstring*，所以pstring*是错误的。

在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的类型。然而有时候要做到这点并非那么容易，因此C++11给auto赋予了新的含义。

7.2 auto简介

在早期C/C++中auto的含义是：使用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;
    cout << typeid(c).name() << endl;
    cout << typeid(d).name() << endl;
    //auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
    return 0;
}

image-20220920140205690

我们发现，auto定义能够自动识别变量的类型。

【注意】

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

7.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;
  cout << typeid(b).name() << endl;
  cout << typeid(c).name() << endl;
  *a = 20;
  *b = 30;
  c = 40;
  return 0;
}

image-20220920140615258

1. 在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

void TestAuto()
{
  auto a = 1, b = 2;
  auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

8.3 auto不能推导的场景

1. auto不能作为函数的参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

1. auto不能直接用来声明数组

void TestAuto()
{
  int a[] = {1,2,3};
  auto b[] = {4，5，6};
}

1. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
2. auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用。

8. 基于范围的for循环(C++11)

8.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 };
    for(auto& e : array)
        e *= 2;
    for(auto e : array)
        cout << e << " ";
    return 0;
}

注意，auto&中的&是必要的，通过上面我们知道&是取别名，即地址一样，可以通过修改e从而修改数组元素，如果没有&，e只是一个临时拷贝，改变e并不能改变数组。

与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

8.2 范围for的使用条件

1. for循环迭代的范围必须是确定的 对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。 注意：以下代码就有问题，因为for的范围不确定

void TestFor(int array[])
{
  for(auto& e : array)
    cout<< e <<endl;
}

因为函数传数组，参数只能是指针，因此以指针为：后的条件是错误的。

1. 迭代的对象要实现++和==的操作。 （由于水平有限，暂不做讨论）

9. 指针空值nullptr(C++11)

9.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*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦。

在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void*)0。

注意：

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

10. 总结

这篇很长的文章到这里就结束了，具体讲解了C++对于C语言不足之处的补充，其中的引用更是重中之重，C++的修炼之路将从这篇起始。