✨个人主页： Yohifo

🎉所属专栏： C++修行之路

🎊每篇一句：图片来源

The longest way must have its close,the gloomiest night will wear on a morning.

最长的路也有尽头，最黑暗的夜晚也会迎来清晨。

📘前言

C++ 是 C语言的超集，是一门在 C语言基础上发展起来的语言，C++ 很强大，如今 C++ 已是一个多重范型编程语言，主要包含四部分：C、Object-Oriented C++、Template C++和STL，因此我们一般将 C++ 看作一个语言联邦，显然 C++ 的内容很丰富，也比较难学，但当我们掌握后，它将称为一把利刃

C++ 摘得 TIOBE 2022 年度编程语言桂冠

📘正文

📖初识C++

先简单了解下 C++ 的起源

C++祖师爷—本贾尼·斯特劳斯特卢普

🖋️C++起源

C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代，计算机界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生

总结：C语言无法满足大型软件的开发需求

无所谓，祖师爷会出手

1979年，贝尔实验室的本贾尼等人试图分析 UNIX 内核的时候，试图将内核模块化，于是在 C语言的基础上进行扩展，增加了类的机制，完成了一个可以运行的预处理程序，称之为 C with classes

1982年，本贾尼博士在 C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与 C语言的渊源关系，命名为 C++ 因此：C++ 是基于 C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

在本贾尼博士的不断修修改改下，一门新的编程语言 C++ 就诞生了

1998年，C++ 标准第一个版本发布，绝大多数编译器都支持，得到了国际标准化组织(ISO)和美国标准化协会认可，以模板方式重写 C++ 标准库，引入了 STL (标准模板库)

2011年，C++ 11标准发布，增加了许多特性，使得 C++ 更像一种新语言，比如：正则表达式、基于范围for循环、auto关键字、新容器、列表初始化、标准线程库等

2020年，C++ 引入了许多新的特性，比如：模块(Modules)、协程(Coroutines)、范围(Ranges)、概念(Constraints)等重大特性，还有对已有特性的更新：比如Lambda支持模板、范围for支持初始化等

由此可见，C++ 是一门更新周期长、内容丰富的编程语言，如今大多数公司主要实用标准为 C++98 和 C++11 ，因此我们现阶段还不需要掌握最新标准内容，从 C++ 入门基础开始，稳扎稳打，争取学好 C++

来自陈皓大佬的吐槽

🖋️C++关键字

C++ 兼容 C语言，因此 C语言中的所有32个关键字在 C++ 中均可以使用，当然 C++ 在此基础上新增了31个关键字，使得 C++ 中的关键字数达到了63，当然这么多关键字现在没必要全部看懂，在学习后面知识时会用到

🖋️C++第一个程序

江湖规矩，学习 C++ 首先少不了 Hello World!

#include<iostream>  //IO流头文件
using namespace std;  //全局展开std命名空间
int main()
{
  // cout 是输出函数
  // << 流插入运算符，配合 cout 使用
  // endl 换行符，相当于 \n
  cout << "Hello World!" << endl;
  return 0;
}

向世界打个招呼后，我们就可以正式开始 C++ 的修行之路了

📖命名空间

命名空间是我们接触的第一个 C++ 特性，当然其他高级语言也支持

背景

在使用 C语言时，我们自己定义的名字可能和库函数起冲突，或者在同一个项目组中，多人定义的名字起冲突

此时我们只有改名字这一条路可选，显然祖师爷本贾尼对于这种方法很不满，于是他想出来这种解决方法

通过不同的命名空间将变量/函数限定使用，即使存在两个同名变量，只要相应空间找对了，也不会起冲突

#include<iostream>  //IO流头文件
using namespace std;  //全局展开std命名空间
//命名空间
namespace AA
{
  int num = 10;
}
namespace BB
{
  int num = 24;
}
int main()
{
  //不同命名空间内的同名 变量/函数 不冲突
  cout << AA::num << endl;
  cout << BB::num << endl;
  return 0;
}

🖋️展开方式

此时我们就能看懂下面这行代码了

