C++入门基础(超详细) 需：C语言基础

1.C++的发展史 大致了解一下

C++的起源可以追溯到1979年，当时BjarneStroustrup(本贾尼·斯特劳斯特卢普，这个翻译的名字不 同的地方可能有差异)在贝尔实验室从事计算机科学和软件工程的研究工作。面对项目中复杂的软件开 发任务，特别是模拟和操作系统的开发⼯作，他感受到了现有语言（如C语言）在表达能力、可维护性和可扩展性方面的不足。

1983年，BjarneStroustrup在C语言的基础上添加了面向对象编程的特性，设计出了C++语言的雏形， 此时的C++已经有了类、封装、继承等核心概念，为后来的面向对象编程奠定了基础。这⼀年该语言被正式命名为C++。

在随后的几年中，C++在学术界和工业界的应用逐渐增多。⼀些大学和研究所开始将C++作为教学和研 究的首选语言，而⼀些公司也开始在产品开发中尝试使用C++。这⼀时期，C++的标准库和模板等特性 也得到了进⼀步的完善和发展。

C++的标准化⼯作于1989年开始，并成立了⼀个ANSI和ISO（InternationalStandards Organization）国际标准化组织的联合标准化委员会。1994年标准化委员会提出了第⼀个标准化草案。在该草案中，委员会在保持斯特劳斯特卢普最初定义的所有特征的同时，还增加了部分新特征。 在完成C++标准化的第⼀个草案后不久，STL（StandardTemplateLibrary）是惠普实验室开发的⼀系 列软件的统称。它是由AlexanderStepanov、MengLee和DavidRMusser在惠普实验室⼯作时所开发 出来的。在通过了标准化第⼀个草案之后，联合标准化委员会投票并通过了将STL包含到C++标准中的 提议。STL对C++的扩展超出C++的最初定义范围。虽然在标准中增加STL是个很重要的决定，但也因 此延缓了C++标准化的进程。

1997年11⽉14日，联合标准化委员会通过了该标准的最终草案。1998年，C++的ANSI/IS0标准被投入使用。

1.1C++版本更新

  1. C++的第一个版本是1998年，绝大编译器都支持；
  2. 如果是一些大公司的项目成熟，现在可能依然还是在用C++11，甚至C++98更老的版本；语法方面用的比较老
  3. 为什么不用新的版本，用新版本 有些地方会更新，可能导致不兼容，更改起来成本大

1.2. 关于C++23的⼀个小故事

  1. C++⼀直被诟病的⼀个地方就是⼀直没出网络库(networking)，networking之前是在C++23的计划中的，现在C++23已经发布了，但是没有networking，网上引发了⼀系列的吃瓜和吐槽。
    1. 原本计划的是一个大版本，最后变成了一次小版本更新
  2. 从C++98开始，原本计划5年更新一次C++的版本，但是一直到C++11才更新，也就说远远不止5年一更；为啥呢？ 因为在这个过程中 烂尾了，中间出现一些问题导致迟迟没有更新
  1. 不过到C++ 11版本后，就是3年一更了，可能是吃了不少教训；

C++23的目标 - 知乎 (zhihu.com)icon-default.png?t=N7T8https://zhuanlan.zhihu.com/p/107360459

2. C++参考文档

  1. 这里有常用的几个C++ 文档，字典
    1. https://legacy.cplusplus.com/reference/
    2. https://zh.cppreference.com/w/cpp
    3. https://en.cppreference.com/w/
  2. 我最常用的就是第一个，但是只更新到了C++11版本，而且不是官网；
  3. 第二个才是官网，当然可能很多小伙伴和我一样英语不太好，所以第三个是中文版的官方网站； 当然最好是一起结合使用，会读英语文档更好

3. C++的重要性

3.1编程语言排行榜

  1. TIOBE排行榜是根据互联网上有经验的程序员、课程和第三方厂商的数量，并使用搜索引擎（如 Google、Bing、Yahoo!）以及Wikipedia、Amazon、YouTube和Baidu（百度）统计出排名数据，只是反映某个编程语言的热门程度，并不能说明一门编程语言好不好，或者一门语言所编写的代码数量多少

2024年6月TIOBE发布的编程语言排行榜 对应的网站TIOBE Index - TIOBE

3.2. C++在工作领域中的应用

C++的应用领域服务器端、游戏（引擎）、机器学习引擎、音视频处理、嵌入式软件、电信设备、金融应用、基础库、操作系统、编译器、基础架构、基础工具、硬件交互等很多方面都有

