【C语言】全面系统讲解 `#pragma` 指令:从基本用法到高级应用

全面系统讲解 #pragma 指令:从基本用法到高级应用

在 C 和 C++ 编程中,#pragma 是一个预处理指令,用来给编译器提供一些特殊的指示。它通常用于调整编译行为、控制特定编译器的优化、内存对齐以及防止头文件的重复包含等。不同的编译器可能支持不同的 #pragma 指令,且它们的语法和行为可能会有所差异。

本文将从基础到高级全面讲解常见的 #pragma 指令,逐一介绍它们的用法、实现原理、编译器支持情况,并通过代码示例和注释帮助读者深入理解。

目录

  • [**全面系统讲解 `#pragma` 指令:从基本用法到高级应用**](#pragma` 指令:从基本用法到高级应用**)
    • [**常见 `#pragma` 指令总结**](#pragma` 指令总结**)
    • [**编译器对 `#pragma` 指令的支持情况**](#pragma` 指令的支持情况**)
    • [**1. `#pragma once`**](#pragma once`**)
    • [**2. `#pragma pack`**](#pragma pack`**)
      • [**2.1 基本语法**](#2.1 基本语法)
      • [**2.2 示例讲解**](#2.2 示例讲解)
        • [**2.2.1 设置对齐方式**](#2.2.1 设置对齐方式)
        • [**2.2.2 使用 `push` 和 `pop`**](#2.2.2 使用 pushpop)
        • [**2.2.3 恢复默认对齐方式**](#2.2.3 恢复默认对齐方式)
      • [**2.3 注意事项**](#2.3 注意事项)
      • [**2.4 编译器支持**](#2.4 编译器支持)
      • [**2.5 与传统方式对比**](#2.5 与传统方式对比)
      • [**2.6 总结表格**](#2.6 总结表格)
    • [**3. `#pragma warning`**](#pragma warning`**)
      • [**3.1 基本语法**](#3.1 基本语法)
      • [**3.2 使用示例**](#3.2 使用示例)
        • 代码解释:
        • [运行结果(如果取消注释 `func4(0);`):](#运行结果(如果取消注释 func4(0);):)
      • [**3.3 编译器支持**](#3.3 编译器支持)
      • [**3.4 与传统方式对比**](#3.4 与传统方式对比)
    • [**4. `#pragma push/pop`**](#pragma push/pop`**)
      • [**4.1 使用示例**](#4.1 使用示例)
      • [**4.2 编译器支持**](#4.2 编译器支持)
      • [**4.3 与传统方式对比**](#4.3 与传统方式对比)
    • [**5. `#pragma optimize`**](#pragma optimize`**)
      • [**5.1 基本语法**](#5.1 基本语法)
      • [**5.2 使用示例**](#5.2 使用示例)
      • [**5.3 编译器支持**](#5.3 编译器支持)
      • [**5.4 与传统方式对比**](#5.4 与传统方式对比)
    • [6. 宏指令放置原则](#6. 宏指令放置原则)
      • [**6.1 放置原则**](#6.1 放置原则)
      • [**6.2 常见 `#pragma` 指令放置位置**](#pragma` 指令放置位置**)
      • [**6.3 实例演示**](#6.3 实例演示)
        • [**1. `#pragma once` 示例**](#pragma once` 示例**)
        • [**2. `#pragma pack` 示例**](#pragma pack` 示例**)
        • [**3. `#pragma warning` 示例**](#pragma warning` 示例**)
        • [**4. `#pragma region` 示例**](#pragma region` 示例**)
        • [**5. `#pragma optimize` 示例**](#pragma optimize` 示例**)
      • [**6.4 小结**](#6.4 小结)
    • **总结**
    • **建议**
    • [9. 结束语](#9. 结束语)
    • 相关文章:

常见 #pragma 指令总结

指令 主要功能 编译器支持
#pragma once 防止头文件多重包含 GCC、Clang、MSVC、Intel、ARM
#pragma pack 控制内存对齐 GCC、Clang、MSVC、Intel、ARM
#pragma warning 控制警告信息 Clang、MSVC、Intel、ARM
#pragma push/pop 保存和恢复编译器设置 Clang、MSVC、Intel
#pragma optimize 控制编译器优化选项 MSVC、Intel

编译器对 #pragma 指令的支持情况

在讲解具体的 #pragma 指令前,我们首先看一下主要编译器对常见 #pragma 指令的支持情况。

#pragma 指令 GCC Clang MSVC Intel Compiler ARM Compiler
#pragma once 支持 支持 支持 支持 支持
#pragma pack 支持 支持 支持 支持 支持
#pragma GCC 支持 支持 不支持 不支持 不支持
#pragma warning 不支持 支持 支持 支持 支持
#pragma push/pop 不支持 支持 支持 支持 不支持
#pragma optimize 不支持 不支持 支持 支持 不支持

表格展示了不同编译器对常见 #pragma 指令的支持情况,编译器的选择会影响你所能使用的 #pragma 指令。

1. #pragma once

#pragma once 是用于防止头文件多重包含的预处理指令,它替代了传统的宏定义方式,确保同一个头文件在同一个编译单元中只会被包含一次。

1.1 使用示例

c 复制代码
// header.h
#pragma once  // 防止头文件被多次包含

#include <stdio.h>

void print_message();  // 函数声明
c 复制代码
// main.c
#include "header.h"  // 引入头文件
#include "header.h"  // 重复包含头文件,但不会导致错误

int main() {
    print_message();  // 调用头文件中的函数
    return 0;
}
c 复制代码
// source.c
#include "header.h"  // 引入头文件

void print_message() {
    printf("Hello, this is a message!\n");
}
运行结果:(正确情况)
bass 复制代码
Hello, this is a message!
解释:(正确情况)
  • header.h 文件中,使用了 #pragma once 来防止头文件被多次包含,即使在 main.c 中重复包含了 header.h,编译器只会处理一次头文件。
  • 程序正常编译并运行,输出预期的消息:Hello, this is a message!
运行结果:(错误情况)
bass 复制代码
multiple definition of 'print_message'
解释:(错误情况)
  • 在这个示例中,虽然我们在 header.h 中使用了 #pragma once,理论上 #pragma once 只能确保头文件在编译过程中只包含一次。
  • 但是,由于 错误的代码结构 ,或者在某些 不支持 #pragma once 的编译器上使用该指令时,可能会依然导致重复包含或多个定义的错误。
  • 某些编译器 中(特别是旧版编译器或不完全实现 #pragma once 的编译器),#pragma once 可能不起作用,导致头文件多次定义。
  • 没有引用 **#pragma once **。

1.2 编译器支持

编译器 支持情况
GCC
Clang
MSVC
Intel Compiler
ARM Compiler

1.3 与传统防止多重包含的方式对比

传统的防止多重包含的方式如下:

c 复制代码
// file1.h
#ifndef FILE1_H
#define FILE1_H

void func();  // 函数声明

#endif  // 防止多重包含

// file2.c
#include "file1.h"  // 会使用宏保护避免多重包含

在传统的方式中,使用 #ifndef#define#endif 宏来确保头文件只被包含一次,虽然它有着广泛的兼容性,但相较于 #pragma once,略显繁琐,并且容易出错。

方法 优点 缺点
#pragma once 简单易懂,编译器优化保证不会多次包含 仅部分编译器支持
传统方式 (#ifndef) 广泛兼容,几乎所有编译器支持 稍显繁琐,易于出错

2. #pragma pack

#pragma pack 用于设置结构体、联合体等数据类型的内存对齐方式。默认情况下,编译器会根据特定的规则来决定对齐方式,使用 #pragma pack 可以强制改变这种默认行为,优化内存占用或确保跨平台兼容。在嵌入式开发、网络协议设计或硬件相关开发中,这种对齐控制非常重要。

2.1 基本语法

#pragma pack 提供了以下三种常用的基本语法,用于设置、保存和恢复对齐方式:

语法形式 作用 说明
#pragma pack(n) 设置全局对齐方式,n 为对齐字节数。 设置后,影响所有后续的结构体、类或联合体的对齐方式。
#pragma pack(push, n) 保存当前对齐方式,并设置新的对齐方式。 可嵌套使用,适用于临时更改对齐方式,稍后可通过 pop 恢复。
#pragma pack(push) 保存当前对齐方式,但不改变对齐值。 此形式仅保存当前对齐设置,不做修改,适合复杂的嵌套对齐场景。
#pragma pack(pop) 恢复最近一次保存的对齐方式。 多次 push 对应多次 pop,可以逐层恢复之前的对齐设置。
#pragma pack() 恢复到默认对齐方式(编译器定义)。 忽略所有之前的 pack 设置,回归到系统或编译器默认的对齐方式(如 GCC 默认对齐 8 字节)。

2.2 示例讲解

2.2.1 设置对齐方式

以下代码展示了如何使用 #pragma pack(n) 设置对齐方式:

c 复制代码
#include <stdio.h>

#pragma pack(1)  // 设置对齐方式为 1 字节
struct Packed1 {
    char a;   // 1 字节
    int b;    // 4 字节
};
#pragma pack()  // 恢复默认对齐方式

struct DefaultPacked {
    char a;   // 1 字节
    int b;    // 4 字节
};

int main() {
    printf("Size of Packed1: %zu\n", sizeof(struct Packed1));       // 输出: 5
    printf("Size of DefaultPacked: %zu\n", sizeof(struct DefaultPacked)); // 输出: 8
    return 0;
}

说明:

  1. #pragma pack(1) 将结构体的对齐方式设为 1 字节,因此 Packed1 的成员是紧密排列的,总大小为 1 + 4 = 5 字节,无填充字节。
  2. #pragma pack() 恢复默认对齐方式,DefaultPacked 根据默认 4 字节对齐,结构体占用 8 字节(填充 3 字节)。

2.2.2 使用 pushpop

pushpop 允许在多处保存和恢复对齐设置,适合需要临时修改对齐的场景:

c 复制代码
#include <stdio.h>

#pragma pack(push, 2)  // 保存当前对齐方式,并设置对齐为 2 字节
struct Packed2 {
    char a;   // 1 字节
    int b;    // 4 字节
};
#pragma pack(pop)  // 恢复之前保存的对齐方式

struct DefaultPacked {
    char a;   // 1 字节
    int b;    // 4 字节
};

int main() {
    printf("Size of Packed2: %zu\n", sizeof(struct Packed2));        // 输出: 6
    printf("Size of DefaultPacked: %zu\n", sizeof(struct DefaultPacked));  // 输出: 8
    return 0;
}

说明:

  1. #pragma pack(push, 2) 将对齐方式设为 2 字节,同时保存了当前的对齐设置。
  2. #pragma pack(pop) 恢复之前保存的对齐方式。

2.2.3 恢复默认对齐方式

以下代码展示了 #pragma pack()#pragma pack(pop) 的区别:

c 复制代码
#include <stdio.h>

#pragma pack(push, 1)  // 保存当前对齐方式,并设置为 1 字节
struct Packed1 {
    char a;
    int b;
};

#pragma pack()  // 恢复默认对齐方式
struct DefaultPacked {
    char a;
    int b;
};

#pragma pack(pop)  // 恢复到最近的 push 设置(1 字节对齐)
struct PackedPop {
    char a;
    int b;
};

int main() {
    printf("Size of Packed1: %zu\n", sizeof(struct Packed1));      // 输出: 5
    printf("Size of DefaultPacked: %zu\n", sizeof(struct DefaultPacked)); // 输出: 8
    printf("Size of PackedPop: %zu\n", sizeof(struct PackedPop));  // 输出: 5
    return 0;
}

区别总结:

指令 作用
#pragma pack() 恢复到系统默认的对齐方式,忽略之前的 push 设置。
#pragma pack(pop) 恢复到最近一次 push 的对齐设置。

2.3 注意事项

  1. 性能影响
    更小的对齐方式可能减少内存占用,但会降低某些平台的访问速度。例如,x86 平台对齐为 4 字节或 8 字节通常性能更佳。
  2. 嵌套使用
    嵌套使用 pushpop 时,需要保证 pushpop 一一对应,避免对齐设置混乱。
  3. 跨平台兼容性
    #pragma pack 的行为依赖于编译器,不同编译器可能默认对齐方式不同,因此需要在跨平台代码中显式指定。

2.4 编译器支持

编译器 支持情况
GCC
Clang
MSVC
Intel Compiler
ARM Compiler

2.5 与传统方式对比

传统的对齐方式通常依赖于编译器的默认设置,而使用 #pragma pack 可以显式地控制对齐方式,从而节省内存或满足特定协议的要求。

方法 优点 缺点
#pragma pack(n) 精确控制内存对齐,可以节省空间 可能导致性能下降,取决于硬件架构
默认对齐 适应大多数平台的性能要求 可能造成内存浪费,无法满足某些协议或标准

2.6 总结表格

语法 作用 场景
#pragma pack(n) 设置对齐方式为 n 字节。 简单修改对齐方式,影响所有后续定义。
#pragma pack(push, n) 保存当前设置,并设置新的对齐方式。 局部修改对齐方式,可嵌套使用。
#pragma pack(push) 保存当前设置,不修改对齐方式。 嵌套对齐管理,恢复更灵活。
#pragma pack(pop) 恢复到最近保存的对齐设置。 用于嵌套场景,逐步恢复对齐状态。
#pragma pack() 恢复到默认对齐方式(编译器定义)。 需要恢复到系统默认对齐时使用。

3. #pragma warning

#pragma warning 用于控制编译器的警告信息,可以开启、关闭或修改警告等级。这在开发过程中非常有用,特别是当我们不希望编译器生成某些警告时。

3.1 基本语法

#pragma warning 用于控制编译器发出的警告信息,主要有以下几种形式:

语法形式 作用 说明
#pragma warning(push) 保存当前警告状态。 通常与 pop 配对使用,用于嵌套管理警告设置。
#pragma warning(pop) 恢复最近保存的警告状态。 恢复到最近一次使用 push 时的状态。
#pragma warning(disable: n) 禁用特定编号的警告(如 n)。 编译器不会对编号为 n 的警告发出提示。
#pragma warning(default: n) 恢复编号为 n 的警告为默认状态。 如果某些警告被禁用,可以通过此语法重新启用。
#pragma warning(error: n) 将编号为 n 的警告视为错误处理。 编译器会将编号为 n 的警告当作错误,终止编译。

3.2 使用示例

c 复制代码
#include <stdio.h>

// 禁用警告 C4100:未引用的形参
#pragma warning(disable : 4100)

void func1(int unused_param) {
    // 参数未使用,通常会触发 C4100 警告,但已被禁用
    printf("Function with unused parameter.\n");
}

// 保存当前警告状态
#pragma warning(push)

// 禁用警告 C4700:局部变量初始化前使用
#pragma warning(disable : 4700)

void func2() {
    // 局部变量未初始化,但警告被禁用
    int uninitialized_var;
    printf("Uninitialized variable usage: %d\n", uninitialized_var);  // 使用未初始化的变量
}

// 恢复警告 C4700
#pragma warning(pop)

void func3() {
    // 会触发 C4700 警告,因为恢复了默认的警告设置
    int uninitialized_var;
    printf("Uninitialized variable usage: %d\n", uninitialized_var);  // 使用未初始化的变量
}

// 将警告 C4100 当做错误处理
#pragma warning(error : 4100)

void func4(int unused_param) {
    // 参数未使用,这将导致编译失败,因为 C4100 警告被视为错误
    printf("Function with unused parameter.\n");
}

int main() {
    func1(42);  // 不会触发 C4100 警告
    func2();    // 不会触发 C4700 警告
    func3();    // 会触发 C4700 警告
    // func4(0);  // 这行会导致编译错误,因为 C4100 警告被视为错误
    return 0;
}
代码解释:
  1. 禁用警告 C4100

    • #pragma warning(disable : 4100) 禁用了 C4100 警告,这意味着 func1 中未使用的参数不会触发警告。
  2. 保存警告状态并禁用警告 C4700

    • #pragma warning(push) 保存当前警告状态。
    • #pragma warning(disable : 4700) 禁用了 C4700 警告(未初始化局部变量)。
    • func2 中,虽然使用了未初始化的局部变量,C4700 警告被禁用,不会触发警告。
  3. 恢复警告 C4700

    • #pragma warning(pop) 恢复了之前保存的警告状态,意味着 func3 中的未初始化局部变量会触发 C4700 警告。
  4. 将警告 C4100 视为错误:

    • #pragma warning(error : 4100) 将警告 C4100 转换为错误。因此,在 func4 中,未使用的参数会导致编译失败。
运行结果(如果取消注释 func4(0);):
  • 编译时会提示错误:C4100: 'unused_param' : unreferenced formal parameter,因为警告被当作错误处理。
  • 其他函数将按照禁用或恢复的警告状态正常编译。

3.3 编译器支持

编译器 支持情况
GCC 不支持
Clang 支持
MSVC 支持
Intel Compiler 支持
ARM Compiler 支持

3.4 与传统方式对比

传统的做法通常依赖于命令行参数来关闭警告,而 #pragma warning 提供了在代码内部控制警告的灵活性。

方法 优点 缺点
#pragma warning 更为灵活,能够精确控制单个文件的警告设置 可能导致在不同编译器之间产生不一致的行为
命令行关闭警告 适用于所有文件,但无法细粒度控制警告 无法在单个文件中控制警告

4. #pragma push/pop

#pragma push#pragma pop 用于保存和恢复编译器设置。它们通常与优化、警告或其他 #pragma 设置一起使用,确保在某段代码修改了编译器设置后,可以恢复原本的设置。

4.1 使用示例

c 复制代码
// 禁用警告
#pragma warning(push)  // 保存当前警告设置
#pragma warning(disable: 4996)  // 禁用警告

// 恢复警告
#pragma warning(pop)  // 恢复先前保存的警告设置

在这段代码中,#pragma warning(push) 保存当前的警告设置,接着通过 #pragma warning(disable: 4996) 禁用警告。使用 #pragma warning(pop) 恢复之前的警告设置。这样做的好处是在局部范围内进行设置调整后,可以保证不会影响到其他地方的编译行为。

4.2 编译器支持

编译器 支持情况
GCC 不支持
Clang 支持
MSVC 支持
Intel Compiler 支持
ARM Compiler 不支持

4.3 与传统方式对比

传统的做法通常通过手动保存并恢复变量或状态来模拟类似的功能。使用 #pragma push#pragma pop 更为简洁,避免了复杂的状态保存和恢复逻辑。

方法 优点 缺点
#pragma push/pop 更简洁,能自动保存和恢复设置 仅限支持的编译器使用
手动保存和恢复 可自定义更复杂的保存恢复逻辑 代码冗长且易于出错

5. #pragma optimize

#pragma optimize 用于控制编译器的优化选项,通常用于调试和性能调优。通过这种方式,开发者可以精确地指定哪些函数或代码块应该进行优化。

5.1 基本语法

#pragma optimize 用于启用或禁用特定优化选项,主要用在性能敏感的代码片段中:

语法形式 作用 说明
#pragma optimize("", on) 启用所有优化选项。 启用编译器优化功能,参数为空字符串表示所有优化,on 表示启用。
#pragma optimize("", off) 禁用所有优化选项。 停用优化功能,便于调试或避免不必要的优化影响。

5.2 使用示例

c 复制代码
// 禁用优化
#pragma optimize("", off)  // 关闭优化
void my_function() {
    // 此函数的代码将不会被优化
}

// 恢复优化
#pragma optimize("", on)  // 恢复优化
void another_function() {
    // 此函数的代码将会被优化
}

在上述代码中,通过 #pragma optimize("", off) 禁用某些函数或代码块的优化,接着使用 #pragma optimize("", on) 恢复优化。这对于调试时非常有用,可以精确控制优化对程序执行的影响。

5.3 编译器支持

编译器 支持情况
GCC 不支持
Clang 不支持
MSVC 支持
Intel Compiler 支持
ARM Compiler 不支持

5.4 与传统方式对比

传统的方式通常通过编译器命令行选项来全局设置优化选项,而 #pragma optimize 允许在代码内部精确控制优化的范围。

方法 优点 缺点
#pragma optimize 精细控制,避免全局影响其他部分 仅限支持的编译器使用
编译器命令行选项 可在全局范围内调整优化选项 无法精确控制某些函数或代码块的优化行为

6. 宏指令放置原则

#pragma 指令的写法和作用会决定它需要放在程序文件的 什么位置 。以下是常见的 #pragma 指令及其推荐位置的详细说明:

6.1 放置原则

  1. 全局作用域的 #pragma 指令

    如果指令的作用需要影响整个文件(如 #pragma once#pragma pack),一般写在文件的开头或声明的前面。

  2. 局部作用域的 #pragma 指令

    如果指令的作用仅限于某一段代码(如 #pragma warning#pragma optimize),通常写在具体代码块附近。

  3. 调试和特定功能的 #pragma 指令

    调试功能相关的 #pragma 指令(如 #pragma warning#pragma message),一般写在需要调试的代码附近,便于查看效果。

6.2 常见 #pragma 指令放置位置

指令 推荐位置 原因与注意事项
#pragma once 文件开头 防止头文件被重复包含,因此通常放在头文件的最顶部。
#pragma pack 声明前或头文件顶部 一般在结构体声明前使用,控制内存对齐方式;如果需要对某段代码局部调整对齐方式,需在调整代码段的前后使用 #pragma pack(push)#pragma pack(pop)
#pragma warning 具体代码块附近 用于临时屏蔽或启用警告,通常放在特定代码块附近以提高可读性,避免全局作用导致的意外效果。
#pragma region 代码逻辑分块处 用于逻辑上分割代码块,因此常放在代码区域的开始和结束处,便于使用 IDE 折叠查看。
#pragma optimize 性能敏感代码段前 在性能优化要求较高的代码段前使用;通常在模块初始化、算法实现等性能瓶颈处设置,避免全局优化的副作用影响整个程序调试。
#pragma comment(lib) 头文件顶部或依赖模块定义附近 为了确保链接库生效,通常将其放置在头文件顶部或者与依赖模块的声明放在一起,避免遗漏链接设置。
#pragma message 编译器需要提示的地方 在代码特定位置插入调试信息,便于在编译时跟踪问题或显示自定义消息提示。

6.3 实例演示

1. #pragma once 示例

通常放在头文件的顶部,用于防止重复包含头文件:

c 复制代码
// myheader.h
#pragma once  // 确保头文件只被包含一次
#include <stdio.h>

void myFunction();
2. #pragma pack 示例

用于控制结构体的对齐方式,通常放在结构体声明前后:

c 复制代码
#include <stdio.h>

// 设置对齐方式为 1 字节
#pragma pack(push, 1)
struct PackedStruct {
    char a;    // 1 字节
    int b;     // 4 字节
};
#pragma pack(pop)  // 恢复默认对齐方式

int main() {
    printf("Size of PackedStruct: %lu\n", sizeof(struct PackedStruct));
    return 0;
}
3. #pragma warning 示例

用于屏蔽某段代码的警告信息,通常放在代码块附近:

c 复制代码
#include <stdio.h>
#pragma warning(disable : 4996)  // 禁用某个警告

int main() {
    char str[10];
    gets(str);  // gets 可能引发警告,这里通过 #pragma 临时屏蔽
    printf("Input: %s\n", str);
    return 0;
}
#pragma warning(default : 4996)  // 恢复默认警告
4. #pragma region 示例

用于逻辑分块:

c 复制代码
#pragma region Initialization
void init() {
    // 初始化代码
}
#pragma endregion
5. #pragma optimize 示例

用于控制性能敏感代码的优化:

c 复制代码
#pragma optimize("", off)  // 禁用优化
void debugFunction() {
    // 调试用代码
}
#pragma optimize("", on)   // 启用优化

6.4 小结

  • 全局性指令 :如 #pragma once#pragma pack 一般放在文件顶部或声明前。
  • 局部性指令 :如 #pragma warning#pragma optimize 放在需要控制的代码块附近。
  • IDE 辅助指令 :如 #pragma region 常用于划分代码块,放在逻辑分块处。

这种放置方式可以确保 #pragma 指令的使用既合理又高效,同时便于代码的可维护性和可读性。

总结

在本文中,我们系统地讲解了常见的 #pragma 指令,包括其基本用法、编译器支持情况、示例代码以及与传统方法的对比。#pragma 指令是一个强大的工具,可以帮助开发者精细控制编译器的行为,优化代码性能,避免错误,并确保跨平台兼容性。然而,使用这些指令时需要特别注意编译器的支持情况,因为并非所有的 #pragma 指令都能在所有编译器中得到支持。

建议

在开发过程中,合理使用 #pragma 指令可以提高代码的可维护性和效率,尤其是在需要与特定平台或编译器配合时。但要小心滥用这些指令,因为它们可能会影响编译器的默认行为,并且某些指令在不同编译器中的支持可能有所不同。因此,始终应根据实际需求和目标编译器的支持情况来选择合适的指令。

9. 结束语

  1. 本节内容已经全部介绍完毕,希望通过这篇文章,大家对C语言 #pragma 指令有了更深入的理解和认识。
  2. 感谢各位的阅读和支持,如果觉得这篇文章对你有帮助,请不要吝惜你的点赞和评论 ,这对我们非常重要。再次感谢大家的关注和支持点我关注❤️

相关文章:

我的博客即将同步至腾讯云开发者社区,邀请大家一同入驻:https://cloud.tencent.com/developer/support-plan?invite_code=32ueob52gdc08

相关推荐
qincjun28 分钟前
文件I/O操作:C++
开发语言·c++
星语心愿.32 分钟前
D4——贪心练习
c++·算法·贪心算法
汉克老师1 小时前
2023年厦门市第30届小学生C++信息学竞赛复赛上机操作题(三、2023C. 太空旅行(travel))
开发语言·c++
stm 学习ing1 小时前
HDLBits训练3
c语言·经验分享·笔记·算法·fpga·eda·verilog hdl
single5941 小时前
【c++笔试强训】(第四十一篇)
java·c++·算法·深度优先·图论·牛客
yuanbenshidiaos1 小时前
C++-----函数与库
开发语言·c++·算法
Lenyiin2 小时前
3354. 使数组元素等于零
c++·算法·leetcode·周赛
爱打APEX的小李2 小时前
拷贝构造和赋值运算符重载
c++
霁月风3 小时前
设计模式——工厂方法模式
c++·设计模式·工厂方法模式
夜阳朔3 小时前
《C++ Primer》第三章知识点
c++·编程语言