using namespace std;  //全局展开std命名空间

它的作用是展开 std 这个命名空间，即库函数，只有展开后，我们才能正常使用 cout

这种展开方式叫做全局展开，除了全局展开外，还有部分展开和域作用限定符展开

全局展开

using namespace 命名空间; //全局展开覆盖范围为整个程序
//比如
using namespace AA; //全局展开AA这个命名空间，可以在任意位置使用AA中的变量/函数

部分展开

using 命名空间::待使用变量/函数;
//比如
using AA::num;  //只展开AA中的变量num，此时可在任意位置使用AA中的变量num

域作用限定符

//需要使用时
cout << 命名空间::待使用变量/函数 << endl; //需要使用时展开
//比如
std::cout << AA::num << std::endl;  //这个就是使用时展开
//注意：假设 :: 左边为空，如 ::num 这种情况，会去全局范围内查找变量
//num，如果没有找到，就会报错

三种方式各有好坏，使用场景有所不同

当我们日常写小程序时，可以使用全局展开的方式，因为不受其他人干扰，也不会干扰其他人

其他场景中，推荐使用部分展开 + 域作用限定符，频繁使用的对象通过部分展开，使用频率较少的对象直接使用域作用限定符就行了

原因：如果随意使用全局展开，那么命名空间就没有存在的意义了

注意：

命名空间支持嵌套使用

如果出现同名的命名空间，编译器会将其合并，可能会引起冲突

命名空间是在编译查找时启用

📖缺省参数

祖师爷在 C++ 中设计了缺省参数这个概念，使得函数在没有参数传递时也可以按其他方式运行

缺省参数

在函数声明时，为形参设定初始值，当有实参传入时，使用实参；如果没有实参传入，则启用初始值

缺省参数就像是现实中的舔狗、备胎，做好随时被需要的准备

#include<iostream>  //IO流头文件
using namespace std;  //全局展开std命名空间
//在函数声明时给形参设定初始值
void print(int val = 999)
{
  if (val == 999)
  cout << "缺省参数已启用 val 值为：";
  else
  cout << "缺省参数未启用 val 值为：";
  cout << val << endl;
}
int main()
{
  print(100);
  print();  //设有缺省参数的函数，可以不传参数
  return 0;
}

缺省参数的出现使得函数运行多了一种可能，实际运用场景如：在栈初始化时，设定缺省参数值为4，即默认大小为4，假若用户不传参数，则按4来初始化栈大小；若传递了参数，则按实参初始化栈大小

🖋️注意事项

缺省参数很实用，但也要慎用

缺省参数有很多使用规则：

1、只允许从右到左依次连续缺省，不得出现跳跃缺省

//正确用法
void test(int a, int b = 2, int c = 3); //从右至左，连续缺省
//错误用法
void test(int a = 1, int b, int c); //非从右至左缺省
void test(int a, int b = 2, int c); //跳跃缺省，非法

2、调用时，实参依次从左往右传递

//正确用法
test(4,5,6);  //不启用缺省值，a = 4，b = 5， c = 6
test(5,6);  //启用缺省参数 c，a = 5， b = 6, c = 3
//错误用法
test(); //此时必须传一个参数，因为参数 a 不是缺省参数
test(1,2,3,4);  //参数传多了

3、声明和定义中不能同时出现缺省参数，只能在声明中出现

//test.h
//声明时缺省
void test(int a = 10);  
//test.c
//定义时不必再缺省
void test(int a)
{
  cout << a << endl;
}

4、C语言不支持缺省参数

void test(int a = 10);  //C语言实现会报错

📖函数重载

C语言不允许两个函数名字相同，比如函数 Add 只能适用于一种数据类型，在 C++ 中支持函数重载，即在参数不同（包括类型不同或顺序不同）的前提下，允许同时存在多个同名函数

//C语言
int Add(int x, int y);
double Add(double x, double y); //此时会报错，两个函数名冲突
//C++
int Add(int x, int y);
double Add(double x, double y); //正常编译，即使函数名都是Add，但在C++中编译器能分清两者

