往篇内容：

 C++学习笔记（一）
        一、C++编译阶段※

        二、入门案例解析 

        三、命名空间详解

        四、C++程序结构

C++学习笔记（二）

        五、函数基础

        六、标识符

        七、数据类型

        补充：二进制相关的概念

                  sizeof 运算符简介

        补充：原码、反码和补码

C++学习笔记（三）

        补充：ASCII码表

        八、内存构成

         补充：变量

        九、指针基础 

        十、const关键字

        十一、枚举类型 

C++学习笔记（四）

        十二、 类型转换

        十三、define指令 

        十四、typedef关键字

        十五、运算符

        十六、 流程控制

C++学习笔记（六）

        十七、数组

C++学习笔记（七）

        十八、指针

目录

 十九、函数进阶

1、内联函数

2、函数重载 

3、缺省函数

4、递归调用

 经典案例1：计算阶乘！

案例2：斐波那契数列（Fibonacci Sequence）

案例3：汉诺塔（Tower of Hanoi）

补充：尾递归

案例1：尾递归阶乘

案例2：尾递归斐波那契

二十、变量进阶

1、作用域

1.1 局部变量

1.2 全局变量 

 2、存储类型

🧩 2.1 auto

🧩 2.2 register

🧩 2.3 static

①局部静态变量

 ②全局静态变量

3、链接属性

4、内部函数

 十九、函数进阶

1、内联函数

        在 C++ 中，内联函数（inline function） 是一种优化机制，用来减少函数调用的开销。通常情况下，函数调用会有一些运行时开销：比如参数压栈、跳转到函数地址等。

        为了提高效率，对于一些短小精悍、频繁调用的函数，我们可以将其声明为inline ，这样编译器就会尝试将该函数的代码直接插入到调用处，而不是进行常规的函数调用。

定义格式：

inline 返回类型 函数名(参数列表) {

// 函数体

}

作用与优点：

 与宏函数的区别（#define）

结论：在 C++ 中，应尽量避免使用宏函数，改用 inline 函数来替代！ 

注意事项：

• 声明和定义必须在一起，通常在头文件中定义并实现
• 内联函数的建议性的，不是强制性的，编译时函数嵌入
• 内联函数一般功能简单，频繁调用，代码量5行以内
• 如果函数太复杂（例如包含循环、递归、静态变量等），编译器可能不会将其内联
• 如果修改了内联函数体里面内容，则必须要重新编译链接才可以起作用

应用场景：

• 函数非常简单（如取绝对值、加减乘除）
• 函数被频繁调用（如类的 getter/setter 方法）
• 性能敏感区域（如游戏引擎、图形库）

2、函数重载 

        C++中函数重载（Function Overloading） 是指在同一作用域中可以有多个同名函数，但它们的参数列表不同（参数个数或类型不同）。编译器会根据调用时传递的参数来决定调用哪一个函数。

基本语法：

返回类型 函数名(参数列表1) { ... }

返回类型 函数名(参数列表2) { ... }

...

案例：

#include <iostream>
using namespace std;// 函数重载示例
int add(int a, int b) {return a + b;
}double add(double a, double b) {return a + b;
}int add(int a, int b, int c) {return a + b + c;
}int main() {cout << "add(3, 4) = " << add(3, 4) << endl;       // 调用第一个add函数cout << "add(3.5, 4.2) = " << add(3.5, 4.2) << endl; // 调用第二个add函数cout << "add(1, 2, 3) = " << add(1, 2, 3) << endl;   // 调用第三个add函数return 0;
} 

编译器判断函数是否构成重载的因素 

返回值类型不同就不可重载吗？

        答：是的，仅返回值类型不同不能构成函数重载。函数重载的核心是参数列表必须不同（参数数量、类型或顺序不同），而返回值类型不参与重载的判断。

为什么？

        因为 C++ 编译器根据调用时提供的参数来决定调用哪个重载函数，而不是根据返回值类型。例如：

add(3, 4); // 编译器如何知道该调用 int 还是 double 版本？

此时编译器无法通过返回值类型区分，因此会报错。

总结

情况	示例	是否重载？
参数列表相同，仅返回值不同	int add(int, int) double add(int, int)	❌ 不构成重载（编译错误）
参数列表不同，返回值可相同或不同	int add(int, int) double add(double, double)	✅ 构成重载

 底层机制

函数重载是静态多态的一种形式，也称为编译时多态（后续会讨论）。它是由编译器在编译阶段完成的：

• 编译器根据函数名和参数列表生成不同的内部符号（name mangling）
• 在链接阶段，链接器会找到正确的函数地址

例如，两个重载函数：

3、缺省函数

基本语法： 

返回类型 函数名(参数类型 参数名 = 默认值, ...) {

// 函数体

}

