前言

C++是C语言的补充和拓展，所以C语言语法规则在C++也同样适用，但是C++中对于C语言的不足之处也做了补充和优化

比如：

作用域方面、IO方面、函数方面、指针方面、宏方面等。

C++关键字（C++98）

C++总计63个关键字，C语言32个关键字

这里只了解C++有多少关键字和关键字是那些，不对关键字的进行具体的讲解

命名空间

在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”: 重定义；以前的定义是“函数

命名空间定义

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

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

//2. 命名空间可以嵌套
// test.cpp
namespace Q1
{
    int a;
    int b;
    int Add(int left, int right)
    {
        return left + right;
    }
    //嵌套的命名空间
    namespace Q2
    {
        int c;
        int d;
        int Sub(int left, int right)
        {
            return left - right;
        }
    }
}
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个Q1会被合并成一个
// test.h
namespace Q1
{
    int Mul(int left, int right)
    {
        return left * right;
    }
}

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

命名空间的使用

命名空间成员的该如何使用呢？

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()
{
    printf("%d\n", a);
    return 0;
}

如果你直接使用你会喜提报错：

 // 编译报错：error C2065: “a”: 未声明的标识符

命名空间的使用办法有三种方式：

:: 这叫作用域限定符

  • 加命名空间名称及作用域限定符 
    int main()
{
    printf("%d\n", N::a);
    return 0;
}
  • 使用using将命名空间内中某个成员引入 
    using N::b;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n0", b);
    return 0;
}
  • 使用using namespace命名空间名称引入 
    using namespace N;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;
}

C++输入&输出

C++有一个std的命名空间

std是C++标准库的命名空间命名，C++将标准库的定义实现都放在了这个命名空间中

#include<iostream>

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类型的对象，>>和<<也涉及运算符重载等知识（这个我们到时候后面会说）

注意：早期标准库将所有功能在全局域中实现，声明在.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 >> b >> c;
	cout << a << endl << b << endl << c << endl;
	return 0;
}

代码结果：

3 3.14 a
3
3.14
a

//关于cout和cin还有很多更复杂的用法，比如控制浮点数输出精度，控制整形输出进制格式等等。因为C++兼容C语言的用法，这些又用得不是很多，我们这里就不展开学习了，真的需要使用可以直接使用C语言控制浮点数输出精度，控制整形输出进制格式

这里对于std命名空间的使用惯例：

std是C++标准库的命名空间，如何展开std使用更合理呢？
1. 在日常练习中，建议直接using namespace std即可，这样就很方便。

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

缺省参数

缺省参数的概念

缺省参数是声明和定义函数时为函数的参数指定一个缺省参数。

在调用该函数的时候，如果没有指定实参则采用该形参的缺省参数，否则使用指定的实参

#include<iostream>

using namespace std;

void Add(int x = 0, int y = 0)
{
    int num = x + y;
    cout << num << endl;
	//cout << x + y << endl;
}
int main()
{
	Add();//没有传参时，使用参数的默认值
	Add(1, 2);//传参时，使用指定的实参
}

代码结果：

0

3

缺省参数的分类

  • 全缺省参数 
    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. 缺省参数不能再函数声明和定义中同时出现
  3. 缺省值必须是常量或者全局变量
  4. C语言不支持（编译器不支持）

关于第一点：

#include<iostream>

using namespace std;

void Add(int x = 0, int y)
{
	cout << x + y << endl;
}
int main()
{
	Add(3);//我这个3是给x？y？
}

因为x虽然是缺省参数，但是也可以接收参数，但是也可以不给x传参，但是y不是缺省参数，必须要传参，所以这个时候编译器就会产生歧义，无法确定这个3到底是传给缺省参数x的还是给y的 

如果是从右往左给呢？

#include<iostream>

using namespace std;

void Add(int x, int y = 0)
{
	cout << x + y << endl;
}
int main()
{
	Add(3);//3给x，y没传参，y = 0很合理
    //Add( ,3);这是错误的写法，编译器不支持这种传参
}

因为缺少参数不能间隔给，所以不存在说3是越过x，成为y的传参，而且此时3给x，y是缺省值，并不会使编译器产生歧义

关于第二点：

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

关于第三点：

#include <iostream>
using namespace std;

//字面常量（最常用）
void func1(int a = 10) 
{ 
    cout << a << endl; 
}

//编译期const常量
const int MAX = 20;
void func2(int a = MAX) 
{ 
    cout << a << endl; 
}


//全局变量（运行期初始化，但合法）
int global_val = 30;
void func4(int a = global_val) 
{ 
    cout << a << endl; 
}