原因： C++中引入了新的函数名修饰规则，比如对于两个Add函数来说，Linux中会分别修饰为 _3Addii 与 _3Adddd，显然两者是不同的；而对于C语言来说两个函数名修饰后都为 Add

我们可以在 Linux 环境下，通过指令 objdump -S 可执行程序查看函数名修饰情况

函数名修饰后，后序并入符号表，链接时只要函数修饰名不冲突，就可以正常链接

Linux 中对于函数名的修饰规则比较简单，而 Windows 中则比较复杂，如在 VS 中，上述函数名修饰为 ?Add@@YAHHH@Z 过于复杂了

下面是重载的各种情况

//假设存在函数 func
void func(int* pa, int len);  //修饰为 _4ZfuncPii 指针需加P
//正确的重载情况，只要修饰后的函数名不冲突，就能构成重载
void func(int& pa, int len);  //修饰为 _4ZfuncRii 引用需加R
int func(int len, int* pa); //修饰为 _4ZfunciPi
char* func(int* pa);  //修饰为 _4ZfuncPi
//错误的重载情况
int func(int* pb, int n); //修饰为 _4ZfuncPii 冲突
void testc(int a, int b); //修饰为 _4Ztestcii
void testc(int b, int a); //修饰为 _4Ztestcii 冲突

注意：返回值不纳入函数名修饰中，假若加入，函数调用时就会出现混乱，因此返回值不同并不构成函数重载

📖引用

引用是一个很好用的工具，它有指针指向同一块数据的能力，同时它不像指针那样危险、复杂，换句话说，引用是指针改进版，在后续学习中，有 80% 的场景都会使用引用而非指针

int a = 10;
int* pa = &a; //指针
int& ra = a;  //引用

引用的底层实现仍然是指针

引用相当于给变量取别名

比如在我们日常生活中，马铃薯/山药蛋/洋芋/洋番芋/薯仔/Potato等等都表示土豆，不同地区叫法不同，换句话说，土豆在全国各地有很多个引用，只要表示对了，都是指土豆

上面代码段中的 ra 与 a 都表示同一块空间，而 *pa 和 a 也表示同一块空间；可以简单把引用理解为一个智能版指针，会自动解引用，使用起来更方便

🖋️引用特性

引用有很多使用特性，即使用规范，使得引用更加安全

引用必须初始化，当一个引用变量被创建时，必须存在其所代表的变量

一个变量可以存在多个引用，就像土豆可以有多个别名

当引用初始化后，无法再代表其他变量，每个引用一生只为一人

不存在多级引用，当引用b 代表引用a 时，实际上就是在代表引用a 所代表的变量 a

char a = 'A';

char b = 'B';

//1、引用必须初始化
char& ra = a; //正确
char& rx; //错误，必须初始化
//2、一个变量可以有多个引用
char& ra = a;
char& rra = a;
char& rrra = a; //没有问题，一个变量允许存在多个引用
//3、引用无法改变指向
char& ra = a;
char& ra = b; //错误，引用一旦确立后，就无法再改变其指向
ra = b; //这个没问题，实际结果为 a = 'B' 即将 b 的内容赋值给 a
//4、不存在多级引用
char& ra = a;
char&& b = ra;  //非法，不存在多级引用
char& b = ra; //合法，实际结果为 char& b = a;

注意：引用不能像指针那样随意使用，引用也不存在指针多级指向的功能

比如下图这种情况对于引用来说是不存在的

🖋️常引用

对于指针和引用来说，存在权限问题，因为指针和引用具有直接修改原数据的能力

众所周知，对于程序来说，存在几个区域：栈、堆、静态区等等，我们使用的常量位于数据段或代码段中，常量具有可读不可修改的特性，当我们使用普通指针或引用指向常量数据时，会引发错误

int main()
{
  const int a = 10; //此时a为常变量，具有常量属性
  const int* pa = &a; //正常
  const int& ra = a;  //正常
  return 0;
}

解决方法也很简单，将指针或引用改为只读权限，就能正常指向常量了（权限平移）

