devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

手撕C++入门基础

作者：小舞很执着 | 2024-08-17 21:06:25

赞

踩

手撕C++入门基础


1.C++介绍

C++课程包括：C++语法、STL、高阶数据结构

C++参考文档：Reference - C++ Reference

C++ 参考手册 - cppreference.com

cppreference.com

C++兼容之前学习的C语言

2.C++的第一个程序

打印hello world

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. // test.cpp
  3. // 这⾥的std cout等我们都看不懂，没关系，下⾯我们会依次讲解
  4. #include<iostream>
  5. using namespace std;
  6.  
  7. int main()
  8. {
  9.     cout << "hello world\n" << endl;
  10.     return 0;
  11. }

在这个代码中我们有很多地方不清楚

  1. 头文件 #include

  2. main函数上面的代码：using namespace std;

  3. 打印hello world的代码：cout << "hello world\n" << endl;

那么下面我们就逐次进行学习这些我们不懂的东西

3.命名空间namespace

1.namespace的价值

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

c语⾔项⽬类似下⾯程序这样的命名冲突是普遍存在的问题，C++引⼊namespace就是为了更好的解决这样的问题

  1. #include <stdio.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. int rand = 10;
  5. int main()
  6. {
  7.     // 编译报错：error C2365: “rand”: 重定义；以前的定义是“函数”
  8.     printf("%d\n", rand);
  9.     return 0;
  10. }
  11. //当头文件只有stdio.h的时候是没有问题的，但是我们加上另一个头文件stdlib.h就会出现报错的现象
  12. //在stdlib这个库里面定义了一个rand 的函数，那么我们现在又在外面定义一个rand的变量，那么就会出现冲突

namespace就是命名空间

那么命名空间是什么样子的呢？

2.namespace的定义

• 定义命名空间，需要使⽤到namespace关键字，后⾯跟命名空间的名字，然后接⼀对{}即可，{}中

即为命名空间的成员。命名空间中可以定义变量/函数/类型等。就不会冲突了

将我们要定义的函数，结构体，全局变量都能放到这个空间中，就不会出现冲突的现象了

  1. #include <stdio.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. namespace bit
  5. {
  6.     // 命名空间中可以定义变量/函数/类型
  7.     int rand = 10;
  8.     int Add(int left, int right)
  9.     {
  10.         return left + right;
  11.     }
  12.     struct Node
  13.     {
  14.         struct Node* next;
  15.         int val;
  16.     };
  17. }
  18. int main()
  19. {
  20.     // 编译报错：error C2365: “rand”: 重定义；以前的定义是“函数”
  21.     printf("%d\n", rand);
  22.     return 0;
  23. }
  24. //我们在命名空间中命名全局变量或者函数的话就不会出现冲突了

• namespace本质是定义出⼀个域，这个域跟全局域各⾃独⽴，不同的域可以定义同名变量，所以下⾯的rand不在冲突了。

我们上面的代码一开始加上stdlib会报错的原因是因为stdlib这个头文件展开会有一个叫rand的函数，那么就会于我们主函数中的变量rand起冲突，这两个rand在同一个域中，一定会有问题的

但是现在我们将rand这个全局变量加在了命名空间中，那么这个rand和stdlib的rand函数就在不同的域中，就不会互相影响了

通过域作用限定符 :: 访问域中的全局变量:

  1. #include <stdio.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. namespace bit
  5. {
  6.     // 命名空间中可以定义变量/函数/类型
  7.     int rand = 10;
  8.     int Add(int left, int right)
  9.     {
  10.         return left + right;
  11.     }
  12.     struct Node
  13.     {
  14.         struct Node* next;
  15.         int val;
  16.     };
  17. }
  18. //int main()
  19. //{
  20. //    printf("%d\n", rand);
  21. //    return 0;
  22. //}
  23. //我们在命名空间中命名全局变量或者函数的话就不会出现冲突了
  24. /*
  25. 但是我们现在打印这个rand显示的是这个rand是函数指针，
  26. 那么就说明这个rand是这个stdlib头文件展开的里面的rand函数
  27.  
  28. 那么我们应该如何将我们命名空间中的rand的值打印出来呢？
  29.  
  30. 如果我们想访问这个命名空间内的rand，那么我们需要指定一个这个空间的域
  31. */
  32. int main()
  33. {
  34.  
  35.     printf("%p\n", rand);//00007FFB89514D50
  36.  
  37.     //::域作用限定符
  38.     printf("%d\n", bit::rand);//10
  39.     //那么这里就说明我们指定要访问bit这个命名空间域里面的rand
  40.  
  41.     bit::Add(1, 2);
  42.  
  43.     struct bit::Node node;   
  44.     //我们在域作用限定符来创建结构体的时候
  45.     //我们需要将这个操作符放到结构体类型的名称的前面
  46.     return 0;
  47. }
  48. /*
  49. 那么第一个打印的就是我们stdlib中展开的函数rand的地址
  50.  
  51. 第二个打印的就是我们bit这个域中的rand的大小
  52. */

::域作用限定符 是两个冒号，通过这个符号我们能访问我们在命名空间中命名的量

我们在域作用限定符来创建结构体的时候

我们需要将这个操作符放到结构体类型的名称的前面

不同的域我们是能定义同名的，但是同一个域是不能定义同名的

• C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/

类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响

编译查找逻辑，还会影响变量的⽣命周期，命名空间域和类域不影响变量⽣命周期。

上面命名空间bit里面的rand是局部的还是全局的呢？

是全局的