C++使用度高，也是离不开在各个领域都有使用的，个人觉得得益于C++高效的性能

  1. 大型系统软件开发。如编译器、数据库、操作系统、浏览器等等
  2. 音视频处理。常见的音视频开源库和方案有FFmpeg、WebRTC、Mediasoup、ijkplayer，音视频开发最主要的技术栈就是C++。
  3. PC客⼾端开发。⼀般是开发Windows上的桌面软件，比如WPS之类的，技术栈的话⼀般是C++和QT，QT是⼀个跨平台的C++图形用⼾界面（GraphicalUserInterface，GUI）程序。
  4. 服务端开发。各种⼤型应用⽹络连接的高并发后台服务。这块Java也比较多，C++主要用于⼀些对性能要求比较高的地方。如：游戏服务、流媒体服务、量化高频交易服务等
  5. 游戏引擎开发。很多游戏引擎就都是使用C++开发的，游戏开发要掌握C++基础和数据结构，学习图形学知识，掌握游戏引擎和框架，了解引擎实现，引擎源代码可以学习UE4、Cocos2d-x等开源引擎实现
  6. 嵌入式开发。嵌入式把具有计算能⼒的主控板嵌入到机器装置或者电⼦装置的内部，通过软件能够控制这些装置。比如：智能手环、摄像头、扫地机器⼈、智能音响、门禁系统、⻋载系统等等，粗略⼀点，嵌入式开发主要分为嵌入式应用和嵌入式驱动开发。
  7. 测试开发/测试。每个公司研发团队，有研发就有测试，测试主要分为测试开发和功能测试，测试开发⼀般是使用⼀些测试⼯具(selenium、Jmeter等)，设计测试用例，然后写⼀些脚本进行⾃动化测试，性能测试等，有些还需要⾃行开发⼀些测试用具。功能测试主要是根据产品的功能，设计测试用例，然后⼿动的方式进行测试。

4. C++学习建议和书籍推荐

  1. C++，算是比较难学的语言，所以要做好准备迎接困难，但是有心人无所畏惧
  2. 书籍推荐
    1. C++Primer：主要讲解语法，经典的语法书籍，前后中期都可以看，前期如果⾃学看可能会有点晦涩难懂，能看懂多少看懂多少，就当预习，中后期作为语法字典，非常好用。
    2. STL源码剖析：主要从底层实现的⻆度结合STL源码，庖丁解⽜式剖析STL的实现，是侯捷⽼师的经典之作。可以很好的帮助我们学习别⼈用语法是如何实现出高效简洁的数据结构和算法代码，如何使用泛型封装等。让我们不再坐井观天，闭门造车，本书课程上⼀半以后，中后期可以看。
    3. Effctive C++：本书也是侯捷⽼师翻译的，本书有的⼀句评价，把C++程序员分为看过此书的和没看过 此书的。本书主要讲了55个如何正确高效使用C++的条款，建议中后期可以看⼀遍，⼯作1-2年后再看 ⼀遍，相信会有不⼀样的收获。

5. C++的一个程序

  1. C++是兼容C语言的，vs编译器看到是.cpp就会调⽤C++编译器编译，linux下要用g++编译，不再是gcc
  2. 所以下列代码可以运行
#include <stdio.h>
int main() //这个也是可以跑起来的，C++ 兼容C
{printf("hello world");return 0;
}
  1. C++ 是有自己的标准输入输出流的，这里可能不太理解cout 和 endl ，一步一步来后面会解释的
  2. #include <iostream> //标准输入输出流 这个是C++的标准输入输出的头文件
#include <iostream> //标准输入输出流
using namespace std; // 展开C++ 自带std域
int main()
{int a = 10;int b = 1;b << 1;//在这里是左移操作符，相当于一个符号多用了cout << "hello world" << endl;//C++在这个 << 这个符号叫流输出操作符//endl 可以暂时理解为换行，因为内层挺复杂的，这里只做了解return 0;
}

6. 命名空间

6.1. namespace的价值

  1. 如果在使用rand变量名的时候，没有#include <stdlib.h> 这个头文件，程序时是可以正常运行的
  2. 这里rand是一个生成随机数的函数
//#include <stdlib.h>
int rand = 10;
int main()
{ printf("%d", rand);//错误	C2365	“rand”: 重定义；以前的定义是“函数”		return 0;
}
  1. 如果此时加上头文件，会导致 命名冲突
  2. C++中为了解决这种问题，引入了 namespace 关键字

6.2. namespace的定义

  1. 定义namespace 命名空间时， 后面跟命名空间的名字 然后加上括号" { } "即可; { }中是命名成员，命名成员的类型可以是定义变量、函数、结构体、类型等等
  2. 本质上是定义一个 域 ，不用 域 里面的名字可以相同，这样就不冲突了，此时会打印这个函数的地址
#include <stdlib.h>
namespace fight
{int rand = 10;
}
int main()
{ printf("%d\n", rand);printf("%p\n", rand);return 0;
}
  1. 在不同的域中出现变量a，那么怎么调用到全部的变量呢？: : 域作用限定符
  2. 这个 : : 符号的左边不写，只写符号右边a，默认访问全局的a
  3. 在 : : 符号左边加上fight，可以访问到fight域里的a
    1. 注意：fight域内的成员是全局的 ，只不过通过 namespace 手段，把它们隔离了起来，防止命名冲突