案例：

#include<iostream>
using namespace std;void greet(string name="Guest")
{cout<<"Hello,"<<name<<"!"<<endl;
}int main()
{greet();//使用默认参数greet("Alice");//传递参数return 0;
}//输出：Hello,Guest   Hello,Alice

• 缺省参数必须放在参数列表的最后面
• 也就是说：一旦某个参数有默认值，它后面的所有参数也必须有默认值

//正确写法

void func(int a, int b = 10, int c = 20);

//错误写法

void func(int a = 5, int b, int c); // 错误：a 之后的参数没有默认值

缺省参数作用域与可见性：

• 缺省参数通常在函数声明中给出（头文件中）

• 函数定义中不再重复指定缺省值

• 如果在定义中给缺省值，在声明中就不应该再给（否则会冲突）

 注意：当函数即作为重载函数，又有默认参数时，注意不要产生二义性。

 错误案例：

#include <iostream>
using namespace std;// 函数1：带缺省参数的版本
void display(int a, int b = 10) {cout << "display(" << a << ", " << b << ")" << endl;
}// 函数2：单参数版本（与函数1冲突）
void display(int a) {cout << "display(" << a << ")" << endl;
}int main() {display(5); // 编译错误：二义性调用return 0;
}    

 经典案例1：计算阶乘！