因为这个命名空间并不影响这些变量的声明周期

我们只是用这个域进行了一个隔离，那就不怕和库里面冲突了

不同类型的域的访问:

  1. int x = 0;//全局域
  2.  
  3. namespace bit
  4. {
  5.     int x = 1;//命名空间域
  6. }
  7.  
  8. void func()
  9. {
  10.     int x = 2;//局部域
  11. }
  12. int main()
  13. {
  14.     int x = 3;//局部域
  15.     printf("%d\n", x);//这里默认访问的是局部的这个x，因为搜索是先局部再全局搜索，不会到命名空间域和函数域中进行搜索的
  16.  
  17.     printf("%d\n", bit::x);//指定一下命名空间就行了
  18.  
  19.     printf("%d\n", ::x);//这么就是访问全局变量，左边是空的
  20.     return 0;
  21. }
  22. //局部域是会影响生命周期的，出了作用域就会被销毁了
  23.  
  24. //我们是不能访问func这个函数内的局部域的，局部域只能在当前这个域内进行访问的
  25.  
  26. //那么我们可以访问自己局部的，可以访问全局的，可以访问命名空间内的
  27.  
  28. //命名空间主要是与全局进行隔离，因为局部域一开始就是被隔离的

命名空间域：bit::x

全局域：::x

局部域：x

• namespace只能定义在全局，当然他还可以嵌套定义。

命名空间只能定义在全局中，不能定义在局部域之中

命名空间是能进行嵌套的，但是嵌套的主要是什么问题呢？怎么嵌套呢？

我们在一个大的类别的命名域中嵌套放着两个多个命名域

我们在bit这个命名空间里面能嵌套一个航哥的命名空间以及鹏哥的命名空间，各自进行隔离，各玩各的，就不存在冲突的问题了

命名空间的嵌套以及空间内的嵌套的访问

  1. // 命名空间可以嵌套
  2. namespace bit
  3. {
  4.     // 鹏哥
  5.     namespace pg
  6.     {
  7.         int rand = 1;
  8.         int Add(int left, int right)
  9.         {
  10.             return left + right;
  11.         }
  12.     }
  13.     // 杭哥
  14.     namespace hg
  15.     {
  16.         int rand = 2;
  17.         int Add(int left, int right)
  18.         {
  19.             return (left + right) * 10;
  20.         }
  21.     }
  22. }
  23.  
  24. int main()
  25. {
  26.     printf("%d\n", bit::pg::rand);
  27.     printf("%d\n", bit::hg::rand);
  28.     printf("%d\n", bit::pg::Add(1, 2));
  29.     printf("%d\n", bit::hg::Add(1, 2));
  30.     return 0;
  31. }

• 项⽬⼯程中多⽂件中定义的同名namespace会认为是⼀个namespace，不会冲突。

就相当于合并在一起了

• C++标准库都放在⼀个叫std(standard)的命名空间中。

域做到了名字的隔离，同一个域不能定义同一个变量，不同的域可以定义同一个变量

3.命名空间使⽤

编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间⾥⾯去查找。所以下⾯程序会编译报错。所以我们要使⽤命名空间中定义的变量/函数，有三种⽅式：

• 指定命名空间访问，项⽬中推荐这种⽅式。

bit::a

• using将命名空间中某个成员展开，项⽬中经常访问的不存在冲突的成员推荐这种⽅式。

• 展开命名空间中全部成员，项⽬不推荐，冲突⻛险很⼤，⽇常⼩练习程序为了⽅便推荐使⽤。

我们在使用命名空间中的变量或者函数总是要写bit:x

就很复杂，那么我们可以在前面加上using namespace bit

正常的话我们是需要这样写才能访问命名空间内的变量或者函数

我们这个正常的搜索是局部再到全局

加上这个我们就能搜索命名空间内的变量或者函数了

  1. namespace bit
  2. {
  3.     int a = 0;
  4.     int b = 10;
  5. }
  6.  
  7.  
  8. //using namespace bit;//暴露这个命名空间内的所有东西
  9.  
  10. using bit::a;//将指定的变量展露出来，相当于这里将a暴露到全局出来了
  11. int b = 2;
  12.  
  13. int main()
  14. {
  15.     printf("%d\n", a);
  16.     printf("%d\n", a);
  17.     printf("%d\n", a);
  18.     printf("%d\n", a);
  19.     printf("%d\n", a);
  20.     printf("%d\n", a);
  21.  
  22.  
  23.     bit::b++;
  24.     printf("%d\n", bit::b);//11   命名空间里面的
  25.  
  26.     printf("%d\n", b);//2   全局的
  27.  
  28.     return 0;
  29. }
  30. /*
  31. 在这里我们将a暴露出来，b就正常的方法进行使用，b不暴露
  32.  
  33. */

可以选择暴露命名空间内的所有东西，也能暴露某一个东西

4.C++输入&输出

• 是 Input Output Stream 的缩写，是标准的输⼊、输出流库，定义了标准的输⼊、输

出对象。

io流

• std::cin 是 istream 类的对象，它主要⾯向窄字符（narrow characters (of type char)）的标准输

⼊流。

• std::cout 是 ostream 类的对象，它主要⾯向窄字符的标准输出流。

• std::endl 是⼀个函数，流插⼊输出时，相当于插⼊⼀个换⾏字符加刷新缓冲区。

• >是流提取运算符。（C语⾔还⽤这两个运算符做位运算左移/右移）

