MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

C++程序启动前的代码执行流程

2021-11-136.5k 阅读

C++ 程序启动前的代码执行流程

预编译阶段

在 C++ 程序真正开始编译之前，首先会经历预编译阶段。预编译处理的主要任务包括宏替换、文件包含和条件编译等。

宏替换

宏定义是 C++ 预处理器的一个重要特性。通过 #define 指令，我们可以定义一个宏，预处理器会在代码中遇到该宏的地方，将其替换为定义的值。例如：

#define PI 3.14159
#include <iostream>
int main() {
    double radius = 5.0;
    double area = PI * radius * radius;
    std::cout << "圆的面积: " << area << std::endl;
    return 0;
}

在这个例子中，预处理器会在编译之前，将代码中所有的 PI 替换为 3.14159。宏定义不仅可以用于定义常量，还可以定义带参数的宏。比如：

#define SQUARE(x) ((x) * (x))
#include <iostream>
int main() {
    int num = 5;
    int result = SQUARE(num);
    std::cout << "5 的平方: " << result << std::endl;
    return 0;
}

这里的 SQUARE(x) 宏在调用时，会将 x 替换为实际传入的参数，并进行相应的计算。不过需要注意，带参数的宏在替换时可能会由于运算符优先级等问题导致意外结果，使用时需要特别小心。

文件包含

文件包含是通过 #include 指令实现的。它允许我们将一个源文件的内容包含到另一个源文件中。C++ 有两种文件包含方式：

  1. 包含系统头文件，使用 <> 符号，例如 #include <iostream>。这种方式告诉预处理器在系统指定的头文件目录中查找头文件。
  2. 包含用户自定义头文件，使用 "" 符号，例如 #include "myheader.h"。预处理器会先在当前源文件所在目录查找该头文件，如果找不到，再到系统头文件目录查找。

以 #include <iostream> 为例，iostream 头文件定义了输入输出流相关的类和函数，如 std::cout 和 std::cin。当预处理器遇到这条指令时，它会将 iostream 头文件的内容插入到当前源文件中 #include 指令所在的位置。这使得我们可以在程序中使用输入输出功能。

条件编译

条件编译允许我们根据不同的条件来决定是否编译某段代码。常用的条件编译指令有 #ifdef、#ifndef、#else 和 #endif。例如：

#define DEBUG
#include <iostream>
int main() {
#ifdef DEBUG
    std::cout << "调试模式开启" << std::endl;
#endif
    std::cout << "程序正常运行" << std::endl;
    return 0;
}

在这个例子中，通过定义 DEBUG 宏，#ifdef DEBUG 和 #endif 之间的代码会被编译。如果没有定义 DEBUG 宏，这部分代码将不会被编译。条件编译在开发过程中非常有用，比如在调试阶段添加一些调试信息，而在发布版本中去除这些信息，从而减少代码体积和提高运行效率。

编译阶段

经过预编译处理后的代码，进入编译阶段。编译的主要任务是将预处理后的代码翻译成汇编代码。编译器会对代码进行词法分析、语法分析、语义分析以及代码优化等操作。

词法分析

词法分析器将输入的源程序字符串按照词法规则分割成一个个单词（token）。例如，对于代码 int num = 5;，词法分析器会将其识别为 int（关键字）、num（标识符）、=（运算符）、5（常量）和 ;（界符）等单词。词法分析是编译的基础，它为后续的语法分析提供输入单元。

语法分析

语法分析器基于词法分析得到的单词序列，按照语法规则来构建语法树。以 int num = 5; 为例，语法分析器会构建一棵反映该语句语法结构的语法树。根节点可能是一个赋值语句节点，其左子节点是变量声明节点（包含 int num 信息），右子节点是常量节点（值为 5）。语法分析的作用是检查代码是否符合 C++ 的语法规则，如果代码存在语法错误，语法分析阶段会检测出来并给出相应的错误信息。

语义分析

语义分析在语法分析的基础上，检查代码的语义是否正确。例如，检查变量是否在使用前声明、函数调用时参数类型和个数是否匹配等。对于代码 int num; num = "hello";，虽然语法上没有错误，但语义上存在问题，因为不能将字符串赋值给整型变量。语义分析器会检测到这种错误，并给出提示。语义分析确保代码在逻辑上是合理的，为后续生成正确的目标代码奠定基础。