// 5. 静态局部变量（生命周期全局）
void func5() {
    static int static_val = 40;
}
// 缺省值用静态局部变量（合法）
void func6(int a = func5::static_val) 
{ 
    cout << a << endl; 
} // 注意：需确保static_val已初始化

函数重载

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

函数重载的概念

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

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

//参数个数不同
int Add(int x, int y)
{
	return x + y;
}
int Add(int x)
{
	return x * x;
}
//参数类型不同、顺序不同
int Add(int x, double y)
{
	return x + (int)y;
}
int Add(double y, int x)
{
	return x - (int)y;
}
int main()
{
	cout<<"Add(int x, int y)："<<Add(1, 2) << endl;
	cout<<"Add(int x)："<<Add(2) << endl;
	cout << "Add(int x, double y)：" << Add(1, 3.14) << endl;
	cout << "Add(double y, int x)：" << Add(3.14, 1) << endl;
	return 0;
}

代码结果：

Add(int x, int y)：3
Add(int x)：4
Add(int x, double y)：4
Add(double y, int x)：-2

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

C++ 支持函数重载而 C 语言不支持的核心原因，是两者对函数名的编译链接规则（名字修饰 / 名字改编，Name Mangling）不同，且底层的编译、链接流程设计也适配了不同的语言特性。

核心原因：名字修饰（Name Mangling）的差异

函数重载的本质是 “同名但参数列表不同的函数，在编译后能被链接器区分”，而名字修饰正是实现这一目标的关键机制 ——C 和 C++ 对函数名的修饰规则完全不同：

1. C 语言的名字修饰：仅保留原函数名，不区分参数

C 编译器编译函数时，会将函数名简单修饰为 _函数名（不同平台略有差异，如 Linux 是 func，Windows 是 _func），完全不包含参数的类型 / 个数信息。

例如：c运行

// C 代码
void func(int);
void func(double);

编译后，两个 func 都会被修饰为 _func（Linux 下是 func），链接器会发现 “符号重复定义”，直接报错 —— 这就是 C 不支持重载的核心原因：无法区分同名但参数不同的函数。

2. C++ 的名字修饰：包含函数名 + 参数类型 / 个数

C++ 编译器为了支持重载，会对函数名进行 “复杂修饰”，将函数名、参数类型、参数个数都编码到最终的符号名中，确保 “同名但参数不同的函数” 生成不同的符号。

不同编译器的修饰规则不同（如 GCC/Clang vs MSVC），但核心逻辑一致：

  • GCC/Clang（Linux/macOS）：_Z + 函数名长度 + 函数名 + 参数类型编码；
  • MSVC（Windows）：? + 函数名 + @ + 参数类型编码 + @Z。

示例（GCC 规则）：cpp运行

// C++ 代码
void func(int);    // 修饰后：_Z4funci（i=int）
void func(double); // 修饰后：_Z4funcd（d=double）
void func(int, double); // 修饰后：_Z4funcid

编译后，三个 func 生成完全不同的符号，链接器能精准区分，从而实现重载。

底层逻辑：编译 / 链接流程的适配差异

除了名字修饰，C 和 C++ 的设计目标差异也决定了对重载的支持与否：

特性 C 语言 C++ 语言
设计目标 简洁、高效、贴近硬件，面向过程 兼容 C + 面向对象 + 泛型，追求灵活
编译链接核心 以 “函数名” 为唯一符号标识 以 “函数名 + 参数” 为唯一符号标识
类型检查 弱类型检查（如隐式类型转换） 强类型检查（严格校验参数类型）
对重载的需求 无（面向过程，函数名唯一即可） 有（类成员函数、泛型编程等需要）

补充两个关键细节：

1. C 的 “弱类型” 不支持重载的语义基础

C 允许隐式类型转换（如 char 转 int、float 转 double），如果支持重载，会导致调用歧义：

c运行

// 假设C支持重载
void func(int);
void func(char);
func('a'); // 是调用func(int)还是func(char)？

C 为了简洁性，直接放弃重载；而 C++ 有严格的类型匹配规则，能解决这种歧义（优先精确匹配，再考虑隐式转换）。

2. C++ 的函数签名规则

C++ 定义 “函数签名” 为：函数名 + 参数类型（包括 const / 引用） + 参数个数（返回值不参与签名），这是重载的语义基础：

  • 合法重载：func(int) vs func(double)、func(int&) vs func(const int&)；
  • 非法重载：仅返回值不同（int func() vs void func()）—— 因为名字修饰不包含返回值，编译后符号相同，链接报错。

补充场景：extern "C" 的作用（C/C++ 混合编程）

如果想让 C++ 中的函数被 C 调用，需要用 extern "C" 禁用 C++ 的名字修饰，强制使用 C 的修饰规则 —— 这也反向验证了名字修饰是重载的核心：cpp运行

