在学习之前我们必须先要知道C和C++的关系，C++是在C的基础上，容纳进去了面向对象的思想，并增加了许多有用的库，这就说明，以前我们敲的那些轮子，现在可以直接调用库实现，当然还在此基础上增加了一些东西，接下来的文章让我们一起来了解。

1.命名空间

   1.1什么是命名空间，有什么作用?

      简单来说命名空间就是为了解决大量在全局作用域中的函数，变量，类的命名冲突问题而产生的，用关键词namespace来定义。

      以下是命名空间的使用方式:

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

   1.2命名空间的性质

    (1)命名空间可以嵌套，看到这里你会不会思考为什么要进行命名空间的嵌套?

     ①表达逻辑层次和代码组织（最主要的原因）

            这是嵌套命名空间最常用、最直观的用途。它允许你将相关的功能分组到更深的层次中，从而清晰地表达代码之间的所属关系。例如

// 定义一个顶级命名空间代表整个游戏项目
namespace MyGame {

    // 嵌套命名空间：处理图形渲染的所有模块
    namespace Graphics {
        class Mesh { ... };
        class Shader { ... };
        namespace API { // 进一步嵌套：抽象不同的图形API
            class DirectX11Renderer { ... };
            class OpenGLRenderer { ... };
        }
    }

    // 嵌套命名空间：处理游戏逻辑的所有模块
    namespace Core {
        class GameObject { ... };
        class Component { ... };
    }

    // 嵌套命名空间：处理音频的模块
    namespace Audio {
        class Sound { ... };
        class MusicTrack { ... };
    }
}

// 使用时的代码非常清晰，表明了所属的模块
MyGame::Graphics::Mesh* mesh;
MyGame::Graphics::API::OpenGLRenderer* renderer;
MyGame::Core::GameObject player;

②防止命名冲突（Encapsulation）

       嵌套命名空间提供了一个更强大的封装屏障。两个同名的类可以存在于不同的嵌套命名空间中而不会冲突。
③实现细节的隐藏（Information Hiding）

      将实现细节放在更深的嵌套命名空间中，是一种向用户暗示“这些是内部实现，你不应该直接使用”的有效方式。常见的做法是使用一个名为 `detail` 或 `internal` 的嵌套命名空间。

  1.3命名空间的三种使用方式

  (1)加命名空间名称以及作用域限定符

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

}

(2)使用using将命名空间中的某个成员变量引入

using N::b;
int main()
{
   printf(“%d”,b);
   return 0;
}

这里的using是什么呢? 首先using是C++中的关键词，它的作用有以下5个:

①引入命名空间成员：
    using std::cout; (引入单个成员)
    using namespace std;(引入整个命名空间 - 需谨慎使用)

②创建类型别名 (替代 typedef)：
    using StringVector = std::vector<std::string>;

③ 在类继承中引入基类成员(解决名称隐藏问题)：
    class Derived : private Base { using Base::someFunction; };

④ 别名模板 (typedef无法实现的功能)：
    template<typename T> using MyAllocVector = std::vector<T, MyAlloc<T>>;

⑤命名空间别名：
    namespace fs = std::filesystem;

(3) 使用using namespace 直接将命名空间名称引用

using namespace N;
int main()
{
   printf("%d",N::a);
   printf("%d",b);  //引用了命名空间名称，想要得到成员这俩种方式都可

}

2.C++的输入输出

 下面我们直接用代码看一下

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

3.缺省参数

3.1什么是缺省参数?

    在定义和声明函数的时候，为函数的参数指定一个缺省值，这个就叫做缺省参数，如果没有给函数的参数定义值，就用这个缺省参数。

void Fun (int a=10)
{
    cout<<a<<endl;
}

int main()
{
   Fun();//这里就是没有给参数传值，就用上面的缺省值10
   Fun(29);//这里传值了，就用传的值29
   return 0；
}

3.2缺省参数分类

  (1) 全缺省参数

   顾名思义，均未传参，全部使用缺省值；

  (2)半缺省参数

   有的用了缺省值，有的自己定义了；

   值得注意的是:

    ①半缺省参数必须从右往左依次的给出，不能间隔着给；

    ②缺省参数不能在定义和声明的时候同时给出；

    ③缺省参数必须是常量或者全局变量；

   这里有没有人好奇为什么要使用常量和全局变量? 为什么不能使用局部变量，或者可变变量?

        因为 ①局部变量(在函数内的变量)的生命周期只在函数执行期间。当函数调用结束，局部变量就可能被销毁了。如果默认参数依赖于一个可能不存在的局部变量，那函数在调用时就会找不到它，导致错误。②可变对象（如列表、字典）—— 最大的陷阱！这是一个著名的“坑”。虽然语法上允许，但强烈不推荐将可变对象作为默认值。原因：默认值对象在函数定义时只创建一次，之后所有调用都会共享同一个对象。