#include <iostream>
using namespace std;
int factorial(int n) {if (n == 0 || n == 1) { // 递归终止条件return 1;}return n * factorial(n - 1); // 递归调用
}
int main() {int num;cout << "请输入一个整数：";cin >> num;cout << num << "! = " << factorial(num) << endl;return 0;
}

案例2：斐波那契数列（Fibonacci Sequence）

#include <iostream>
using namespace std;int fibonacci(int n) {if (n == 0) return 0;if (n == 1) return 1;return fibonacci(n - 1) + fibonacci(n - 2);
}int main() {int n;cout << "请输入斐波那契数列的项数：";cin >> n;for (int i = 0; i < n; ++i)cout << fibonacci(i) << " ";cout << endl;return 0;
}

案例3：汉诺塔（Tower of Hanoi）

#include <iostream>
using namespace std;/*** 汉诺塔问题解决方案* 将n个盘子从source柱子，借助auxiliary柱子，移动到target柱子* @param n 盘子数量* @param source 源柱子* @param auxiliary 辅助柱子* @param target 目标柱子*/
void hanoi(int n, char source, char auxiliary, char target) {if (n == 1) {cout << "Move disk 1 from " << source << " to " << target << endl;return;}// 步骤1：将n-1个盘子从源柱子移动到辅助柱子hanoi(n - 1, source, target, auxiliary);// 步骤2：将最大的盘子从源柱子移动到目标柱子cout << "Move disk " << n << " from " << source << " to " << target << endl;// 步骤3：将n-1个盘子从辅助柱子移动到目标柱子hanoi(n - 1, auxiliary, source, target);
}int main() {int n;cout << "请输入汉诺塔的盘子数量：";cin >> n;hanoi(n, 'A', 'B', 'C');return 0;
}  

递归优缺点

✅ 优点：

• 代码简洁清晰；
• 更符合某些问题的自然逻辑；
• 易于实现复杂的数据结构操作（如树、图等）；

 2种递归对比：

注意：

• 并非所有递归都可以写成尾递归
• 不同编译器对尾递归优化的支持程度不同
• 使用 -O2 或 -O3 编译选项可以启用尾递归优化

二十、变量进阶

1、作用域

• 文件作用域
  也称为全局作用域，在任何函数、类或命名空间之外声明的变量具有文件作用域

 void func(int param); // param 在这里是函数原型作用域

• 函数作用域
  goto 标签是唯一具有函数作用域的实体，意味着标签名称在整个函数体内都是有效的，

void func() {

        goto label;

        label: //标签可以放置在函数内的任何位置，但必须在函数范围内使用

        cout << "Jumped to label" << endl;

}

• 类作用域（Class Scope）
  成员变量和函数属于其类的作用域，后续类和对象再讨论！
  • 命名空间作用域（Namespace Scope）
    命名空间内的名字具有命名空间作用域，例如：

    namespace MySpace {

        int var = 10;

    }

    int main() {

        cout << MySpace::var << endl; // 使用命名空间限定符访问变量

    }

1.1 局部变量

        在一个函数内部定义的变量是内部变量，它只在本函数范围内有效。也就是说只有在本函数内才能使用它们，在此函数以外是不能使用这些变量的。

        同样，在复合语句中定义的变量只在本复合语句范围内有效。

上面两种都称为局部变量 (local variable)。具体可见下图：

 注意：函数声明和函数定义中的形式参数，相互独立！

1.2 全局变量 

        在函数内定义的变量是局部变量，而在函数之外定义的变量是外部变量，称为 全局变量 (global variable,也称全程变量)。全局变量的有效范围为从定义变量的位置开始到本源文件结束。

 2、存储类型

        在 C++ 中，存储类型（Storage Class）决定了变量的生命周期、可见性（作用域）以及是否可以被初始化等特性。C++ 中主要有4种存储类型： auto 、register 、 static 和 extern 。每种存储类型都有其特定的应用场景和特点。

⚪存储类型：存储变量值的内存类型
⚪决定了变量的创建时间、销毁时间、值的生命周期
⚪普通内存、运行时堆栈、硬件寄存器

⚪存储类型：

• 静态变量：代码块之外或则代码块内部并用 static 修饰

• 自动变量：代码块内部并且不使用 static

• 寄存器变量：使用 register 修饰的自动变量

⚪生命周期并不等同于存储类型

⚪初始化

• 静态变量有默认初始化值 0

• 自动变量没有默认初始化

🧩 2.1 auto

• 默认存储类型：对于局部变量，默认即为 auto 类型。
• 作用域与生命周期：具有块作用域（Block Scope），从声明点开始直到包含它的最内层代码块结束；生命周期从进入作用域时开始，离开作用域时结束。
• 使用情况：自 C++11 起， auto 关键字更多地用于自动类型推导，而不是传统的存储类型指定。

void autoExample() {

auto x = 5; // 自动类型推导，x 是 int 类型

}

🧩 2.2 register

• 意图优化：建议编译器将变量存储在寄存器中以提高访问速度，但现代编译器通常会自动进行这种优化，因此很少显式使用 register
• 寄存器变量：为提高执行效率， C++允许将局部变量的值放在CPU中的寄存器中，需要用时直接从寄存器取出参加运算，不必再到内存中去存取。

🧩 2.3 static

①局部静态变量

在函数内使用 static 修饰变量时，其存储类型会由栈空间修改为数据区（初始化或未初始化）。它只会在第一次执行到它的初始化语句时初始化一次，并且它的值会保留直到程序结束，即使函数多次被调用也不会重新初始化。

#include <iostream>
using namespace std;int f(int a) {auto b = 0;// 只初始化一次，存储在初始化数据区，函数帧销毁，c 不会销毁static int c = 3; b = b + 1;  // 每次调用 b 重新从 0 加 1c = c + 1;  // c 静态变量，值持续累加，依次为 4、5、6 return a + b + c;
}int main() {int a = 2;// 调用 3 次 f 函数for (int i = 0; i < 3; i++) {// 第一次：2 + 1 + 4 = 7// 第二次：2 + 1 + 5 = 8// 第三次：2 + 1 + 6 = 9 cout << f(a) << " "; }cout << endl;return 0;
}

 ②全局静态变量

        在程序设计中希望某些外部变量只限于被本文件引用，而不能被其他文件 引用。这时可以在定义外部变量时加一个 static声明。

总结：

3、链接属性

• 标识符的链接属性（linkage）用于决定如何处理在不同文件中出现的标识符，主要有 external、internal、none 三种 。

三种链接属性具体说明

1. None（无链接属性）：带有这种链接属性的标识符，总是被当作单独的个体，各声明相互独立，不关联其他位置的同名标识符 。

2. Internal（内部链接属性）：在同一个源文件内，所有对该标识符的声明都指向同一个实体；但在不同源文件中，同名标识符的声明会被视为不同实体，相互独立 。

3. External（外部链接属性）：无论标识符被声明多少次、分布在几个源文件中，都表示同一个实体，可跨源文件关联使用 。

• 链接属性：声明一个变量或函数，告诉编译器该标识符是在其他地方定义的
• 用途：主要用于多文件编程中，允许在一个文件中引用另一个文件中定义的全局变量或函数

// file1.cpp

int globalVar = 10;

// file2.cpp

extern int globalVar; // 声明 globalVar 存在于其他文件中

• 函数声明：通常省略 extern ，因为它是函数声明的默认存储类型 

4、内部函数

如果一个函数只能被本文件中其他函数所调用，它称为内部函数，在定义函数时用 static 修饰。

格式： static 返回值类型 函数名(形参列表); 如： static int fun(int a, int b); 内部函数也称为静态(static)函数。

如果在不同的文件中有同名的内部函数，互不干扰。

static关键字总结

•  static 用于函数定义或则用于代码块之外的变量声明时，static 关键字用于修改标识符的链接属性，从 external 修改为 internal。修改标识符的存储类型和作用域。

• static 用于代码块内部的变量声明时，static 用于修改变量的存储类型，从自动变量修改为静态变量。变量的链接属性和作用域不受影响。