#include <stdlib.h>
namespace fight
{int rand = 10;int a = 100;
}
int a = 30;
int main()
{ int a = 5;printf("%d\n", a);// ::域作用限定符  ::a 默认全局域查找printf("%d\n", ::a);// 访问 fight域的aprintf("%d\n", fight::a);return 0;
}

  1. C++中域有函数局部域、全局域、命名空间域、类域；域影响的是编译时语法查找⼀个变量、函数、类型出处(声明或定义)的逻辑 ，意思就是在运行这个函数时需要先找到该声明，有了域 就可以隔离起来从而解决命名冲突
  2. 局部域和全局域会影响查找逻辑（默认情况下查找变量时会先找局部的）如果没找到就会去域里面找，找不到就会报错，还会影响声明周期，但是不会影响命名空间域和类域变量声明周期
  3. namespace只能定义在全局，当然他还可以嵌套定义；如何解决呢？

通过命名空间域，嵌套解决；你们项目组，其他项目组就不会冲突

namespace jwj
{namespace fight{int rand = 10;int a = 100;int add(int x, int y){return x + y;}struct fg{int n;int size;int* arr;};}namespace gan{int rand = 10;int a = 1145;int add(int x, int y){return x + y;}struct fg{int n;int size;int* arr;};}
}
int main()
{printf("%d\n", jwj::fight::a);printf("%d\n", jwj::gan::a);return 0;
}
  1. 不同文件，命名空间声明可以相同; 相同名字，会认为是一个namespace, 自己会合并；

直接通过不同的命名空间区分里面相同名字的函数，直接就解决问题了

//Stack.cpp 文件的
namespace jwj
{int Sub(int x, int y){return x * y;}
}
//tset.cpp
namespace jwj
{namespace fight{int rand = 10;int a = 100;int add(int x, int y){return x + y;}struct fg{int n;int size;int* arr;};}namespace gan{int rand = 10;int a = 1145;int add(int x, int y){return x + y;}struct fg{int n;int size;int* arr;};}
}
int main()
{printf("%d\n", jwj::fight::a);printf("%d\n", jwj::gan::a);//这个Sub函数是在Stack.cpp文件中的函数cout << jwj::Sub(5,5) << endl;return 0;
}
  1. C++标准库都放在一个叫std(standard)的命名空间中。怕和其他名字冲突，所以标准库也做了封装

6.3. 命名空间使用

  1. 编译器在查找变量声明/定义，默认查找全局和局部的，不会去命名空间查找，从而导致报错；所以此时就有了一下三种方式：
    1. 指定命名空间访问
    2. 使用using来展开命名空间的某个成员，对经常使用的成员，当然要确保变量名不冲突
    3. 使用using展开命名空间中的全部成员，小项目练习可以用。在实际项目中不推荐，风险太大
  2. 展开头文件和命名空间的区别
    1. 展开头文件是拷贝一份，而命名空间是把这堵墙拆开（把限制解除了），在这个位置展开
int main()
{using namespace jwj::fight;//展开jwj命名空间里的fight命名空间；也就是展开里面的命名空间printf("%d\n", a);printf("%d\n", a);printf("%d\n", a);using abx::x;//部分展开指的是展开变量、函数、结构体；using abx::add;return 0;
}

7. 输入输出流

  1. <iostream>, 是InputOutputStream的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象
  2. std::cout 标准输出流(写入)，窄字符的便准输出流；输出到控制台(console)
  3. std::endl 流插入输出时，相当于插入⼀个换行字符 + 刷新缓冲区；这里也涉及到了运算符重载的
  4. std::cin 是istream类的对象,窄字符标准输入流(读取)
  5. <<是流插入运算符，>>是流提取运算符；这是一个 二元操作符，两边都只能有一个操作数 （在c语言中的意思是 << 左移操作符 和 右移操作符 >>）
  6. 使用C++的输入输出更方便，因为可以自动识别变量类型(本质是通过函数重载实现) C++更好的支持输入输出自定义类型的对象(类)
    1. IO流涉及类和对象、运算符重载、继承等等；会使用IO流的基本用法就行，后面再深入了解
  1. cout/cin/endl等都属于C++标准库，都放在一个叫std(standard)的命名空间中，所以要通过命名空间的使用方式 ；std::cerr 输出错误 std::clog 输出日志
  2. 是日常练习当中，使用using namespace std展开，实际项目中不建议
  3. 还有一种情况，代码并没有包含<stdio.h>的头文件，但是依然可以用printf和scanf，可能<iostream>间接包含了。但是再gcc环境下要包含<stdio.h>的头文件
#include <iostream> //标准输入输出流
int main()
{using namespace std;//展开 std命名空间 using std::cin;// 展开命名空间里的函数int a = 20;char b = 'b';int c = 40;char arr[10] = "abced";scanf("%d", &c);//iostream 里面间接包含了，所以可以使用printf("%d ", c);cout << a << endl;// cout 窄字符输出流，输出到控制台 a是一个变量，这个会自动转换成字符类型//endl 现阶段可以理解为换行符 + 刷新缓冲区cin >> a >> c >> b >> arr;cout << a << ' ' << c << ' ' << b  << ' ' << arr << endl;//流提取操作符return 0;
}