• 使⽤C++输⼊输出更⽅便，不需要像printf/scanf输⼊输出时那样，需要⼿动指定格式，C++的输⼊输出可以⾃动识别变量类型(本质是通过函数重载实现的，这个以后会讲到)，其实最重要的C++的流能更好的⽀持⾃定义类型对象的输⼊输出。

• IO流涉及类和对象，运算符重载、继承等很多⾯向对象的知识，这些知识我们还没有讲解，所以这

⾥我们只能简单认识⼀下C++ IO流的⽤法，后⾯我们会有专⻔的⼀个章节来细节IO流库。

• cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使⽤⽅式去⽤他们。

基本的使用

  1. using namespace std;//加上这个我们下面就可以不用指定了
  2. //就是下面的输入和输出的话我们是不用在前面加std::的
  3. using std::cout;//仅仅值展开一些
  4. using std::endl;
  5.  
  6. int main()
  7. {
  8.     //  <<这个运算符叫做流插入---输出
  9.     //std::cout << "hello world\n";//可以输出任意类型的变量和对象
  10.     cout << "hello world\n";//可以输出任意类型的变量和对象
  11.     //将这个字符串流向控制台---输出
  12.  
  13.     int i = 10;
  14.     cout << i<<'\n'<<"\n";
  15.     //支持连续的流插入的    换行就这么写
  16.     double d = 1.1;
  17.     cout << d << endl;
  18.     //  std::cout << d << std::endl;
  19.  
  20.     //右边的对象流向左边的控制台对象里面
  21.  
  22.  
  23.     //输入
  24.     //std::cin >> i >> d;//输入i  再接着输入d
  25.     cin >> i >> d;//输入i  再接着输入d
  27.     cout << i << ' ' << d << std::endl;  //输出i  再接着输出d  再输出换行
  28.  
  29.     return 0;
  30. }
  31. /*
  32. 我们这里是不需要像c语言一样要在前面定义%s %d  这些东西
  33. */
  34. /*
  35. 换行的两种方法：在我们输出的后面接着输出换行'\n'或者是"\n"
  36.  
  37. 另一种方法就是在后面输出std::endl
  38. endl就是end line的缩写  结束一行
  39.  
  40. endl这个实际上是一个函数
  41. std::endl这个的兼容性相较于'\n'的话更强一些
  42. 根据平台的不同会进行处理的 
  43. */
  44.  
  45. /*
  46. 输入输出的话我们用c语言的scanf和printf都是可以的
  47. 但是我们要指定类型
  48.  
  49. c++的输入和输出就不用指定类型了
  50.  
  51. C/C++是可以混在一起用的，不会有什么问题的
  52.  
  53. 如果想控制打印出来的小数点的精度的话，建议使用printf
  54. 因为C++的话控制这个精度的话会很麻烦的
  55. */

总结：

std::out<<i<<'\n'

输出i且输出换行

out<<i<<'\n'

输出i且输出换行 前提是前面加上using namespace 或者是using std::cout 将这个展开

cin >> i >> d;

输入i再输入d

前提是前面加上using namespace 或者是using std::cin

将这个展开

cout << i << ' ' << d << std::endl;

输出i和输出d再输出换行

换行就是std::endl

如果前面加上了using namespace 或者是using std::endl

那么我们就这么写：cout << i << ' ' << d << endl;

那么这么写就很方便了

  1. #include<iostream>
  2. using namespace std;
  3. int main()
  4. {
  5. // 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码
  6. // 可以提⾼C++IO效率
  7. ios_base::sync_with_stdio(false);
  8. cin.tie(nullptr);
  9. cout.tie(nullptr);
  10. return 0;
  11. }

对于这些输入输出的话我们不是直接操作台，我们的数据都要经历缓冲区

这样就会使效率降低

那么我们加上这个主函数里面的代码就能提高效率了

将这三串代码放在前面，后面的输出输出的话效率会高一些

在io需求比较高的地方，比如大量输入的竞赛题中，加上这三行代码

就能提高C++ IO效率

• ⼀般⽇常练习中我们可以using namespace std，实际项⽬开发中不建议using namespace std。

一般的练习的话我们是将std进行展开的，项目开发是不建议展开的

避免我们的创建的变量和库中的变量冲突了

• 这⾥我们没有包含，也可以使⽤printf和scanf，在包含间接包含了。vs系列编译器是这样的，其他编译器可能会报错。

学到这里我们来回顾一开始打印hell world的代码，这么我们就很清楚每一步的作用了

5.缺省参数

c语言是没有缺省参数的概念

C++支持缺省参数，有些地方将缺省参数叫做默认参数

• 缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调⽤该函数时，如果没有指定实参则采⽤该形参的缺省值，否则使⽤指定的实参，缺省参数分为全缺省和半缺省参数。（有些地⽅把缺省参数也叫默认参数）

• 全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。

• 带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参。

• 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省值。

缺省参数的简单介绍：

  1. #include <iostream>
  2. #include <assert.h>
  3. using namespace std;
  4. void Func(int a = 0)
  5. {
  6.     cout << a << endl;
  7. }
  8. int main()
  9. {
  10.     Func(); // 没有传参时，使⽤参数的默认值
  11.     Func(10); // 传参时，使⽤指定的实参
  12.     return 0;
  13. }
  14. //如果我们没有传参的话，我们就使用的是这个缺省值
  15. //对于这个函数func的话，我们没有传参的话，那么我们就用函数内的缺省参数作为默认值
  16. //如果传了参的话，我们就用传的参
  17.  
  18. //那么第一个函数打印的就是0
  19. //第二个函数打印的就是10

缺省函数分为全缺省和半缺省