🖋️使用场景

引用主要有以下几个使用场景

1、做参数

void swap(int& ra, int& rb)
{
  //有了引用之后，不需要再解引用，也能达到指针的效果
  int tmp = ra;
  ra = rb;
  rb = tmp;
}

2、做返回值

#include<iostream>
using namespace std;
int arr[10] = {0};  //数组为全局变量
int& getVal(int pos)
{
  //返回数组指定位置的值
  return arr[pos];
}
int main()
{
  for(int i = 0; i < 10; i++)
  {
  //借助引用，可以直接通过返回值修改数组中的值
  getVal(i) = i * 10;
  cout << arr[i] << " ";
  }
  cout << endl;
  return 0;
}

当引用做返回值时，接收到的变量就是函数返回时的本体，比如全局数组 arr ，此时对返回值做出修改，就是在改变数组 arr

引用返回很强大，但也不能随便使用，引用返回一般用于生命周期较长的变量，即函数结束后不被销毁的变量，如果使用生命周期短的变量作为引用返回值，那么结果是未定义的

int& func(int n)
{
  int val = n;
  return val; //结果未定义
}
//val是函数 func 中的局部变量，当函数结束后，变量就被销毁了
//此时可能得到正确的结果(编译器未清理)，也可能得到错误的结果（编译器已清理）
//因此说结果是未定义的
//可以看到下图中相同语句出现两种结果

引用返回原理：

之前我们一直都是走的临时变量那条路，现在有了引用后，在使用生命周期较长的变量时，就可以考虑使用引用返回来提高效率

性能对比	1w数据量	10w数据量
普通值返回	14ms	1753ms
引用返回	0ms	1ms

🖋️小结

引用是比较重要的特性，需要小结一下：

引用在概念上是给变量取别名，而指针是新开一块空间指向变量

引用必须初始化，指针可以不初始化

引用无法改变指向，指针可以

不存在空引用，但存在空指针

引用大小为所代表变量的大小，而指针大小为 4/8 字节

引用+1等价于变量+1，指针+1则表示指向位置向后偏移一个单位

引用不需要解引用，指针使用前需要解引用

引用使用起来更安全、更方便

以后涉及需要改变原变量值时，优先考虑使用引用，特殊场景下，仍然需要使用指针

引用与指针互不冲突，两者都有自己适用的领域，比如在实现链表时，必须使用指针，因为引用无法改变指向，而链表需要频繁的进行改链操作

📖内联函数

内联函数主要是为了替代宏函数，因为宏函数存在很多坑，并且在某些场景下使用复杂

#define ADD(x, y) ((x) + (y)) //通过宏函数实现ADD，比较复杂、麻烦

除了使用复杂外，宏还存在以下缺点：

不能进行调试，宏是直接进行替换的

没有类型安全检查

在书籍《Effective C++》中，作者建议

使用 const 和 enum 替换宏定义的常量

使用内联函数 inline 替换宏函数

总之，宏很危险，需要少用

所谓内联函数就是在函数实现前加上 inline 修饰，此时函数会被编译器标记为内联函数

//此时的 Add 函数就是一个内联函数
inline int Add(int x, int y)
{
  return x + y;
}

内联函数特点：

在 Debug 模式下，函数不会进行替换，可以进行调试

在 Realse 模式下，函数会像宏函数一样展开，提高程序运行速度

内联函数弥补了宏函数的不足，同时吸收了宏函数速度快的优点

内联函数可以全面替代宏，当然使用时也需要注意

频繁使用内联函数，编译出来的可执行程序会更大，因为代码会变多，但运行速度更快

调用内联函数时，是否展开取决于编译器，如果内联函数展开后会影响性能，那么编译器有权不展开内联函数

内联函数适用于代码行数较少，且被频繁调用的小函数

内联函数不建议声明和定义分开，因为内联函数不进入符号表，因此可能产生链接错误，推荐在声明时就顺便将函数定义，头文件展开时，将内联函数一起包含

📖auto关键字