// C++ 代码
extern "C" {
    // 禁用C++名字修饰，按C规则修饰为 _func
    void func(int) { ... }
}

// 此时无法重载：void func(double) 会被修饰为 _func，符号重复
// void func(double) { ... }

总结

维度 C 语言 C++ 语言
名字修饰 仅保留函数名，无参数信息 包含函数名 + 参数类型 / 个数
符号唯一性 仅靠函数名，无法区分重载 靠 “函数名 + 参数”，可区分重载
设计底层 简洁优先，无重载语义需求 灵活优先，强类型支持重载语义

C 语言的名字修饰规则仅以函数名作为符号标识，无法区分同名不同参数的函数；而 C++ 通过带参数信息的名字修饰，让重载函数生成唯一符号，从而支持重载。

引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量共用同一块内存空间。
比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。

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

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

void Test()
{
   int a = 10;
   int& b = a;//<====定义引用类型
   cout << "a的地址："<< & a << endl;
   cout << "b的地址："<< & b << endl;
}

代码结果：

a的地址：000000F1A93BFB04
b的地址：000000F1A93BFB04

其实此时的a和b都是共用一块内存，共享内存中的数据，就像指针一样

引用特性

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

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

代码结果：

00000035781CF6B4  00000035781CF6B4  00000035781CF6B4

常引用

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;
}

当引用的对象是被const修饰的变量时，那么引用时也要带上const，如果你不带，编译器看来你就是对const的权限放大，这是不被允许的，权限可以在引用时平移、缩小但不能放大

引用的对象如果数据类型不同，不加const会报错，为嘛呢?

因为此时发生了数据类型的隐式转化，12.34被转化成了10，但是此时d的值真的被改变了嘛，没有，d里的值还是12.34，但是为什么最后rd最后接受到的就是12呢？

因为在隐式转化过程中会有一个临时变量，而这个临时变量具有常属性，对于具有常属性的数据，必须带上const

使用场景

做参数

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

相对于C语言中的用指针来解决，在代码的便捷性上，引用的便利性会更好一点，不用带 *

做返回值

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

这是一段正确的引用做返回值的代码

接下来看看这一段

int& Add(int a, int b)
{
   int c = a + b;
   return c;
}
int main()
{
   int& ret = Add(1, 2);
   Add(3, 4);
   cout << "Add(1, 2) is :"<< ret <<endl;
   return 
}

这会输出什么呢？

函数Add在返回c的时候会先将c的数据放到寄存器中，然后将变量c销毁，那么此时返回的

c的地址对于ret来说就是不确定的，用指针的概念来说就是野指针

但是main函数又调用了一次，那么他就会在原来第一次的开辟的函数栈帧位置，在开辟一次函数栈帧，应为刚好是同一个函数，所以有可能会刚好将第一次c变量那个空间，拿来直接用做第二次c变量的空间，那么此时这块空间的数据就会被改变

所以此时打印出来的要么是随机值，要么是7

引用和指针的区别

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

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

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


 
引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

内联函数

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

正常函数在执行的时候，编译器会根据函数名（函数地址）来调用函数，图片里我们可以到在执行到Add(2,3)的时候，编译器执行了call指令，这样直接会跳转到Add函数的定义位置，执行该函数

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用

查看方式：
1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add
2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2013的设置方式)

因为我这里用的是2020VS，所以在2013VS又重新演示了一遍

我们可以清楚地就看到，原本的call汇编指令不见了，是剩下移动和相加指令，说明此时的内联函数已经在编译的过程中替换成了函数体

特性

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

不是你加了inline关键字，编译器就一定认为该函数是内联函数，为什么？

因为inline关键字对编译器只有"建议/提示"（而非强制命令），编译器可以不采纳你的建议，也就是说你虽然写了内联函数，但是编译器可以将他当做普通函数来处理，因为我们知道内联函数的实现过程就是用函数体替换函数调用，在该函数调用的地方生成该函数体，免去了函数调用的系统开销，但是如果你的内联函数的代码量很大或者是一个递归，那该操作就会大大增加你的目标文件的大小，所以你如果想使用内联函数，首先保证你的代码量不能过大，其实该函数不能是一个递归函数