4.函数重载

   4.1什么是函数重载?

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

    C++ 中，函数重载只看 函数名 和 参数的类型、个数、顺序，与返回类型无关。
所以只要同名，并且参数列表不同，就是重载。

#include<iostream>
using namespace std;
// 1、参数类型不同
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;
}
// 2、参数个数不同
void f()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << endl;
}
// 3、参数类型顺序不同
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;
}
int main()
{
Add(10, 20);
Add(10.1, 20.2);
f();
f(10);
f(10, 'a');
f('a', 10);
return 0;
}

4.2 C++支持函数重载的底层逻辑

       C++通过名称修饰（Name Mangling）实现函数重载。编译器会将函数名、参数类型和数量等信息编码生成一个唯一的内部标识符。这样即使函数原名相同，只要参数列表不同，编译后的实际函数名就不同，链接器就能正确区分和调用对应的函数版本。

5.引用

5.1引用的概念

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

5.2引用的使用

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

int main()
{
   int a=0;
   int & ar=a; //这里的ar就是给a取的别名
   return 0;

}

  注意:  (1)引用类型必须和引用实体类型相同

            (2)引用在定义前必须初始化；

            (3)一个变量可以有多个引用；

            (4)一个引用只能引用一个实体；

5.3引用和指针的区别

    (1) 引用概念上定义一个变量的别名，指针存储一个变量地址。

    (2) 引用在定义时必须初始化，指针没有要求

    (3) 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何      一个同类型实体

    (4) 没有NULL引用，但有NULL指针

    (5) 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32      位平台下占4个字节)

    (6) 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

    (7)有多级指针，但是没有多级引用

    (8)访问实体方式不同，指针需要显式解引用，引用编译器自己处理

    (9)引用比指针使用起来相对更安全

6.内联函数

6.1什么是内联函数

     内联函数是C++中用 inline 关键字建议编译器进行优化的函数。其核心目的是消除函数调用的开销（如压栈、跳转、返回等操作）。编译时，编译器会选择性地将函数调用处直接替换为函数体的代码副本，从而提升执行速度。这是一种以牺牲程序体积（空间）来换取运行效率（时间）的策略，常用于短小且频繁调用的函数。

6.2使用内联函数的注意事项

       (1)适用场景：仅适用于函数体短小、逻辑简单且被频繁调用的函数。对于包含循环、递归或代码量大的函数，内联会导致代码膨胀，反而可能降低性能。

       (2)编译器决定权：inline 只是一个对编译器的建议，而非命令。编译器会根据函数复杂度、当前优化选项等自行决定是否真正内联。

       (3)头文件定义：内联函数的（完整）定义通常必须放在头文件中。因为编译时需要在每个调用处展开，所有使用该函数的源文件都必须能看到其定义。

// F.h
#include <iostream>
using namespace std;
inline void f(int i);  //声明和定义不建议分开
// F.cpp
#include "F.h"
void f(int i)
{
 cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
 f(10);
 return 0;
}

       (4)调试限制：内联函数在展开后不再存在独立的函数调用，因此可能会给调试（如设置断点、跟踪调用栈）带来一些困难。

  7.auto关键词

      auto是C++11引入的关键字，用于自动类型推导。它的作用是让编译器根据变量初始化时的赋    值符号右边的值，自动推断出该变量的合适类型。这样写代码时就不用显式写出冗长的类型（如   迭代器类型），既能简化代码，又能避免写错类型，让程序更灵活清晰。它让编译器帮你写类   型。

7.1auto 的使用细则

      (1)必须初始化：auto 变量定义时必须直接赋值，编译器靠初始值来猜类型。

      (2)忽略引用和const：默认会忽略初始值的引用和常量属性，若需保留要手动加 & 或 const（如 const auto&）。

      看到这点是不是不太理解?没事让我来简单的解释一下

      核心原则：auto 的推导规则和模板参数推导几乎一致，它推导的是对象的类型，而不是修饰词。

      比如说:

假设我们有一个被 const 和引用修饰的原始变量：

const int& original_value = 10; //这里的给常量进行引用可以赋予常量和引用一样的生命周期

现在我们想用 auto来创建一个新变量 new_value，并用它来接收 original_value。

auto new_value = original_value;

但是这里编译器只会推导出是int类型。

如果只加 & 符号，结果是new_value_ref 是 original_value 的一个别名（引用），并且因为原对象是 const 的，所以通过 new_value_ref 也不能修改其值。它们指向同一个内存地址。

如果将 const &都加上，编译器的逻辑是:
      ①你明确指定了 const 和 &。
      ②它会将 original_value 的类型 const int& 完美地应用到这个新变量上。
      ③最终，new_value_const_ref 的类型就是 const int&。
结果：new_value_const_ref 是 original_value 的一个不可修改的引用别名。这是一种“安全模式”，避免了不必要的拷贝，也不会意外修改原值。

(3)保持简洁：适合简化复杂类型（如迭代器、lambda表达式），但基础类型（如 int）建议直接声明，代码更清晰。

8.范围for

8.1什么是范围for?

    范围 for 循环是 C++11 引入的语法糖，用于快速遍历容器或序列中的所有元素。

                            其格式为：for (元素类型 变量名 : 容器)
   编译器会自动处理迭代器的begin()和end()，依次取出每个元素。它比传统for循环更简洁安全，     避免了操作迭代器的麻烦，是遍历容器的首选方式。

8.2范围for的使用

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    // 范围for循环：依次取出numbers中的每个元素，赋值给num
    for (int num : numbers) {
        std::cout << num << " ";
    }
    // 输出: 1 2 3 4 5
    
    return 0;
}

    更加现代的用法

for (auto num : numbers) {  // auto自动推导元素类型
    std::cout << num << " ";
}

    如果需要修改则需要加上&(引用)

for(auto & num: number)
{
   num*=2;
}

   9.nullptr

   9.1什么是nullptr?

    nullptr 是 C++ 中专门用来表示空指针的关键字。你可以把它想象成一个通用的“空钥匙”，能打开任何类型的指针“锁”（比如 int*、char* 等），表示这把锁目前没有锁任何东西。它彻底取代了老式的 NULL（本质是数字0），避免了在函数重载时可能引发的混乱，让代码更安全、更清晰。它的类型是 std::nullptr_t。

9.2注意事项

(1) 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。

(2) 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
(3)为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

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

 10.名词解释

   语法糖  :这个名字是一个非常巧妙且形象的比喻，它来自于计算机科学之父之一——彼得·兰丁。
这个名字可以从两个层面来理解：
   1. 核心比喻：让“苦”药变“甜”
“语法”：指的是编程语言的规则和写法，是程序员必须遵守的“药物”。
“糖”：指的是让这种写法变得更可口、更易接受的“调味剂”。
早期的编程语言语法有时非常繁琐、原始，甚至有些“苦涩”（难以书写和阅读）。语法糖的发明，就是给这些必要的、但有些“苦”的语法裹上一层甜甜的糖衣，让它变得更容易“下咽”（编写和理解）。
就像小朋友不爱吃药，但如果把药粉混在糖浆里，他就愿意吃了。语法糖就是代码世界的“糖浆”。
      2.深层含义：只有味道改变，本质不变
这也是这个名字最精妙的地方：你吃了糖，但吃到肚子里的药效并没有改变。
同样地：
你写了更甜的语法（比如范围for循环）。
但编译器“吃”下去之后，会把它消化（编译）成原本那个更底层、更“苦”的形式（比如传统的for循环与迭代器）。
程序的最终执行逻辑和功能没有任何改变，改变的只是你作为程序员的编写体验。
一个简单的例子：
“苦”药（基础语法）：
cpp
// 传统的遍历方式，需要手动处理迭代器，比较繁琐
for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << std::endl;
}
“糖衣”（语法糖）：
cpp
// 范围for循环，简洁明了，专注于元素本身
for (int element : vec) {
    std::cout << element << std::endl;
}
编译器会把下面甜甜的“糖”还原成上面那段“苦”药来执行。对你来说，体验变甜了；对机器来说，任务照旧。
所以，“语法糖”这个名字完美地捕捉到了其改善开发者体验而不改变语言功能的精髓，是一个既可爱又准确的术语。