全缺省就是在函数部分我们直接在括号中将所有的变量都进行定定义大小 void Func1(int a = 10, int b = 20, int c = 30)

半缺省的话就是存在没有定义大小的变量 ，就是缺省部分参数

void Func2(int a, int b = 10, int c = 20)

我们是不支持不连续的传参

比如：Func(,2,);

这种写法就是错的

只要缺省一部分那么就是半缺省

我们是不能第一个参数不缺省，第二个参数缺省，第三个参数不缺省

既然缺省了就要连续缺省

缺省函数以及半缺省函数的介绍用法

  1. #include <iostream>
  2. using namespace std;
  3. // 全缺省   缺省全部参数
  4. void Func1(int a = 10, int b = 20, int c = 30)
  5. {
  6.     cout << "a = " << a << endl;
  7.     cout << "b = " << b << endl;
  8.     cout << "c = " << c << endl << endl;
  9. }
  10. // 半缺省  缺省部分参数
  11. void Func2(int a, int b = 10, int c = 20)
  12. {
  13.     cout << "a = " << a << endl;
  14.     cout << "b = " << b << endl;
  15.     cout << "c = " << c << endl << endl;
  16. }
  17. int main()
  18. {
  19.     Func1();//可以一个都不传，全用的就是缺省值
  20.     Func1(1);//仅仅传第一个给a，剩下的b和c用缺省值
  21.     Func1(1, 2);//传a和b，c用缺省值
  22.     Func1(1, 2, 3);//三个都传，那么三个都不用缺省值
  23.     //Func1(,2,);//这样写是错的，因为我们这么写不支持，因为我们传参要连续传参
  24.  
  25.     Func2(100);
  26.     Func2(100, 200);    
  27.     Func2(100, 200, 300);
  28.     return 0;
  29. }
  30. /*
  31. a = 10
  32. b = 20
  33. c = 30
  34.  
  35. a = 1
  36. b = 20
  37. c = 30
  38.  
  39. a = 1
  40. b = 2
  41. c = 30
  42.  
  43. a = 1
  44. b = 2
  45. c = 3
  46.  
  47. a = 100
  48. b = 10
  49. c = 20
  50.  
  51. a = 100
  52. b = 200
  53. c = 20
  54.  
  55. a = 100
  56. b = 200
  57. c = 300
  58.  
  59. */

缺省参数的实际应用，我们在创建栈的时候我们需要手动去调节栈的大小，我们就可以设置缺省值，给这个栈设置一个初始的大小，啥都不用去传

如果我们提前知道要开辟多大的空间我们直接给，避免扩容的时候做出的消耗

如果在函数的声明中给了缺省函数的话我们就没必要再定义中再给缺省函数了

避免给的值不一样，就算一样也会报错的

如果函数没有声明的话我们是可以直接在定义中给上缺省函数的

做人不能做缺省参数，就是备胎舔狗

6.函数重载

C++⽀持在同⼀作⽤域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调⽤就表现出了多态⾏为，使⽤更灵活。C语⾔是不⽀持同⼀作⽤域中出现同名函数的。

同一个作用域中的两个同名参数，总得有点不同

形参不同，参数个数不同，类型不同

函数重载的举例

  1. using namespace std;
  2. //参数类型不同
  3. int Add(int left, int right)//对整数的加法
  4. {
  5.     cout << "int Add(int left, int right)" << endl;
  6.     return left + right;
  7. }
  8. double Add(double left, double right)//对小数的加法
  9. {
  10.     cout << "double Add(double left, double right)" << endl;
  11.     return left + right;
  12. }
  13.  
  14.  
  15. // 2、参数个数不同
  16. void f()
  17. {
  18.     cout << "f()" << endl;
  19. }
  20. void f(int a)
  21. {
  22.     cout << "f(int a)" << endl;
  23. }
  24.  
  25. // 3、参数类型顺序不同
  26. void f(int a, char b)
  27. {
  28.     cout << "f(int a,char b)" << endl;
  29. }
  30. void f(char b, int a)
  31. {
  32.     cout << "f(char b, int a)" << endl;
  33. }
  34.  
  35.  
  36. //语法上下面的两个函数构成重载，但是我们在调用的时候就会有歧义了
  37. //我们不知道调用的是哪个
  38. //语法上是可以存在的，但是在实际运用中是不能存在的
  39. void f1()
  40. {
  41.     cout << "f()" << endl;
  42. }
  43. void f1(int a = 10)
  44. {
  45.     cout << "f(int a)" << endl;
  46. }
  47.  
  48. int main()
  49. {
  50.     //下面的两个函数其实是不同的函数
  51.     //参数的类型不同
  52.     Add(10, 20);
  53.     Add(10.1, 20.2);
  54.  
  55.     //参数个数不同
  56.     f();
  57.     f(10);
  58.  
  59.     //参数顺序不同  本质还是类型不同
  60.     f(10, 'a');
  61.     f('a', 10);
  62.     return 0;
  63. }
  64. /*
  65. 如果是返回值不同那么能不能构成重载呢？
  66. 答案是不能的，因为光凭借这个我们是不能进行判断的
  67.  
  68. 但是我们的参数个数以及参数顺序和参数类型不同都能进行判断函数的不同，那么就能进行重载
  69. */

参数不同、参数的类型不同、参数的个数不同

随便满足一个条件的话都构成函数重载

那么我们在调用的时候就不会担心调用的时候调用错了

7.引用

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

引用就是取别名