在竞赛时，如果跑不通过，可以加上这三行代码，提高IO效率，减少一些不必要的系统调用

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

8. 缺省参数

  1. 缺省参数时声明或定义函数的参数指定一个缺省值。调用函数时如果没有实参，就会使用缺省值，相反就使用实参，还有全缺省和半缺省；当然也有叫默认参数的
  2. 全缺省就是全部实参都给缺省值，半缺省就是部分给缺省值，而半缺省值有规定，必须从右向左连续给缺省值，不能跳着给缺省值
  3. 带缺省值的函数调用，C++规定必须从左到右依次给实参，也不可以跳跃给实参
  4. 函数的声明和定义分离时，缺省参数不能同时出现（看下列图），规定必须在函数声明给缺省值

#include <iostream>
using namespace std;
void print(int a = 0)
{cout << a << endl;
}
int main()
{print();print(10);return 0;
}
  1. 全缺省和半缺省
#include <iostream>
using namespace std;
void print1(int a = 1,int b = 2,int c = 3)
{cout << a << " " << b << " " << c << " " << endl;
}
void print2(int a, int b = 2, int c = 3)
{cout << a << " " << b << " " << c << " " << endl;
}
int main()
{//全缺省print1();print1(10);print1(10,20);print1(10,20,30);cout << endl;//半缺省print2(11);print2(11,22);return 0;
}
  1. 错误示范，调用带有缺省参数的函数，不能跳着给参数，也不可以跳着给缺省值

9. 函数重载

  1. C++支持同一个作用域中出现同名函数，但是要求同名函数的实参类型不同，或者时参数的个数不同；这样C++函数调用表现出了多态行为，使用更加灵活，C语言是不支持同名函数的
  2. 假设使用一个相加函数，函数重载就可以很好的解决问题
#include <iostream>
using namespace std;
//类型不同
int add(int pa, int pb)
{cout << "add(int pa,int pb)" << endl;return pa + pb;
}
double add(double pa, double pb)
{cout << "add(double pa,double pb)" << endl;return pa + pb;
}
//交换函数
void Swap(int* x, int* y)
{int tmp = *x;*x = *y;*y = tmp;
}
void Swap(char* x, char* y)
{char tmp = *x;*x = *y;*y = tmp;
}
int main()
{add(10, 20);add(10.1, 20.2);char a = 'h';char b = 'g';int al = 10, bl = 20;Swap(&a, &b);Swap(&al, &bl);cout << "a = " << a << '\n' << "b = " << b << endl;cout << "al = " << al << '\n' << "bl = " << bl << endl;return 0;
}

是不是突然绝对C++，很方便

参数个数不同

#include <iostream>
using namespace std;
// 个数不同
void fun1()
{cout << "fun1()" << endl;
}
void fun1(int a)
{cout << "fun1(int a)" << endl;
}
int main()
{fun1();fun1(10);return 0;
}

个数一样，类型顺序不一样

void testnum(char a, int b)
{cout << "testnum(char a, int b)" << endl;
}
void testnum(int a, char b)
{cout << "testnum(int a, char b)" << endl;
}
int main()
{testnum('g', 10);testnum(20, 'j');return 0;
}

错误的

返回值不一致不构成函数重载

#include <iostream>
using namespace std;
// 返回值不一样，不构成函数重载
void fx(int x, int y)
{cout << "fx(int x, int y)" << endl;
}
double fx(int x, int y)
{cout << "fx(int x, int y)" << endl;return 0.0;
}
int main()
{testnum('g', 10);testnum(20, 'j');return 0;
}

个数不一样构成函数重载，但是调用函数会出问题；因为带有缺省参数的函数，可以不用传实参

//1.个数不一样构成函数重载
//2.但是调用函数会出问题；因为带有缺省参数的函数，可以不用传实参
void fen()
{cout << "fen()" << endl;;
}
void fen(int n = 0)
{cout << "fen(int n = 0)" << endl;
}
int main()
{//testnum('g', 10);//testnum(20, 'j');//fen(); // 调用有问题//fen(10);// 可以找到对应函数，并打印return 0;
}

10. 引用

10.1. 引用的概念和定义

  1. 引用不是重新定义一个变量，而是给这个变量取一个别名，编译器不会为引用变量开辟新空间，依然是和被引用的变量使用同一块内存空间。
  2. 假如说：鲁迅，有很多其他的名字，可以叫周树人、周樟寿等等，本质上都是说的同一个人
  3. 基本结构 : 类型& 引用别名=引用对象;
  4. C++中为了避免引入太多的符号，所以和取地址使用的同一个符号 ' & ';可以发现C++也使用了C语言中的左移和右移操作符
  5. 可以看下面例子，语法层面来说就是给a变量取另外一个名字，而且都是指向同一块内存空间的，引用可以改变内容，不能改变指向
#include <iostream>
using namespace std;
int main()
{int a = 10;int& b = a;//给别名取别名int& c = b;int& d = c;cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "c = " << c << endl;cout << "d = " << d << endl;//取别名的地址，它们都指向同一块空间cout << "a = " << &a << endl;cout << "b = " << &b << endl;cout << "c = " << &c << endl;cout << "d = " << &d << endl;return 0;
}