代码优化

编译器在生成汇编代码之前，通常会对代码进行优化。优化的目的是提高代码的执行效率和减少代码体积。优化可以分为多个层次，例如：

  1. 局部优化：在基本块（一段顺序执行，没有分支和跳转的代码）内进行优化，如常量折叠。对于代码 int result = 3 + 5;，编译器可以在编译时直接计算出 3 + 5 的结果为 8，从而将代码优化为 int result = 8;。
  2. 全局优化：考虑整个函数或程序的优化，如公共子表达式消除。对于代码 int a = b + c; int d = b + c;，编译器可以识别出 b + c 是公共子表达式，将其计算结果保存起来，避免重复计算，优化后的代码可能变为 int temp = b + c; int a = temp; int d = temp;。

汇编阶段

编译阶段生成的汇编代码，在汇编阶段会被汇编器翻译成目标机器的机器语言指令，生成目标文件（通常是 .obj 文件，在 Linux 下是 .o 文件）。汇编语言是一种低级语言，与目标机器的指令集紧密相关。例如，对于 x86 架构的处理器，以下是一段简单的汇编代码示例：

; 计算 5 + 3 并将结果存储在 eax 寄存器中
mov eax, 5
add eax, 3

mov 指令将值 5 移动到 eax 寄存器，add 指令将 3 加到 eax 寄存器中的值上。汇编器会将这些汇编指令翻译成对应的机器码。每个汇编指令都有对应的机器码表示，不同的处理器架构其机器码格式和指令集都有所不同。

链接阶段

链接的主要任务是将各个目标文件以及所依赖的库文件链接成一个可执行文件。在链接过程中，会解决目标文件之间的符号引用问题。

符号解析

在编译过程中，每个源文件可能会定义一些符号（如函数和变量），同时也可能引用其他源文件中定义的符号。例如，有两个源文件 main.cpp 和 func.cpp：

// main.cpp
#include <iostream>
extern void myFunction();
int main() {
    myFunction();
    return 0;
}

// func.cpp
#include <iostream>
void myFunction() {
    std::cout << "这是 myFunction" << std::endl;
}

在 main.cpp 中，myFunction 是一个外部符号引用，而在 func.cpp 中定义了 myFunction。链接器在链接时，会将 main.cpp 中对 myFunction 的引用与 func.cpp 中 myFunction 的定义关联起来，这就是符号解析的过程。如果链接器找不到某个符号的定义，就会报链接错误。

重定位

目标文件中的地址通常是相对地址，因为在编译时并不知道最终可执行文件在内存中的加载地址。链接器在链接过程中，会对目标文件中的指令和数据的地址进行调整，使其能够在可执行文件加载到内存后正确运行，这个过程称为重定位。例如，假设一个函数在目标文件中的相对地址是 0x100，而在链接后的可执行文件中，其加载地址变为 0x10000，链接器会将所有对该函数的引用地址从 0x100 调整为 0x10000。

库链接

C++ 程序通常会依赖一些标准库或第三方库。链接器在链接时需要将这些库文件中的代码和数据链接到可执行文件中。库分为静态库和动态库。

  1. 静态库：在链接时，静态库中的代码会被完整地复制到可执行文件中。例如，使用静态链接的 libstdc++.a（GCC 的 C++ 标准库静态版本），会将库中的所有相关函数和数据结构的代码都合并到可执行文件中。这样生成的可执行文件体积较大，但运行时不需要依赖外部库文件。
  2. 动态库：动态库在链接时，只是在可执行文件中记录对动态库的引用信息，而不是将动态库的代码复制到可执行文件中。在程序运行时，操作系统会负责加载动态库，并将其映射到进程的地址空间中。例如，Windows 下的 DLL 文件和 Linux 下的 .so 文件就是常见的动态库形式。使用动态库可以减少可执行文件的体积，并且多个程序可以共享同一个动态库，节省内存空间。

运行时初始化

当可执行文件生成后，在程序真正开始执行 main 函数之前，还会进行一系列的运行时初始化操作。

全局变量和静态变量的初始化

全局变量和静态变量在程序启动时会被初始化。全局变量又分为已初始化的全局变量和未初始化的全局变量。已初始化的全局变量，例如 int globalVar = 5;，其初始化值会被存储在可执行文件的数据段中。在程序启动时，系统会将数据段中的值加载到内存中对应的变量位置。未初始化的全局变量，例如 int uninitGlobalVar;，会被存储在 BSS（Block Started by Symbol）段中，在程序启动时，系统会将 BSS 段清零，从而完成对未初始化全局变量的默认初始化。