引用的基本用法：

  1. using namespace std;
  2.  
  3. void Swap(int& rx, int& ry)//之前我们是没有&这个稍微，那么这里的参数就是a和b的拷贝
  4. //因为是传值所以是不能进行根本性的交换的
  5. //所以我们在进行交换函数的时候我们是要传地址的，使用指针的
  6.  
  7. //那么现在我们在函数的定义中我们直接将a的别名和b的别名定义在里面
  8. //那么因为rx是a的别名，ry是b的别名，那么我们通过这两个别名就能访问他们的地址了
  9. //并且我们在这个主函数里面我们在进行交换函数的时候我们是不需要进行取地址的操作的
  10. //因为我们的函数传的参是a  那么我们为a取别名叫rx  那么rx就是a
  11.  
  12. //那么rx和ry的交换就是a和e的交换
  13.  
  14. //那么就是形参的改变就改变了实参
  15. {
  16.     int tmp = rx;
  17.     rx = ry;
  18.     ry = tmp;
  19. }
  20. int main()
  21. {
  22.     int a = 0;
  23.     //int b = a;//将a赋值给b
  24.  
  25.     int& b = a;//给a的这块空间取别名。叫b
  26.  
  27.     int& c = a;//再给a取别名叫c
  28.  
  29.     int& d = b;//也可以给b取别名
  30.  
  31.     //其实就是这么一块空间有多个名字
  32.  
  33.     cout << &a << endl;
  34.     cout << &b << endl;
  35.     cout << &c << endl;
  36.     cout << &d << endl;
  37.     //这四个变量的地址都是一样的
  38.     b++;
  39.     //那么我们进行b++的话，a c d 的大小都会被改变的
  40.  
  41.  
  42.     //我们还能给指针p1取别名
  43.     int* p1 = &a;
  44.     int*& p2 = p1;
  45.  
  46.     int e = 10;
  47.     p2 = &e;//将p2改变指向从a变成e 
  48.     //因为p1就是p2
  49.     //那么随着p2的改变，那么p1也改变了
  50.     cout << *p1 << endl;
  51.  
  52.  
  53.  
  54.     int x = 0, y = 1;
  55.     cout << x << " " << y << endl;
  56.     Swap(x, y);
  57.     cout << x << " " << y << endl;
  58.     return 0;
  59.  
  60.     return 0;
  61. }
  62.  
  63. //我们这里是给变量取别名
  64. //但是typedef是给类型取别名
  65. //typedef int type  
  66. // 
  67. //define是定义宏
  68.  
  69. //&这个在c语言中是取地址的符号，但是我们在这里是引用的意思
  70. //就是给这个变量起个小名
  71.  
  72. //引用是不能替代指针的

引用等价于指针的利用：

在函数传参的时候我们使用引用我们既不用传地址了

  1. typedef struct ListNode
  2. {
  3.     int val;
  4.     struct ListNode* next;
  5. }LTNode, * PNode;
  6. // 指针变量也可以取别名，这⾥LTNode*& phead就是给指针变量取别名
  7. // 这样就不需要⽤⼆级指针了，相对⽽⾔简化了程序
  8. //void ListPushBack(LTNode** phead, int x)
  9. //void ListPushBack(LTNode*& phead, int x)
  10. void ListPushBack(PNode& phead, int x)
  11. {
  12.     PNode newnode = (PNode)malloc(sizeof(LTNode));
  13.     newnode->val = x;
  14.     newnode->next = NULL;
  15.     if (phead == NULL)
  16.     {
  17.         phead = newnode;
  18.     }
  19.     else
  20.     {
  21.         //...
  22.     }
  23. }
  24.  
  25.  
  26. int main()
  27. {
  28.     PNode plist = NULL;
  29.     ListPushBack(plist, 1);   //那么我们传上去的plist的别名就是phead
  30.     return 0;
  31. }
  32. //将plist引用一个新的名字

引用就是给我们的变量换个名字

这些名字都指向了这个变量，地址都是相同的

引用就是取别名

我叫XX凯

朋友叫我凯子

这两个名字都指向的是我本人

这就是引用

一个变量是可以有多个名字的

引用的特点就是在新名字前面加上&这个符号

类型&引用别名=引用对象

在定义变量，在类型后面加&这个就是引用，其他的位置都是取地址的意思

我们给一个变量取了别名，我们还能给别名取别名，最后这些名字都指向最开始的变量

引用的特性

• 引⽤在定义时必须初始化

int&c;

这种写法就是错的，没有进行初始化

• ⼀个变量可以有多个引⽤

一个变量可以起很多个别名

• 引⽤⼀旦引⽤⼀个实体，再不能引⽤其他实体

就是我现在是你的别名，那么我就不能变成别人的别名了

引用的特性以及为什么引用不能替代指针：

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include<iostream>
  3. using namespace std;
  4. int main()
  5. {
  6.     int a=10;
  7.     int &b=a;
  8.     int &d=b;
  9.  
  10.     cout<<&a<<endl;
  11.     cout<<&b<<endl;
  12.     cout<<&d<<endl;
  13.  
  14.     int e=20;
  15.     //这里并非让b引用c，因为c++引用不能改变指向
  16.     //那么这里就是赋值
  17.     //相当与对a b c d这四个变量进行赋值为e的大小
  18.     //因为前面四个变量都指向a这块空间
  19.     //现在我们重新赋值为20
  20.     //那么下面的输出就是20
  21.     d=e;
  22.     cout<<&a<<endl;
  23.     cout<<&b<<endl;
  24.     cout<<&d<<endl;
  25.     cout<<&e<<endl;
  26.     return 0;
  27. }
  28. /*
  29. C++的引用是不能替代指针的
  30. 我们拿链表来举例子的话
  31. 链表的节点在物理上并非总是连续的
  32. 我们是一个节点存储着下个节点的指针的
  33. 如果我们将2这个节点删除的话
  34. 那么我们要将1的next指针的指向指向3这个节点
  35. 那么通过指针的改变就能实现
  36. 但是我们的引用是不能改变指向的
  37. 这就是为什么C++的引用不能去替代指针
  38.  
  39. */