10.2.引用的特性

  1. 引用在定义是必须初始化
  2. 一个变量可以有很多个引用
  3. 引用了一个实体，不能再引用其他实体
#include <iostream>
using namespace std;
int main()
{int a = 10,b = 20;//int& at; 错误的int& ay = a;//一个变量多个引用,本质上都是a的其他名字int& aa = a;int& ab = aa;int& ac = ab;int& ad = a;//只能改变内容，不能改变指向ay = b;cout << ay << endl;return 0;
}

10.3引用的使用

  1. 引用在实践中，主要是引用传参和引用做返回值，减少拷贝和改变引用对象时同时改变被引用对向；
  2. 引用和指针功能类似，但是引用更加方便
  3. 引用的返回值的场景比较复杂，下面场景就很好的说明的用处
#include <iostream>
#include <cassert>
using namespace std;
typedef int STDataType;
typedef struct Stack
{STDataType* a;int top;int capacity;
}ST;
void STInit(ST& rs, int n = 4)
{rs.a = (STDataType*)malloc(n * sizeof(STDataType));rs.top = 0;rs.capacity = n;
}
// 栈顶
void STPush(ST& rs, STDataType x)
{// 满了，扩容if (rs.top == rs.capacity){printf("扩容\n");int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *sizeof(STDataType));if (tmp == NULL){perror("realloc fail");return;}rs.a = tmp;rs.capacity = newcapacity;}rs.a[rs.top - 1] = x;rs.top++;
}
//以前使用的方法
void Modify(ST& rs, STDataType x)
{rs.a[rs.top - 1] = x;
}
//现在使用的方法
// int STTop(ST& rs)
int& STTop(ST& rs)
{assert(rs.top > 0);return rs.a[rs.top - 1];
}
//int STTop(ST& rs)
//{
//	assert(rs.top > 0);
//	return rs.a[rs.top - 1];
//}
int main()
{	//调⽤全局的ST st1;STInit(st1);STPush(st1, 1);STPush(st1, 2);STTop(st1) = 5;return 0;
}

  1. 引用和指针在实践过程中相辅相成，功能相似，但是各不一样，也不可以相互替代。和其他语言有很大的差距，比如java，java和C语言的指针很像可以改变指向，而C++的引用不行
  2. 引用场景还有一些，看下面代码的函数传参，原本时用来接收一级指针的；现在给链表的结点一级指针重新取了一个别名，pphead；避免了二级指针的繁琐操作