为什么inline声明和定义分离就会导致链接错误报错？

  1. inline函数默认具有外部链接——理论上inline函数地址（符号）是可以被其他.cpp文件找到的，但是有一个前提条件就是他的外部链接的体现，必须是"定义在所有使用该函数的.cpp 编译单元中可见"（.h 文件只是实现 “多编译单元可见” 的载体）
  2. inline函数编译过程无法完成函数体对函数调用的替换——在编译的过程，编译器会先找到inline函数的声明，但是找不到定义，所以编译器就会退而求其次(退而求其次的前提：开启优化时仍无法内联（如 Debug 模式下，即使能看到定义，编译器也可能跳过内联，直接生成 call 指令）)将其当做普通函数来处理，生成call函数名指令，希望可以在链接阶段找到函数（全局符号）地址
  3. C++的ODR规则——ODR在"单定义规则"上对内联函数有豁免条件，内联函数可以"允许多个编译单元（.cpp）拥有完全一致的定义"，也就是在多个.cpp文件中定义相同的内联函数（一定要相同）

--------------------------------------------------------------------------------------------------------------------------

根据上面的三点推出报错的原因：

  • inline函数定义放在了.cpp编译单元，内联函数如果定义在.cpp文件中，那么编译器就会将其降级为内部链接（就像加了static的全局变量），所以此时inline理论上是外部属性，也无法被其他.cpp找到(符号表标记为内部，不进入全局符号)
  • 因为无法被找到，所以在链接的这一步编译器找不到inline函数定义就会报错（call这一步无法执行）
  • ODR规则是对内联函数允许"多个编译单元（.cpp）拥有完全一致的定义"，但是inline定义在单个.cpp文件中，既不符合ODR规定的"单定义规则"（链接找不到地址），也不符合inline的豁免条件(无多编译单元的一致定义)

以上的总总最终触发规则冲突

（这里补充一点，inline函数可以在多个源文件定义名字相同但是函数体不同的内联函数）

因为他们不具备外部属性，也不会进入符号表，所以最后也不会引起冲突

--------------------------------------------------------------------------------------------------------------------------

解决办法：

  • 将定义和声明放在同一个.h文件中
  • 或者在每个.cpp文件中都写入一个一模一样的inline函数

这边推荐第一种

C语言的宏 vs C++的常量定义、内联函数

宏：

优：增强了代码的复用性、提高了性能

缺：不方便调试。（预编译阶段进行了替换）、代码可读性差、可维护性差、容易误用、没有类型完全的检查

常量定义、内联函数：

const enum 替换了C语言中的宏常量定义

可调试的内联函数替换了宏函数

auto关键字（C++11）

这个关键字暂时我们用不上，因为他的作用是根据右边的值来自动给变量的确定类型

typedef和#define的区别

typedef char* pstring;
int main()
{
const pstring p1;    // 编译成功还是失败？
const pstring* p2;   // 编译成功还是失败？
return 0;
}

#define char* pstring;
int main()
{
const pstring p1;    // 编译成功还是失败？
const pstring* p2;   // 编译成功还是失败？
return 0;
}

typedef修饰的char*在编译阶段就会变成char* const p1;此时旁p1地址不改变，但是p1未初始化会报错，为什么会变成char* const p1；

首先const char* p1和char const* p1两者都是一样的，都是保证p1指向的数据不能改变

const只会修饰与自己最近的数据类型也就是char、*，但是如果遇到了pstring（char*）此时const修饰的就是char*这个整体，那么此时const保证的就是char*的数据类型不能变，也就是p1不能变

所以我们看到其实C语言自带的一些语法还是有很大坑的，所以这个时候如果你用auto就没有这么多烦恼啦


auto的使用细则

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导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;
}

auto的使用细则

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;
}

 在同一行定义多个变量

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

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

auto不能推导的场景

auto不能作为函数的参数

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

auto不能直接声明数组

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

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

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

范围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;
}

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

范围for使用的条件

for循环迭代的范围必须是确定的

如果是在函数作为参数穿过来数组就不能直接用for循环迭代，因为传过来的时数组的首元素地址，而这个地址for循环迭代无法确定该数组的范围

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

这就是一个有问题的代码

指针空值nullptr(C++11)

在C++中，给指针赋一个空值我们一般给nullptr，可能大家以前用的就是NULL，但是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。

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

# c++ # 开发语言
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

蚂蚁开源世界模型LingBot-World：具有分钟级记忆的实时世界模拟器

avatar 2048 AI社区
cover

SCI制图——云雨图

avatar 2048 AI社区

识别大模型撒谎：清华首创可解释性大模型幻觉检测

我们已经习惯利用大语言模型处理海量信息，依靠检索增强生成（RAG）等技术来获取基于上下文的连贯回答。但模型常常会生成与给定上下文不一致或完全无关的内容。这种现象被称为忠实度幻觉。对于追求精准的实际应用来说，这是致命的。如何检测这些幻觉至关重要。目前的主流做法是利用GPT-4等强大的通用模型进行二分类判断。这种方法虽然有效，但成本高昂且效率低下，难以在大规模实际场景中部署。另一条路是开发专门的小型检

avatar 2048 AI社区