引用的使用

• 引⽤在实践中主要是于引⽤传参和引⽤做返回值中减少拷⻉提⾼效率和改变引⽤对象时同时改变被引⽤对象。

b是a的别名，b没有额外的开辟空间

通过应用的方式减少额外的拷贝：

  1. void Swap(int& rx, int& ry)//形参是实参的别名
  2. //那么rx和ry的交换就是x和y的交换
  3. // 改变引用对象的同时能改变被引用对象
  4. //这里的话指针也是可以实现的，但是指针的话相较于引用更加麻烦
  5. {
  6.     int tmp = rx;
  7.     rx = ry;
  8.     ry = tmp;
  9. }
  10.  
  11. struct A
  12. {
  13.     int arr[1000];
  14. };
  15.  
  16.  
  17. void func(A& aa)
  18. {
  19.  
  20. }
  21.  
  22.  
  23. int main()
  24. {
  25.     int x = 0, y = 1;
  26.     cout << x << " " << y << endl;
  27.     Swap(x, y);
  28.     cout << x << " " << y << endl;
  29.  
  30.  
  31.     A aa1;
  32.     func(aa1);//传指针的话我们就直接传过去指针的4个字节
  33.     //如果将这个结构体传过去的话，那么就是4000个字节，我们需要额外进行拷贝的操作
  34.  
  35.     //我们在这里使用引用的话，其实更方便些，同样和指针一样不需要进行额外的拷贝的操作
  36.     return 0;
  37. }

传值返回也会生成拷贝的

传值返回就是返回的就是拷贝的

传引用返回，返回的就是它的别名

引用做返回值可以减少拷贝做临时对象那一步，

引用减少了返回值的拷贝的步骤：

  1. //传值返回
  2. int STTop(ST& rs)
  3. {
  4.     assert(rs.top > 0);
  5.     return rs.a[rs.top];
  6. }
  7. //STTop(st1)++    这个是会报错的
  8. //因为我们在传值返回的时候我们是临时创建了一块空间
  9. //将值传过去，接收完之后这块空间就销毁了
  10. //那么我们这里就无法进行这个返回值加加的操作了
  11. //这个加加操作的话我们加到了临时变量上面去了
  12. //传引用返回
  13. int& STTop(ST& rs)
  14. {
  15.     assert(rs.top > 0);
  16.     return rs.a[rs.top];
  17. }
  18. STTop(st1)++;
  19. //我们的返回值的别名
  20. //就是返回我们要返回值的别名
  21. //这样我们就能进行加加操作了
  22.  
  23. //这里我们的返回是返回值的引用
  24. //那么我们这里返回的话就直接跨过了创建临时变量的那一步了

简单点来说就是正常的传值返回的话，我们在返回的时候生成了一个中间变量，通过这个变量我们实现了值的返回

但是我们在使用引用返回的话，我们就不需要这个额外的步骤了

我们直接将返回值的引用值返回了

C++设计引用不是替代指针的，是用来简化指针的问题

不是所有的返回都能用引用返回的

  1. //不是所有的情况都能用引用反回的
  2. int* func()
  3. {
  4.     int ret = 10;
  5.     ret++;
  6.  
  7.     //......
  8.     return &ret;//这里我们如果返回的是ret的地址的话，是会报错的，因为ret是个局部变量
  9.     //出了函数就会被销毁的，那么返回ret的地址就是返回了一个野指针了
  10. }
  11.  
  12. int& func1()
  13. {
  14.     int ret = 10;
  15.     ret++;
  16.  
  17.     //......
  18.     return ret;
  19. }
  20. //如果用的是引用返回呢？
  21. //一样是不行的
  22. //因为我们的ret已经别销毁了

为什么在上面的栈写的代码我们可以返回呢

因为我们的数据是在堆上面动态开辟的

我们返回的时候是一直存在的

直到这个我们主动进行free的，否则是一直存在的

那么我们就能进行返回了

那么在这个代码中就不一样，一出函数就被销毁了，指向那块空间的指针就成了野指针了

所以我们在使用引用返回的时候我们是要判断这块空间是否出函数存在

越界是不存在报错的

• 引⽤传参跟指针传参功能是类似的，引⽤传参相对更⽅便⼀些。

• 引⽤返回值的场景相对⽐较复杂，我们在这⾥简单讲了⼀下场景，还有⼀些内容后续类和对象章节中会继续深⼊讲解。

• 引⽤和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引⽤跟其他语⾔的引⽤(如Java)是有很⼤的区别的，除了⽤法，最⼤的点，C++引⽤定义后不能改变指向，Java的引⽤可以改变指向。

• ⼀些主要⽤C代码实现版本数据结构教材中，使⽤C++引⽤替代指针传参，⽬的是简化程序，避开复杂的指针，但是很多同学没学过引⽤，导致⼀头雾⽔。