静态变量在函数内部或类中声明时，其初始化过程与全局变量类似。例如：

class MyClass {
public:
    static int staticVar;
};
int MyClass::staticVar = 10;

void myFunction() {
    static int localVar = 20;
}

MyClass::staticVar 和 localVar 都会在程序启动时或首次进入包含它们的函数时被初始化。

构造函数的调用

对于全局对象和静态对象，其构造函数会在程序启动时被调用。例如：

class MyObject {
public:
    MyObject() {
        std::cout << "MyObject 构造函数被调用" << std::endl;
    }
};
MyObject globalObject;

void myFunction() {
    static MyObject staticObject;
}

globalObject 的构造函数会在程序启动时立即被调用，而 staticObject 的构造函数会在首次进入 myFunction 函数时被调用。这确保了对象在使用之前已经被正确初始化。

线程局部存储（TLS）的初始化

如果程序使用了线程局部存储（通过 __thread 关键字在 GCC 中，或 __declspec(thread) 在 Visual C++ 中声明变量），在每个线程启动时，会对线程局部变量进行初始化。例如：

#include <iostream>
#include <thread>
__thread int threadLocalVar = 0;
void threadFunction() {
    threadLocalVar = std::this_thread::get_id().hash_code();
    std::cout << "线程 " << std::this_thread::get_id() << " 的 threadLocalVar: " << threadLocalVar << std::endl;
}
int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    t1.join();
    t2.join();
    return 0;
}

在这个例子中，每个线程都有自己独立的 threadLocalVar 副本，并且在各自线程启动时进行初始化。

入口点和运行环境设置

在完成上述一系列初始化操作后，程序会进入入口点。在 C++ 程序中，入口点通常是 main 函数。

启动代码

在调用 main 函数之前，会执行一段启动代码。启动代码的具体实现依赖于操作系统和编译器。它的主要任务包括初始化运行时环境，如设置栈、堆等内存区域，初始化 C 运行时库（CRT）等。例如，在 Windows 下，启动代码会负责初始化进程的环境变量、加载动态链接库等操作。在 Linux 下，启动代码会设置程序的参数和环境变量，为 main 函数的执行做好准备。

运行环境设置

运行环境设置包括初始化标准输入输出流（std::cin、std::cout 和 std::cerr），设置信号处理函数等。标准输入输出流在程序启动时会被关联到操作系统的标准输入输出设备（通常是键盘和显示器）。信号处理函数的设置使得程序能够响应各种系统信号，如 SIGINT（通过 Ctrl+C 产生），可以在程序中注册相应的信号处理函数来处理这些信号。例如：

#include <iostream>
#include <csignal>
void signalHandler(int signum) {
    std::cout << "捕获到信号 " << signum << std::endl;
    // 执行清理操作或其他处理
}
int main() {
    std::signal(SIGINT, signalHandler);
    std::cout << "按 Ctrl+C 发送 SIGINT 信号" << std::endl;
    while (true) {
        // 程序主体
    }
    return 0;
}

在这个例子中，通过 std::signal 函数注册了 SIGINT 信号的处理函数 signalHandler，当程序接收到 SIGINT 信号时，会调用 signalHandler 函数进行处理。

总结

C++ 程序从源文件到最终运行，经历了预编译、编译、汇编、链接以及运行时初始化等多个阶段。每个阶段都有其特定的任务和作用，它们紧密协作，确保程序能够正确地生成和运行。深入理解这些流程，对于优化代码、解决编译和链接错误以及编写高效稳定的程序具有重要意义。无论是在开发小型应用程序还是大型复杂系统时，对程序启动前执行流程的掌握都能帮助开发者更好地控制和管理代码。例如，在处理复杂的库依赖关系时，了解链接过程可以帮助我们正确配置项目；在优化代码性能时，熟悉编译优化技术可以让我们编写更易于优化的代码。同时，对运行时初始化的理解有助于我们正确处理全局变量和对象的初始化，避免潜在的错误。总之，对 C++ 程序启动前代码执行流程的深入了解是成为一名优秀 C++ 开发者的必备知识。