typedef int SLDataType;
typedef struct SListNode
{int data;struct SListNode* next;
}SLNode,*LNode;
// *LNode 等价于 typedef struct SListNode *LNode;
//链表尾删
//void SLDelBack(SLNode** pphead)
//void SLDelBack(SLNode*& pphead)
void SLDelBack(LNode& pphead)
{assert(pphead);if ((pphead)->next == NULL){free(pphead);pphead = NULL;}else{SLNode* ptail = pphead;SLNode* pcur = pphead;while (ptail->next){pcur = ptail;ptail = ptail->next;}free(ptail);ptail = NULL;pcur->next = NULL;}

10.4. const引用

  1. 可以引用一个const对象，但是也必须用const引用，const也可以引用一个普通对象；但是引用的权限只可以缩小不可以放大
  2. 比如const int& sum = (a + b); 和 const int& fi = f;这些计算结果和类型转换会产生临时对象空间，而C++中临时空间具有常属性，有常属性就需要const，让它变成只读
  3. 产生这些为命名的临时空间，可以叫做临时对象
  4. 类型转换、整型提升、临时计算的结果等等，都是具有常性

using namespace std;
typedef int STDataType;
int main()
{const int a = 10;// 具有了常属性int ai = a;//可以读取，不是权限放大//int& ay = a;//此时会造成权限放大const int& ay = a;//正确做法int b = 20;const int& by = b;//引用时的权限可以缩小，但是不能放大b++;//by++;//const 限制的是by权限，并不限制b，所以可以b++;//int& n = 40;//40具有常属性，会开辟临时空间权限会放大，所以需要const使权限缩小，变成只读const int& n = 40;//n不销毁，40也不会销毁，始终跟着n的生命周期来const int& sum = (a + b);//计算出的结果会产生临时变量，所以也需要constdouble f = 3.15;int ft = f;//发生截断cout << ft << endl;//int& fi = f;//类型转换也会创建临时变量所以需要constconst int& fi = f;double& rf = f;return 0;
}

10.5. 指针和引用的关系

  1. 指针和引用有着很大的关系，但是互相不替代各有提点，在实践过程中往往一起结合使用解决问题
  2. 引用不需要开额外的空间，而指针存储一个变量是需要开空间的
  3. 引用必须初始化，但是指针可以初始化为NULL，或者初始化
  4. 引用不可以改变指向，一旦引用了这个对象那就不能有其他的对象；为什么呢？
    1. 可以理解为定义一个指针，它可以通过取地址改变去指向不同的空间，而引用一旦引用了这块空间就不会换，可以更改里面的内容和改变指向 要区分开
    2. 而指针就可以随意改变指向对象
  5. 引用可以直接访问对象，而指针需要解引用才能访问对象
  6. sizeof中含义不同，引用的大小为引用类型的大小，指针在32位平台下占4字节，63位平台下占8字节
  7. 个人觉得引用比指针更好用，不容易犯错
#include <iostream>
using namespace std;
int main()
{int a = 10;int* ap = &a;*ap = 1;int& ay = a;ay = 3; //间接空引用int* pt = NULL;int& pty = *pt;return 0;
}

11. inline 内联函数

  1. 内联函数就是用来替代C语言的宏函数，因为C语言的宏很容易出错，不够方便
  2. 加了inline只是对编译器的一个建议，可以在调用的时候选择不展开，展不展开取决于编译器，就好比如你是一个递归函数，就算加了inline编译器会选择不展开；所以inline适合频繁调用的短小函数
  3. 个人理解：inline 只是对编译器的一个建议，如果编译器接受你的建议是会展开的(展开减少了函数栈帧的开辟，提高了效率)，如果编译器不接受你的建议(代表这个不是内联了)，那么就不会展开；此时的编译器还是会认为它是一个函数，是函数就会有栈帧的开辟
  4. vs编译器debug版本下面默认是不展开inline的，这样方便调试，宏函数复杂容易出错而且不方便调试，所以inline就是来替代宏函数的
  5. 如果想看看展开，需要在编译器里设置两个地方

  1. inline非常不建议声明和定义分别放到头文件和.cpp文件，分离会导致编译错误，因为inline被展开了，没有函数地址，链接会导致报错
  2. 虽然说vs编译器默认不展开，但是它是默认，而在分两个文件放时不行的
#include <iostream>
using namespace std;//宏函数，常见容易写错的地方
//#define ADD(x,y) return x + y 
//#define ADD(x,y)  (x + y) 
//#define ADD(x,y)  (x) + (y) #define ADD(x ,y) ((x) + (y)) 
int main()
{int a = 10, b = 20;int sum = ADD(a, b);cout << sum << endl;//1.为什么不能加分号？，因为宏是将整个替换掉，会导致多一个分号//cout << ADD(30, 40) << endl;  假设加分号#define ADD(x ,y) ((x) + (y)); -->  cout << 70; << endl;//2.为什么外面要加括号？，最根本的就是优先级问题，假设不加外括号cout << ADD(30, 40) * 10 << endl; // 替换后 30 + 40 * 10,优先级就就是乘法了//3.为什么要加内括号？，如果 x 是一个表达式且不加内括号  10 & 10 + 40  按位与的优先级是很低的，就会导致先算10 + 40cout << ADD(10 & 10, 40) * 10 << endl;return 0;
}
  1. 为什么不能加分号？，因为宏是将整个表达式替换掉，会导致多一个分号
  2. 为什么外面要加括号？，最根本的就是优先级问题
  3. 为什么要加内括号？，这也是优先级问题
  4. 在汇编代码层面默认不展开，通过call和jmp跳转到对应函数；
    1. 可以发现，地址跳转都是都是按照指定地址的

  1. 如果要展开，可以在设置里面勾选，会直接展开执行过程；但是当内联函数里过多代码，编译器会选择不展开

12. nullptr

  1. NULL在C语言中实际是一个宏，在C的头文件(stddef.h)中是这么定义的
#ifndef NULL#ifdef __cplusplus#define NULL    #else#define NULL    #endif
#endif
  1. 在函数调用传参的过程中，NULL有可能会被当做是0，但是和你预期的函数调用不符合，从下放的调试图就可以看出，系统调用的是void f(int x)函数，并没有去调用void f(int* x)；C中被定义为无类型指针(void*)的常量，C语言的定义是void*的指针可以传递给任意类型的指针，这也体现出了C语言留下的小毛病
#include <iostream>
using namespace std;void f(int x)
{cout << "void f(int x)" << endl;
}
void f(int* x)
{cout << "void f(int* x)" << endl;
}
int main()
{f(0);f(NULL);//f((void*)0); //这种C语言的写法不行，C语言的定义是void*的指针可以传递给任意类型的指针，但C++不行return 0;
}

//C++ 
void* a = NULL;
int* pa = (int*)a;//而C++不行//C  隐式类型转换
void testC()
{void* a = NULL;int* pa = a;//这里有隐式类型转换int p = pa;//而C语言pa指针隐式类型转换成了，int类型，C++ 不行}
  1. C语言会有隐式类型转换，C++没有，并且C++检查会更加严格；所以为了避免这种问题；C++引入了nullptr，nullptr是一个特殊关键字，一种特殊的字面量，可以传递给任意类型，还可以避免类型转换的问题
  2. nullptr只能隐式转换成指针类型，而不是像上面C语言中的NULL那样被转换成了int类型，也就说nullptr是指针专用的了。
#include<iostream>
using namespace std;
void fi()
{cout << "world" << endl;
}
int main()
{int* fr = fi();return 0;
}

上面代码，调用 fi 函数时，是不能接收任意指针类型的

总结：

  • 很久没有写博客了，今天逼自己一把，还是写了；放假有些懈怠，不过还需继续坚持

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/web/49695.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Linux权限维持篇

Linux权限维持篇

目录 SSH后门 &#xff08;1&#xff09;软链接sshd &#xff08;2&#xff09;SSH Key 生成公私钥 创建个authorized_keys文件来保存公钥 通过修改文件时间来隐藏authorized_keys &#xff08;3&#xff09;SSH Keylogger&#xff08;记录日志&#xff09; Linux的PA…
阅读更多...
【Go系列】Go的UI框架Fyne

【Go系列】Go的UI框架Fyne

前言 总有人说Go语言是一门后端编程语言。 Go虽然能够很好地处理后端开发&#xff0c;但是者不代表它没有UI库&#xff0c;不能做GUI&#xff0c;我们一起来看看Go怎么来画UI吧。 正文 Go语言由于其简洁的语法、高效的性能和跨平台的编译能力&#xff0c;非常适合用于开发GUI…
阅读更多...
MICA：面向复杂嵌入式系统的混合关键性部署框架

MICA：面向复杂嵌入式系统的混合关键性部署框架

背景 在嵌入式场景中&#xff0c;虽然 Linux 已经得到了广泛应用&#xff0c;但并不能覆盖所有需求&#xff0c;例如高实时、高可靠、高安全的场合。这些场合往往是实时操作系统的用武之地。有些应用场景既需要 Linux 的管理能力、丰富的生态&#xff0c;又需要实时操作系统的高…
阅读更多...
vue中scoped详解以及样式穿透＞＞＞、/deep/、::v-deep

vue中scoped详解以及样式穿透＞＞＞、/deep/、::v-deep

1、scoped scoped属性用于限制样式仅应用于当前组件。当一个style标签拥有scoped属性时&#xff0c;它的CSS样式就只能作用于当前的组件&#xff0c;通过该属性&#xff0c;可以使得组件之间的样式不互相污染。 原理&#xff1a;当样式中加了scoped属性时候&#xff0c;编译的…
阅读更多...
数据库解析一维和二维简易JSON，

数据库解析一维和二维简易JSON，

项目还在使用Oracle11&#xff0c;不支持后续官方的json解析方式&#xff0c; 在 前年、去年、今年 接连 遇到json解析问题后&#xff08;其实是公司的轮子效率太慢&#xff0c;太复杂&#xff0c;决定自己造个轮子&#xff0c;看看到底为什么慢&#xff0c;是不是真的很复杂&a…
阅读更多...
【最新】cudnn安装教程

【最新】cudnn安装教程

最近换了新电脑需要重新安装cuda和cudnn&#xff0c;发现现在cudnn的安装比以前方便多了&#xff0c;直接在官网下载exe安装包一键运行即可。安装的时候注意cuda和cudnn的对应关系即可&#xff1a;【最新】cuda和cudnn和显卡驱动的对应关系-CSDN博客 访问cudnn下载链接cuDNN 9…
阅读更多...
Git 基础 GitHub【学习笔记】

Git 基础 GitHub【学习笔记】

一、Git 优势 大部分操作在本地完成&#xff0c;不需要联网完整性保证尽可能添加数据而不是删除或修改数据分支操作非常快捷流畅与 Linux 命令全面兼容 二、Git 程序安装 https://git-scm.com 三、Git 结构 #mermaid-svg-9Go6R1leWXWrDCqn {font-family:"trebuchet ms&quo…
阅读更多...
运维锅总详解NFS

运维锅总详解NFS

NFS是什么&#xff1f;如何对NFS进行部署及优化&#xff1f;NFS工作流程是什么&#xff1f;NFS的性能及优缺点是什么&#xff1f;NFS发展历史又是怎样的&#xff1f;希望本文能帮您解答这些疑惑&#xff01; 一、NFS简介 NFS (Network File System) 是由 Sun Microsystems 在…
阅读更多...
论文精读（保姆级解析）—— Flash Diffusion

论文精读（保姆级解析）—— Flash Diffusion

0 前言 今天分析的论文是《Flash Diffusion: Accelerating Any Conditional Diffusion Model for Few Steps Image Generation》。该论文发表在2024年&#xff0c;目前已开源在arxiv上&#xff0c;主要提出了一种高效、快速且多功能的蒸馏方法&#xff0c;用于加速预训练扩散模…
阅读更多...
[C++][STL源码剖析] 详解AVL树的实现

[C++][STL源码剖析] 详解AVL树的实现

目录 1.概念 2.实现 2.1 初始化 2.2 插入 2.2.1 旋转&#xff08;重点&#xff09; 左单旋 右单旋 双旋 2.❗ 双旋后&#xff0c;对平衡因子的处理 2.3 判断测试 完整代码&#xff1a; 拓展&#xff1a;删除 1.概念 二叉搜索树虽可以缩短查找的效率&#xff0c;但…
阅读更多...
遇到Websocket就不会测了？别慌，学会这个Jmeter插件轻松解决....

遇到Websocket就不会测了？别慌，学会这个Jmeter插件轻松解决....

websocket 是一种双向通信协议&#xff0c;在建立连接后&#xff0c;websocket服务端和客户端都能主动向对方发送或者接收数据&#xff0c;而在http协议中&#xff0c;一个request只能有一个response&#xff0c;而且这个response也是被动的&#xff0c;不能主动发起。 websoc…
阅读更多...
【研路导航】保研英语面试高分攻略，助你一路过关斩将

【研路导航】保研英语面试高分攻略，助你一路过关斩将

面试攻略之 千锤百炼英语口语 写在前面 在保研面试中&#xff0c;英语口语往往是让许多同学感到头疼的一部分。如何在面试中展现出自信和流利的英语表达能力&#xff0c;是我们今天要探讨的主题。以下是一些有效的英语口语练习方法和常见题型解析&#xff0c;帮助你在保研面试…
阅读更多...
LoRA:低秩自适应

LoRA:低秩自适应

LoRA:低秩自适应 本章节是对轻松上手微调大语言模型——QLORA篇中提到的LoRA的原理解释。 背后动机 现今模型的参数量变得越来越大&#xff0c;对预训练模型进行全微调变得越来越不可行。为了解决这个问题有了LoRA&#xff08;Low-Rank Adaption&#xff09;的诞生。将可训练…
阅读更多...
Nginx制作下载站点

Nginx制作下载站点

使用nginx制作一个类似nginx官网的下载站点 如何制作一个下载站点,首先需要ngx_http_autoindex_module模块 该模块处理以斜杠(“/”)结尾的请求&#xff0c;并生成目录列表。 nginx编译的时候会自动加载该模块&#xff0c;但是该模块默认是关闭的&#xff0c;需要使用下来指令…
阅读更多...
3 FreeRTOS移植(从FREERTOS官网移植进自己的工程)

3 FreeRTOS移植(从FREERTOS官网移植进自己的工程)

3 FreeRTOS移植 1 获取FreeRTOS源码&#xff08;熟悉&#xff09;1.1 介绍源码内容1.2 FreeRTOS内核1.2.1 Demo文件夹1.2.2 Source文件夹1.2.2.1 portable文件夹 2 FreeRTOS手把手移植&#xff08;掌握&#xff09;&#xff08;重要&#xff09;2.1 移植步骤 3 系统配置文件说明…
阅读更多...
GraphHopper-map-navi_路径规划、导航（web前端页面版）

GraphHopper-map-navi_路径规划、导航（web前端页面版）

文章目录 一、项目地址二、踩坑环境三、问题记录3.1、graphhopper中地图问题3.1.1. getOpacity不存在的问题3.1.2. dispatchEvent不存在的问题3.1.3. vectorLayer.set(background-maplibre-layer, true)不存在set方法3.1.4. maplibre-gl.js.map不存在的问题3.1.5. Uncaught Ref…
阅读更多...
学习记录：ESP32控制舵机 FREERTOS BLE

学习记录：ESP32控制舵机 FREERTOS BLE

控制舵机 PWM信号 PWM信号是一种周期性变化的方波信号&#xff0c;它有两个关键参数&#xff1a; 周期&#xff08;Period&#xff09;&#xff1a;一个完整的PWM信号的时间长度&#xff0c;通常用秒&#xff08;s&#xff09;或毫秒&#xff08;ms&#xff09;表示。占空比…
阅读更多...
FFmpeg解复用器如何从封装格式中解析出不同的音视频数据

FFmpeg解复用器如何从封装格式中解析出不同的音视频数据

目录 1、ffmpeg介绍 2、FFMPEG的目录结构 3、FFmpeg的格式封装与分离 3.1、数据结构 3.2、封装和分离（muxer和demuxer） 3.2.1、Demuxer流程 3.2.2、Muxer流程 4、总结 4.1、播放器 4.2、转码器 C++软件异常排查从入门到精通系列教程（专栏文章列表，欢迎订阅，持续…
阅读更多...
微服务上（黑马）

微服务上（黑马）

文章目录 微服务011 认识微服务1.1 单体架构1.2 微服务1.3 SpringCloud 2 微服务拆分2.1 熟悉黑马商城2.2 服务拆分原则2.2.1.什么时候拆2.2.2.怎么拆 2.3 拆分服务2.3.1 拆分商品管理功能模块2.3.2 拆分购物车功能模块 2.4 远程调用2.4.1 RestTemplate2.4.2.远程调用 2.5 总结…
阅读更多...
顺序表算法题

顺序表算法题

在学习了顺序表专题后&#xff0c;了解的顺序表的结构以及相关概念后就可以来试着完成一些顺序表的算法题了&#xff0c;在本篇中将对三道顺序表相关的算法题进行讲解&#xff0c;希望能对你有所帮助&#xff0c;一起加油吧&#xff01;&#xff01;&#xff01; 1.移除元素 2…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023