关于越界访问：

  1. int main()
  2. {
  3.  
  4.  
  5.     int a[10] = {0};
  6.     //越界是不一定报错的
  7.     //越界读的话不报错   读就是打印里面的值
  8.     cout << a[10] << endl;
  9.     cout << a[11] << endl;
  10.     cout << a[12] << endl;
  11.  
  12.     //越界写不一定报错    写就是进行赋值
  13.     a[10] = 1;
  14.     a[12] = 1;
  15.     return 0;
  16. }
  17. //编译器系统对越界行为是一种抽查行为
  18. //不一定会报错的

8.const引用

const引用

• 可以引⽤⼀个const对象，但是必须⽤const引⽤。const引⽤也可以引⽤普通对象，因为对象的访问权限在引⽤过程中可以缩⼩，但是不能放⼤。

权限的放大和缩小：

  1. int main()
  2. {
  3.     const int a = 10;
  4.     //a不能进行修改,所以不能取别名，取别名的话是会对a造成修改的风险的
  5.  
  6.     //在引用的过程中权限不能放大
  7.     //int& ra = a;
  8.  
  9.     //下面我们引用一个const对象，但是必须用const引用
  10.     //那么这里的ra就是const对象
  11.     const int& ra = a;    
  12.  
  13.     //cnost引用普通的对象
  14.     //权限可以缩小
  15.     int b = 1;
  16.     const int& rb = b;
  17.     //rb不能进行修改,b能被修改
  18.     //rb++;
  19.     b++;
  20.  
  21.     //不是权限的放大
  22.     //x不能修改，但是我们在下面将x拷贝成y
  23.     //我们修改y的话是对x没有影响的
  24.     const int x = 0;
  25.     int y = x;//这里是拷贝赋值
  26.  
  27.  
  28.     return 0;
  29. }
  30.  
  31. /*
  32. 我们对a进行const的话，那么a的别名就不能进行别名的定义了
  33. 因为别名会影响到a，这种属于权限放大了，我们只能进行权限缩小，不能放大
  34.  
  35. 但是我们创建了个变量b的话，我们是能对b进行修改的
  36. 但是如果b的别名加上const的话就不能进行修改了
  37.  
  38. 如果我们一开始就将x进行const定义了
  39. 那么我们是能将x赋值给y的
  40. 这种属于拷贝
  41. 不会对x造成影响的
  42. */

指针上的权限问题：

  1. int main()
  2. {
  3.     const int a = 10;//a是不能进行修改的
  4.     const int* p1 = &a;
  5.     //p1是不能给p2的，这种属于权限的放大
  6.     //int* p2 = p1;
  7.  
  8.     /*
  9.     我们的p2一开始就被固定指向为a
  10.     那么我们就不能修改指向了
  11.     因为我们前面的加了const
  12.  
  13.     const在*右边就说明我们已经将这个变量进行限制了
  14.     不能将指向改变了
  15.  
  16.     在左边的话就说您我们不能通过指针对指向的数据进行修改的操作
  17.     */
  19.     int b = 20;
  20.     int* p3 = &b;//p3存的是b的地址
  21.     const int* p4=p3;//p4也是b的地址，但是我们只能进行读取，不能进行修改的
  22.  
  23.  
  24.     //下面的const在*右边 就说明我们是不能进行指针指向的修改的
  25.     int* const p4 = &b;
  26.     int* p5 = p4;
  27.  
  28.  
  29.     return 0;
  30.  
  31. }
  32. /*
  33. 不想让const修改p就把p放在*右边-- *const p--一直指向一个数
  34. 不想让你通过p修改p的指向的内容就把const放在左边，将*p固定住-conat *p
  35.  
  36. *p被const固定住，*p指向内容的大小不得改变
  37. */

不想让const修改p就把p放在*右边-- *const p--一直指向一个数 不想让你通过p修改p的指向的内容就把const放在左边，将*p固定住-conat *p

p被const固定住，p指向内容的大小不得改变

• 需要注意的是类似 int& rb = a3; double d = 12.34; int& rd = d; 这样⼀些场景下a3的和结果保存在⼀个临时对象中， int& rd = d 也是类似，在类型转换中会产⽣临时对象存储中间值，也就是时，rb和rd引⽤的都是临时对象，⽽C++规定临时对象具有常性，所以这⾥就触发了权限放⼤，必须要⽤常引⽤才可以。

• 所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象，C++中把这个未命名对象叫做临时对象。

const引用能引用以下对象：

1.普通对象

2.临时对象

3.const对象

不用的引用对象的使用：

  1. void f1(const int& rx)//我们在引用接受对象的同时，为了不能通过这个形参改变实参，我们可以在2前面加上const
  2. {
  3.  
  4. }
  5.  
  6. int main()
  7. {
  8.     const int xx = 20;
  9.     int a = 10;
  10.     //本质而言这里是一个权限放大
  11.     //int& rb = a * 3;//引用的是这个表达式的整体  ,表达式的结果会用一个临时对象进行存储的
  12.     const int& rb = a * 3;//加上const就行了
  13.     //上面的rb引用的是个临时对象  a*3的结果存储在临时变量里面
  14.     //因为C++规定临时对象具有常性，那么这里就触发了权限放大，必须要用常引用才行
  15.     //那么前面加上const就行了
  16.  
  17.     double d = 12.34;
  18.     int rd = d;
  19.     //我们是不能用int类型的数据引用其他类型的数据的
  20.     //int &rd = d;
  21.     //这里因为类型不同，那么类型转换的同时中间会生成临时变量，那么我们就需要const进行修饰
  22.  
  23.     //这里的临时对象具有常性，和常量一样，就像是已经被const修饰一样
  24.     //那么我们的左边同样也要进行const修饰的操作，本质是触发了权限的放大
  25.     const int& rd = d;//前面加上const就行了
  26.  
  27.     f1(xx);//可以传const对象
  28.     f1(a);//可以传普通值
  29.     f1(a * 3);//可以传表达式
  30.     f1(d);//可以传带有类型转换的
  31.     //如果用const引用传参的话是会很宽泛的
  32.     return 0;
  33. }
  34.  
  35. //临时对象是具有常量性值，就相当与已经被const修饰了。不能被修改
  36.  
  37. //const引用能引用普通对象，引用临时对象，引用const对象