这个是 C++11 中的新特性，auto 关键字能直接识别目标变量类型，然后自动转换为相应类型

int a = 10;
int* b = &a;
auto aa = a;  //此时 aa 为 int
auto bb = b;  //此时 bb 为 int*

除了自动识别外，我们还可以指定转化类型

int a = 10;
auto* pa = a; //指定 pa 为 int*
auto& ra = a; //指定 pa 为 int&

期学习中，某个变量类型可能非常长，此时可以利用 auto 自动识别类型

auto 支持一行声明多个变量，当然类型得统一

auto a = 1, b = 2, c = 3; //合法，类型统一
auto a = 1, b = 2.2;  //非法，类型不统一

注意： auto 不能用于数组，auto 也不能当作参数类型

📖范围for

这个也是 C++11 中的新特性，是一个语法糖，范围 for 循环拥有自动拷贝、自动判断范围、自动结束等特点，使用起来很方便

#include<iostream>
using namespace std;
int main()
{
  int arr[] = {1, 2, 3, 4, 5};
  //范围 for 循环
  for(auto val : arr)
  {
  cout << val << " ";
  }
  cout << endl;
  return 0;
}

范围 for 配上 auto 自动识别类型，写出来的循环很简单，在加上引用，使得我们可以轻而易举的给数组赋值

#include<iostream>
using namespace std;
int main()
{
  int arr[] = {1, 2, 3, 4, 5};
  //范围 for 循环
  //配合引用修改原数组值
  for(auto& val : arr)
  {
  val *= 2;
  cout << val << " ";
  }
  cout << endl;
  return 0;
}

注意： 范围 for 遍历数组时，数组大小必须确定，迭代的对象要实现 ++ 和 == 的操作

📖nullptr指针空值

这个是 C++11 中新增的补丁，因为在设计 C++ 时，指针空值 NULL 出了点问题，NULL 可能被编译器直接识别为 0 而非 void*

#include<iostream>
using namespace std;
void func(int)
{
  cout << "参数为整型 0" << endl;
}
void func(void*)
{
  cout << "参数为指针 void*" << endl;
}
int main()
{
  func(0);
  func(NULL);
  return 0;
}

可以看到，NULL 并没有被识别为指针空值，因此委员会推出了 nullptr 这个补丁，专门用于给指针置空

注意：

nullptr 是作为关键字加入的，不需要头文件

nullptr 和 void* 的大小一致

在后续学习中，为了确保程序的健壮性，建议指针置空使用 nullptr 而非 NULL

auto、范围for、nullptr 这些都是 C++11 中的新特性，较老的编译器可能不支持

📘总结

以上就是关于 C++ 入门基础的全部内容了，我们从 C++ 的诞生开始，认识了 C++ 为弥补 C语言缺陷所做出的改动，也学习了 C++ 中的各种新特性，如引用、内联、auto等等；C++ 很强大，学习周期很长，但我相信锲而不舍，金石可镂，再高的山峰也有人成功登顶，C++ 的修行之路才刚刚开始，我们已充满信心

如果你觉得本文写的还不错的话，期待留下一个小小的赞👍，你的支持是我分享的最大动力！

如果本文有不足或错误的地方，随时欢迎指出，我会在第一时间改正

C++ 入门基础

📘前言

📘正文

📖初识C++

🖋️C++起源

🖋️C++关键字

🖋️C++第一个程序

📖命名空间

🖋️展开方式

📖缺省参数

🖋️注意事项

📖函数重载

📖引用

🖋️常引用

🖋️使用场景

🖋️小结

📖内联函数

📖auto关键字

📖范围for

📖nullptr指针空值

📘总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C++ 入门基础

📘前言

📘正文

📖初识C++

🖋️C++起源

🖋️C++关键字

🖋️C++第一个程序

📖命名空间

🖋️展开方式

📖缺省参数

🖋️注意事项

📖函数重载

📖引用

🖋️常引用

🖋️使用场景

🖋️小结

📖内联函数

📖auto关键字

📖范围for

📖nullptr指针空值

📘总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景