引用和指针的关系

C++中指针和引⽤就像两个性格迥异的亲兄弟，指针是哥哥，引⽤是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有⾃⼰的特点，互相不可替代。

• 语法概念上引⽤是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间。

• 引⽤在定义时必须初始化，指针建议初始化，但是语法上不是必须的。

• 引⽤在初始化时引⽤⼀个对象后，就不能再引⽤其他对象；⽽指针可以在不断地改变指向对象。

• 引⽤可以直接访问指向对象，指针需要解引⽤才是访问指向对象。

• sizeof中含义不同，引⽤结果为引⽤类型的⼤⼩，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)

• 指针很容易出现空指针和野指针的问题，引⽤很少出现，引⽤使⽤起来相对更安全⼀些。

9.inline

• ⽤inline修饰的函数叫做内联函数，编译时C++编译器会在调⽤的地⽅展开内联函数，这样调⽤内联函数就不需要建⽴栈帧了，就可以提⾼效率。

宏定义的缺点：

为什么会有这个inline这个东西？

  1. // 实现⼀个ADD宏函数的常⻅问题
  2. //#define ADD(int a, int b) return a + b;
  3. //#define ADD(a, b) a + b;
  4. //#define ADD(a, b) (a + b)
  5. // 正确的宏实现
  6. #define ADD(a, b) ((a) + (b))
  7. // 为什么不能加分号?宏是替换机制的  ，在宏定义后面加分号的话就有问题了
  8. // 为什么要加外⾯的括号?   不加外面的括号这个优先级就有问题了
  9. // 为什么要加⾥⾯的括号?   同样是为了保持优先级
  10.  
  11. int main()
  12. {
  13.     int ret = ADD(1, 2);//宏是替换机制的
  14.     cout << ret << endl;
  15.     ;
  16.     cout << ADD(1, 2) << endl;     //第一个问题
  17.     cout << ADD(1, 2) * 5 << endl;    //第二个问题
  18.     int x = 1, y = 2;
  19.     ADD(x & y, x | y); // -> (x&y+x|y)  第三个问题
  20.  
  21.     return 0;
  22. }
  23. /*
  24. 宏函数缺点很多，但是替换机制，调用时不用简历栈帧，提效，开销小
  25. */
  26.  
  27. //那么我们的祖师爷忍不了一点儿，就创建了这个inline

• inline对于编译器⽽⾔只是⼀个建议，也就是说，你加了inline编译器也可以选择在调⽤的地⽅不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适⽤于频繁调⽤的短⼩函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。

debug是默认不展开的

release是展开的

大家如果想要展开的话跟随下面的操作图进行操作

可以使debug能展开

1.右击项目点击属性

2.改成下图的样子就行了

3.调整完这个点击应用再确定

展开了就没有栈帧的消耗，不展开就有

如果函数较长的话，就不展开了

inline是一个对于编译器建议，编译器啊才有最终决策权

这个就是编译器的防御策略，怕不靠谱的程序员

• C语⾔实现宏函数也会在预处理时替换展开，但是宏函数实现很复杂很容易出错的，且不⽅便调试，C++设计了inline⽬的就是替代C的宏函数。

• vs编译器 debug版本下⾯默认是不展开inline的，这样⽅便调试debug版本想展开需要设置⼀下以下两个地⽅。

• inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错。

内联函数不能分离到两个文件，因为内联函数是没有地址的

10.nullptr

NULL实际是⼀个宏，在传统的C头⽂件(stddef.h)中，可以看到如下代码

  1. #ifndef NULL
  2.     #ifdef __cplusplus
  3.         #define NULL 0
  4.     #else
  5.         #define NULL ((void *)0)
  6.     #endif
  7. #endif

• C++中NULL可能被定义为字⾯常量0，或者C中被定义为⽆类型指针(void)的常量。不论采取何种定义，在使⽤空值的指针时，都不可避免的会遇到⼀些⿇烦，本想通过f(NULL)调⽤指针版本的f(int)函数，但是由于NULL被定义成0，调⽤了f(int x)，因此与程序的初衷相悖。f((void*)NULL);调⽤会报错。

• C++11中引⼊nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字⾯量，它可以转换成任意其他类型的指针类型。使⽤nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，⽽不能被转换为整数类型。

在c++中使用nullptr来定义空指针可以避免类型转换的问题

用nullptr来定义空指针：

  1. //下面两个函数构成函数重载
  2. void f(int x)
  3. {
  4.     cout << "f(int x)" << endl;
  5. }
  6. void f(int* ptr)
  7. {
  8.     cout << "f(int* ptr)" << endl;
  9. }
  10. int main()
  11. {
  12.  
  13.     //f(0);//调用第一个
  14.     //f(NULL);//调用第二个
  15.     f(nullptr);//在c++中使用nullptr来定义空指针可以避免类型转换的问题
  16.  
  17.     return 0;
  18.  
  19. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小舞很执着/article/detail/994464
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号