C语言 on 星分

c拓展语法学习

Fri, 26 Jun 2026 08:04:20 +0000

pragma

　　#pragma是 C 语言的一种预处理指令，类似于#include。用于告诉编译器进行某种操作。pragma 单词本身的释义为“编译指令”。

　　最简单的一种 pragma 可以在编译时输出文本提示。

#pragma message(">>> Compiling ...")

int main(void) {
    return 0;
}

　　编译上面的 C 文件结果输出如下。

❯ gcc pragma.c
pragma.c:1:9: warning: >>> Compiling ... [-W#pragma-messages]
    1 | #pragma message(">>> Compiling ...")
      |         ^
1 warning generated.

_Pragma

　　由于宏定义之间不能嵌套，当某种 pragma 想要复用时，无法通过#define复用，此时可以通过_Pragma指令，如下所示。

#define MSG _Pragma("message(\">>> Compiling ...\")")

MSG

_Pragma("message(\">>> Compiling ...\")")

int main(void) {
    return 0;
}

　　编译后输出如下提示信息。其中的 note 消息可以忽略，关注warning: >>> Compiling ... [-W#pragma-messages]段即可。

❯ gcc pragma.c
pragma.c:3:1: warning: >>> Compiling ... [-W#pragma-messages]
    3 | MSG
      | ^
pragma.c:1:13: note: expanded from macro 'MSG'
    1 | #define MSG _Pragma("message(\">>> Compiling ...\")")
      |             ^
<scratch space>:4:2: note: expanded from here
    4 |  message(">>> Compiling ...")
      |  ^
pragma.c:5:1: warning: >>> Compiling ... [-W#pragma-messages]
    5 | _Pragma("message(\">>> Compiling ...\")")
      | ^
<scratch space>:6:2: note: expanded from here
    6 |  message(">>> Compiling ...")
      |  ^
2 warnings generated.

　　根据上面的编译输出结果，我们可以知道，如下两种编译指令是近似等价的。但是_Pragma语法本身可以放在#define中复用。

1
2

#pragma message(">>> Compiling ...")
_Pragma("message(\">>> Compiling ...\")")

pragma 指令功能表

指令	功能
clang diagnostic push	保存当前的诊断设置（哪些警告开、哪些关）到内部栈
clang diagnostic ignored “-Wexcessive-regsave”	告知编译器对接下来遇到的 -Wexcessive-regsave 警告保持沉默
clang diagnostic pop	从栈中恢复诊断设置，这样后面的代码不受影响

-Wexcessive-regsave: 这是一个在某些架构上（尤其是 ARM64）编译器生成代码时可能触发的警告：函数太复杂，编译器需要把大量寄存器保存/恢复到栈上，影响性能。通常在非常大的内联函数或深层嵌套调用时出现。

attribute

　　__attribute__ 是 GCC（GNU Compiler Collection） 提供的一种语言扩展，用于在 C/C++ 代码中指定函数、变量、类型的特殊属性（attributes），从而告诉编译器对这些实体进行特定的优化、检查或行为控制。它也被 Clang 等兼容 GCC 的编译器支持。其基本语法如下

`1`	`__attribute__((attribute-list))`

可放在声明末尾，或紧跟在标识符之后。
多个属性用逗号分隔，例如 __attribute__((aligned(8), packed))

常见属性表

函数属性

属性	说明
`noreturn`	函数永不返回（如 `exit`、`abort`），帮助消除 unreachable-code 警告
`format(archetype, string-index, first-to-check)`	声明类 printf/scanf 函数的格式串检查，例如 `format(printf, 1, 2)`
`nonnull(arg-index, ...)`	声明指针参数不可为 NULL
`const`	纯函数 - 只依赖参数值，不读全局内存，无副作用（比 `pure` 更强）
`pure`	函数无副作用，返回值仅依赖参数和全局内存（可被 CSE 优化，但调用次数不可消）
`malloc`	返回新分配的内存指针，且该指针不会与任何已有指针别名
`warn_unused_result`	调用者忽略返回值时发出警告
`used`	即使未引用也保留函数代码（防止被链接器丢弃）
`unused`	抑制"未使用函数"警告
`weak`	弱符号 - 可被同名强符号覆盖，用于提供默认实现
`constructor`	在 `main()` 之前自动执行（可带优先级参数）
`destructor`	在 `main()` 返回后或 `exit()` 时自动执行
`noinline`	禁止内联此函数
`always_inline`	强制内联（即使优化级别不支持）
`flatten`	将此函数内的每个调用都视为 `always_inline`
`hot`	标记为热点路径，优化分支预测和指令布局
`cold`	标记为冷路径，优化代码体积而非速度
`no_sanitize("sanitizer-name")`	对此函数禁用指定 sanitizer（如 address、thread）
`interrupt` / `interrupt_handler`	声明中断处理函数（自动保存/恢复寄存器，使用特殊返回指令）
`sentinel`	参数列表必须以 NULL 结尾（如 `execl`）
`alloc_size(pos)` / `alloc_size(pos1, pos2)`	标明第几个参数控制分配大小，辅助优化和安全检查
`returns_nonnull`	函数保证返回非 NULL 指针
`leaf`	函数不会回调当前编译单元内的任何函数
`nothrow`	函数保证不抛出 C++ 异常
`target("feature")`	为特定 CPU 特性编译此函数（如 `target("avx2")`）

类型属性

属性	说明
`aligned(N)`	指定类型或变量的对齐字节数（N 为 2 的幂）
`packed`	紧凑布局 - 移除成员间的填充字节
`deprecated` / `deprecated("message")`	标记为已弃用，使用时产生警告
`unavailable`	标记为不可用，使用时产生错误
`visibility("type")`	符号可见性：`default`、`hidden`、`internal`、`protected`
`mode(TI/QI/HI/SI/DI)`	指定整数类型的宽度（如 `__attribute__((mode(DI)))`）
`may_alias`	声明此类型可能与其他类型别名，抑制严格别名优化
`transparent_union`	透明联合体 - 传参时各成员类型可隐含转换
`designated_init`	只能通过指定初始化器初始化（可用于 union）
`objc_root_class`	标记 Objective-C 根类

变量属性

属性	说明
`section("name")`	将变量放入指定段（如 `.init_array`、`.bss.my_section`）
`used`	即使未引用也保留变量
`unused`	抑制"未使用变量"警告
`aligned(N)`	指定对齐（同类型属性，直接作用于变量）
`packed`	去除结构体成员对齐填充（作用于变量声明时）
`cleanup(function)`	变量离开作用域时自动调用给定函数（类似 C++ RAII）
`weak`	弱符号 - 可被同名强符号覆盖
`tls_model("model")`	指定 TLS 模型：`global-dynamic`、`local-dynamic`、`initial-exec`、`local-exec`
`noinit`	变量不初始化为零（用于保持复位后的数据）

用法示例

typedef struct {
        acpi_sdt_header_t header;
        uint32_t          PointerToOtherSDT;
} __attribute__((packed)) rsdt_t;

__attribute__((noinline)) void compiler_barrier(void)
{ __asm__ volatile("" ::: "memory"); }

volatile float __x __attribute__((unused));

aligned(N) 做了两件事：

效果	说明
起始地址	变量/结构体地址满足 addr % N == 0
sizeof 补整	末尾补 padding 使 sizeof % N == 0

volatile 关键字

　　volatile 是 C 语言的一个类型修饰符，用于告诉编译器：该变量的值可能在程序控制流之外被意外修改，因此编译器不能对该变量的访问进行某些优化（如缓存到寄存器、消除冗余读取等）。

　　__asm__和volatile可以一起使用，如下。

`1`	`__asm__ volatile("inw %1, %0" : "=a"(ret) : "dN"(port));`

编译器必须：

保留这段汇编，即使输出没用
每次都生成，不能合并
保持原位，不和其它 volatile asm 重排

【武大软件逆向课程/第一周】扫雷逆向分析批量插旗及机器指令表.exe文件字体更换

Wed, 19 Feb 2025 17:43:52 +0800

作业目标

逆向分析扫雷程序winmine.exe，并编写程序对其进行批量插旗
更换机器指令表.exe内的显示字体

扫雷

定位绘制雷区的代码位置

使用Ollydbg打开winmin.exe。

在当前模块中右键->查找->当前模块中的名称（标签），在弹出的窗口中寻找名称为Bitblt的函数。这里可以直接右键->在每个参考上设置断点，但是我的Ollydbg会报错。因此采用后续的方法。

选中Bitblt项后，按回车键Enter，在弹出的窗口中再次按回车Enter。

执行上述操作后弹出的窗口即为Bitblt的源码，在源码首行按F2或者右键设置断点。

设置断点后按F9或功能按钮运行程序，程序会暂停在断点处。此时按Ctrl + F9或者功能按钮执行到返回，程序会运行到函数Bitblt调用处的下一行。

观察上下文程序可以发现是类似于一个循环的结构，其中esi寄存器为循环变量。

定位雷区数据地址

在这一节内需要观察不同操作下内存区域的变化。

在Ollydbg中可以通过单击任意数据来刷新数据窗口中的内容。

如果想要重新绘制扫雷窗口，需要最小化后恢复窗口。

观察内存读取部分，代码中只有两句可能是对于数组的读取。分别为：

1
2

mov    al, byte ptr [ebx+esi]
push   dword ptr [eax*4+1005A20]

这里可以记录一下Bitblt调用处的地址1002706，然后取消所有断点重新运行程序，将游戏切换到高级模式，随机点击一个地块。这里为了便于定位雷区数据位置，我们多次开局点击地块，直到仅连锁翻开一个地块（这样对雷区数据的影响较小，数据特征更明显）。

然后将在数据窗口中右键->转到->表达式或者按Ctrl + G，输入内存读取部分的常量地址1005A20跳转到该地址。观察数据窗口内该地址处的数据。

发现并不符合雷区数据的特征（至少应该出现大量相同的两种数据）。实际上作为绘制雷区的函数，对数组下标的访问应该具有循环变量，也就是esi寄存器应该参与内存地址的计算，而这条指令并不符合。

因此选择下面的指令来寻找雷区数据所在的内存地址。

`1`	`mov al, byte ptr [ebx+esi]`

在这条指令上打断点后最小化扫雷窗口，再恢复窗口，查看ebx寄存器的值，发现是内存地址1005360，在数据窗口中跟踪该地址。

该地址处的内存数据如下。可以大致推测，未翻开的雷区和未翻开的空白对应数据为0x0F或0x8F。

再次重开游戏，翻开第一个地块以定位数据区域首个元素的位置，如下图所示。

对比可知1005361为首的地址存放雷区数据。

分析地块状态对应的内存值

非雷区地块

从上一节的最后一个图可以得知，翻开的2地块对应的内存值为0x42。推测翻开的n对应的内存值为0x4n。

翻开相邻地块进行验证，可知推测成立，同时也得知未翻开的非雷区对应的内存值为0x0F。

雷区地块

再次观察内存区域，在9个地块后，有一个地块的内存值为不同的0x8F，翻开该地块后再次观察内存区域变化。

可知未翻开的雷为0x8F，翻开的雷为0x8A，踩中的雷为0xCC。

插旗地块与存疑地块

重开游戏并刷新数据窗口。在任意0x8E和0x0F对应的地块上右键以插旗后，刷新数据窗口，观察对应数据变化。扫雷游戏中还有一种标记，在插旗的地块上再次右键可以变为问号地块，这里称为存疑地块，与本次任务并不相关，但是这里还是给出其对应的内存值。

观察上图可知，插旗地块的0x?F被替换为0x?E，存疑地块的0x?F被替换为0x?D。

至此，所有地块状态对应的内存值均被我们分析出来。

简单总结一下，地块状态对应的内存值如下：

地块状态	内存值	地块状态	内存值
未翻开的空地	0x0F	插旗的空地	0x0E
翻开的空地	0x4n(n为要显示的数字)	存疑的空地	0x0D
未翻开的地雷	0x8F	插旗的地雷	0x8E
翻开的地雷	0x8A	存疑的地雷	0x8D
踩中的地雷	0xCC

此外，按Ctrl + ↓调整数据窗口首列数据从0x01偏移开始展示，可以发现在高级模式下30 * 16的布局下，每30个地块的数据后都有两个0x10，用于标注此行结束，在后面编写程序时，应当注意处理这个间隔区域。

编写程序以批量插旗地雷

程序如下：

#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <tlhelp32.h>

#define GET_OFFSET(ROW, COL) ((ROW) * 32 + (COL))

void print_sign(BYTE val) {
    if (val == 0x0F || val == 0x8F) {
        printf("--");
    } else if (val == 0x0E || val == 0x8E) {
        printf("||");
    } else if (val == 0x0D || val == 0x8D) {
        printf("??");
    } else if (val == 0x40) {
        printf("..");
    } else if (val == 0x8A) {
        printf("**");
    } else if (val == 0xCC) {
        printf("XX");
    } else if (val == 0x10) {
    } else {
        printf("%01X", val & 0x0F);
        printf("%01X", val & 0x0F);
    }
    printf(" ");
}

int main() {
    DWORD pid = 0;          // Target process ID
    HANDLE hProcess = NULL;
    LPVOID targetAddress = (LPVOID)0x1005361; // Target memory address
    BYTE readBuffer[512] = {0};
    // BYTE writeData[4] = {0xAA, 0xBB, 0xCC, 0xDD}; // Example data to write
    SIZE_T bytesRead = 0;
    // SIZE_T bytesWritten = 0;

    // Create a snapshot of all processes
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        printf("Failed to create process snapshot, error code: %d\n", GetLastError());
        return 1;
    }

    PROCESSENTRY32 pe = {sizeof(PROCESSENTRY32)};
    if (Process32First(hSnapshot, &pe)) {
        do {
            if (_tcsicmp(pe.szExeFile, _T("winmine.exe")) == 0) {
                pid = pe.th32ProcessID;
                printf("Process found: winmine.exe, PID: %u\n", pid);
                break;
            }
        } while (Process32Next(hSnapshot, &pe));
    } else {
        printf("Failed to retrieve process information, error code: %d\n", GetLastError());
    }

    CloseHandle(hSnapshot);

    if (pid == 0) {
        printf("Process winmine.exe not found\n");
        return 1;
    }

    // Open the target process with required permissions for memory operations
    hProcess = OpenProcess(
        PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION,
        FALSE,
        pid
    );

    if (hProcess == NULL) {
        printf("Failed to open process, error code: %d\n", GetLastError());
        return 1;
    }

    // Read memory content
    if (!ReadProcessMemory(
        hProcess,
        targetAddress,
        readBuffer,
        sizeof(readBuffer),
        &bytesRead
    )) {
        printf("Failed to read memory, error code: %d\n", GetLastError());
        CloseHandle(hProcess);
        return 1;
    }
    printf("Read %d bytes of data:\n", bytesRead);
    for (int i = 0; i < 16; i++) {
        for (int j = 0; j < 32; j++) {
            print_sign(readBuffer[GET_OFFSET(i, j)]);
        }
        printf("\n");
    }


    printf("Start flaging all the mines..\n");
    // Write to memory
    int count = 0;
    for (int i = 0; i < 16; i++) {
        for (int j = 0; j < 32; j++) {
            BYTE flag_mine = 0x8E;
            if (readBuffer[GET_OFFSET(i, j)] == 0x8F) {
                WriteProcessMemory(
                    hProcess,
                    targetAddress + GET_OFFSET(i, j),
                    &flag_mine,
                    sizeof(flag_mine),
                    NULL
                );
                count++;
            }
        }
    }
    printf("Finish! the count of mines: %d\n", count);

    CloseHandle(hProcess);
    // system("pause");
    return 0;
}

这段程序将会在打印雷区当前状态后，将所有0x8F修改为0x8E，即将所有的未翻开的地雷插上旗子，用户应当在新一局游戏内翻开任意地块后运行此程序，然后最小化再恢复窗口以重新绘制雷区。

打印当前状态过程中，未翻开的所有地块将记为--，插旗地块记为||，翻开的空地记为..，翻开的数字地块记为该数字，翻开的地雷记为**，踩中的地雷记为XX。

实验结果

运行结果如下图所示：

刷新窗口后成功插旗。

降低雷数为20后重新运行，便于验证结果正确性，手动翻开所有未插旗地块，中间笑脸图标带上墨镜（表示游戏胜利），可见结果正确。

更换机器指令表.exe显示字体

定位控制字体显示的WinAPI

使用Ollydbg打开机器指令表.exe。

在API文档及网络资料中查询其内涉及的API。

API名称	功能
GetModuleHandle	检索指定模块的模块句柄。模块必须已由调用进程加载。
GetCommandLine	检索当前进程的命令行字符串。
ExitProcess	结束调用进程及其所有线程。
GetSystemMetrics	用于获取关于显示器、鼠标、键盘等系统参数的信息。

观察发现在程序有效的程序段中涉及的三个WinAPI均与字体显示无关。还剩下一个call 004031，推测其很可能控制字体的显示。其上的四个push可能包含参数，尝试修改为push 0D 观察程序变化。修改两个push后运行程序并无明显变化。可见这两个参数并不控制该程序的字体显示。

在call 00401031处设断点并单步步入，依次检索遇见的到的WinAPI功能。

API名称	功能
CreateWindowEx	用于创建一个窗口（包括各种控件如按钮、文本框等）。
SetWindowLong	更改指定窗口的属性。该函数还将指定偏移量处的32位(长)值设置为额外的窗口内存。
GetStockObject	用于获取预定义的图形对象（如画笔、画刷和字体）的句柄。

其中GetStockObject涉及字体的显示，在4010C6处调用，其上一条指令push 0B很可能控制字体的显示。

将push 0B修改为push 0E后继续运行程序，可见字体明显发生变化。

将修改保存到文件

选中被修改的指令，在指令窗口中右键->复制到可执行文件->选择，在弹出的新窗口中选中被修改的指令，右键->保存文件。将新可执行文件命名为机器指令表2.exe。

双击运行修改前后的机器指令表，对比两者的字体差异。

c语言getopt.h库解析

Wed, 22 Jan 2025 13:29:03 +0800

getopt.h简介

getopt.h 是C语言中一个用于处理命令行参数的内嵌库。可以通过以下两个函数来调用其功能：

getopt()
getopt_long()

函数 `getopt()`

getopt() 用于解析仅包含短选项的指令，例如 -g、-o、-f。

`getopt()` 示例程序

使用 getopt() 的参数处理框架如下：

#include <stdio.h>
#include <getopt.h>

int main(int argc, char *argv[]) {
    int opt;

    /* parse the command line input */
    while ((opt = getopt(argc, argv, "f:o:kh")) != -1) {
        switch (opt) {
            case 'f':
                printf("Arg -f: %s\n", optarg);
                break;
            case 'o':
                printf("Arg -o: %s\n", optarg);
                break;
            case 'k':
                printf("Arg -k do not need arguments:%s\n", optarg);
                break;
            case 'h':
                printf("Arg -k do not need arguments:%s\n", optarg);
                break;
            case '?': // An invalid option was found or a required argument is missing.
                if (optopt == 'f' || optopt == 'o') {
                    printf("Option -%c requires an argument.\n", optopt);
                } else {
                    printf("Unknown option -%c.\n", optopt);
                }
                break;
            default:
                printf("Unexpected situation.\n");
                break;
        }
    }

    /* extra arguments handling */
    if (optind < argc) {
        printf("Remaining arguments: ");
        for (; optind < argc; optind++) {
            printf("%s ", argv[optind]);
        }
    } /* optind < argc */
}

编译并运行如下指令：./test_short.out -v yuanshen -f arg:f -o arg:o -k arg:k -h arg:h

> ./test_short.out -v yuanshen -f arg:f -o arg:o -k arg:k -h arg:h
./test_short.out: invalid option -- 'v'
Invalid option: v
Arg -f: arg:f
Arg -o: arg:o
Arg -k do not need arguments:(null)
Arg -k do not need arguments:(null)
Remaining arguments: yuanshen arg:k arg:h %

`getopt()`详细说明

全局变量

全局变量	用途
optopt (int)	遇到未知选项或缺少必要参数时设置，存储导致错误的选项字符。
optarg (char*)	存储当前选项的参数值。当解析需要参数的选项（例如 `-f file.txt` 中的 `file.txt`）时，`optarg` 指向该字符串。
optind (int)	在解析命令行参数过程中，追踪位置，具体指示下一个要处理的参数的索引。

以下代码段会打印所有未被 getopt() 识别的参数（忽略这些参数的输入顺序）：

/* extra arguments handling */
if (optind < argc) {
    printf("Remaining arguments: ");
    for (; optind < argc; optind++) {
        printf("%s ", argv[optind]);
    }
}

模式字符串

模式字符串的定义是 const char *__shortopts，在示例程序中，其实例为 "f:o:kh"。

顾名思义，模式字符串定义了 getopt() 和 getopt_long() 函数中将被识别的短选项。冒号 : 跟在短选项字符后表示该选项需要一个参数。

以 "f:o:kh" 为例，此模式字符串接收4个选项。选项 -f 和 -o 需要输入参数，而选项 -k 和 -h 不需要。

注意：如果 -f 后跟一个选项，该选项会被视为参数。

函数 `getopt_long()`

getopt_long() 用于解析既包含短选项（如 -g、-o、-f）又包含长选项（如 --version、--input）的指令。

函数 getopt_long 识别一个结构体数组 struct option，该数组定义了长选项的信息。

struct option 的原型及相关介绍如下：

struct option {
    const char *name;   /* 长选项的名称 */
    int has_arg;        /* 是否需要参数 */
    int *flag;          /* 如果用户提供了此选项，*flag 将被赋值为 @val */
    int val;            /* 将长选项与短选项绑定，或赋值给 @*flag */
};

字段 has_arg 有两个有效值，即宏 no_argument 和 required_argument。

如果字段 flag 未提供，则字段 val 会被视为与当前长选项绑定的短选项。

如果提供了字段 flag，当用户提供当前长选项时，字段 val 将被赋值给 *flag。

用实例详细说明

以下是一个使用 struct option 数组和模式字符串的实例：

/* the corresponding pattern string */
const char *pattern = "suR:";

struct option long_options[] = {
    /* long option only */
    /* with flag set - 1 */
    { "onlyset1",   no_argument,        &onlyset1,      1   },

    /* long option only */
    /* with flag set - 2 */
    { "onlyset2",   no_argument,        &onlyset1,      2   },

    /* long option only */
    /* with flag set - 3 */
    { "onlyset3",   no_argument,        &onlyset2,      3   },

    /* long option only ( bind failed ) */
    /* with flag set, with val bind */
    { "setbind",    no_argument,        &setbind_flag,  's' },

    /* short and long option */
    /* without flag set, with val bind */
    { "unsetbind",  no_argument,        NULL,           'u' },

    /* short and long option */
    /* require argument */
    { "RequireArg", required_argument,  NULL,           'R' },
};

考虑到短选项和长选项，当提到某个功能的option时，可能会有以下三种情况：

仅有短选项
仅有长选项
同时具有短选项和长选项

结合模式字符串和 struct option 数组，程序接收的选项如下：

短选项	长选项
	–onlyset1
	–onlyset2
	–onlyset3
	–setbind
-s
-u	–unsetbind
-R	–RequireArg

选项 -s 和 --setbind 并未绑定在一起，因为在与 "setbind" 对应的结构体元素中设置了字段 flag。

参数需求冲突

当短选项和长选项中都定义了参数需求时，可能会发生冲突。

我们通过一个实例进行说明：

/* the corresponding pattern string */
const char *pattern = "c:d";

struct option long_options = {
    /* short and long option */
    /* conflict argument require - 1 */
    { "Conflict1",  no_argument,        NULL,           'c' },

    /* short and long option */
    /* conflict argument require - 2 */
    { "Conflict2",  required_argument,  NULL,           'd'},

    /* end of the array ( all zero ) */
    { 0,            0,                  0,              0   }
};

我们可以看到，上述程序将一个需要参数的短选项 -c 与一个不需要参数的长选项 --Conflict1 绑定在一起。

同时，它还将一个不需要参数的短选项 -d 与一个需要参数的长选项 --Conflict2 绑定在一起。

该程序运行正常，但关于参数的配置也会生效。

当用户提供 -c 或 --Conflict1 时，程序会进入同一个分支，但 --Conflict1 不会读取后续的参数，而 -c 会读取。

当用户提供 -d 或 --Conflict2 时，结果则相反。

`getopt_long()` 示例程序

以下是使用 getopt_long() 的参数处理框架：

#include <stdio.h>
#include <getopt.h>

/* test instructions:
    ./test_long.out --onlyset1 --onlyset2 --onlyset3
    ./test_long.out -s --setbind
    ./test_long.out --unsetbind --RequireArg arg:RequireArg
    ./test_long.out -u -R arg:R

    ./test_long.out -c arg:c -d arg:d
    ./test_long.out --Conflict1 arg:Conflict1 --Conflict2 arg:Conflict2

    ./test_long.out -c arg:c --Conflict1 arg:Conflict1
    ./test_long.out --Conflict1 arg:Conflict1 -c arg:c
*/

int main(int argc, char *argv[]) {
    int opt;
    int onlyset1 = 0;
    int onlyset2 = 0;
    int setbind_flag = 0;

    struct option long_options[] = {
        /* long option only */
        /* with flag set - 1 */
        { "onlyset1",   no_argument,        &onlyset1,      1   },

        /* long option only */
        /* with flag set - 2 */
        { "onlyset2",   no_argument,        &onlyset1,      2   },

        /* long option only */
        /* with flag set - 3 */
        { "onlyset3",   no_argument,        &onlyset2,      3   },

        /* long option only ( bind failed ) */
        /* with flag set, with val bound */
        { "setbind",    no_argument,        &setbind_flag,  's' },

        /* short and long option */
        /* without flag set, with val bound */
        { "unsetbind",  no_argument,        NULL,           'u' },

        /* short and long option */
        /* require argument */
        { "RequireArg", required_argument,  NULL,           'R' },

        /* short and long option */
        /* conflict argument require - 1 */
        { "Conflict1",  no_argument,        NULL,           'c' },

        /* short and long option */
        /* conflict argument require - 2 */
        { "Conflict2",  required_argument,  NULL,           'd'},

        /* end of the array ( all zero ) */
        { 0,            0,                  0,              0   }
    };

    int long_index = 0;
    while ((opt = getopt_long(argc, argv, "suR:c:d", long_options, &long_index)) != -1) {
        switch (opt) {
            case 0:
                /* provide long option with flag set */
                printf("long option with flag set recognized!\n");
                printf("long option name is %s\n", long_options[long_index].name);
                if (long_options[long_index].flag != NULL) {
                    printf("the flag value is %d\n", *(long_options[long_index].flag));
                }
                break;
            case 's':
                /* provide option -s instead of --setbind */
                printf("long option (short option only), with flag set, with val bound.\n");
                printf("setbind_flag == %d\n", setbind_flag);
                break;
            case 'u':
                /* provide option -u and --unsetbind */
                printf("long option, without flag set, with val bound.\n");
                break;
            case 'R':
                /* provide option -R and --RequireArg */
                printf("long option require argument.\n");
                printf("the argument: %s\n", optarg);
                break;
            case 'c':
                /* -c require an argument while --Conflict1 not */
                printf("conflict argument require - 1\n");
                printf("the argument: %s\n", optarg);
                break;
            case 'd':
                /* --Conflict2 require an argument while -d not */
                printf("conflict argument require - 2\n");
                printf("the argument: %s\n", optarg);
                break;
            case '?':
                /* Unrecognized option or missing argument */
                printf("Unknown option or missing argument.\n");
                break;
        }
        printf("\n");
    }

    /* Process remaining non-option arguments */
    for (int index = optind; index < argc; index++)
        printf("Non-option argument %s\n", argv[index]);

    return 0;
}

运行测试指令并分析测试结果

编译运行时的测试指令如下：

./test_long.out --onlyset1 --onlyset2 --onlyset3
./test_long.out -s --setbind
./test_long.out --unsetbind --RequireArg arg:RequireArg
./test_long.out -u -R arg:R

./test_long.out -c arg:c -d arg:d
./test_long.out --Conflict1 arg:Conflict1 --Conflict2 arg:Conflict2

./test_long.out -c arg:c --Conflict1 arg:Conflict1
./test_long.out --Conflict1 arg:Conflict1 -c arg:c

结果如下：

> ./test_long.out --onlyset1 --onlyset2 --onlyset3
long option with flag set recognized!
long option name is onlyset1
the flag value is 1

long option with flag set recognized!
long option name is onlyset2
the flag value is 2

long option with flag set recognized!
long option name is onlyset3
the flag value is 3

指令 ./test_long.out --onlyset1 --onlyset2 --onlyset3 展示了 getopt_long() 的基本功能。

它改变了 flag 地址中的值。

> ./test_long.out -s --setbind
long option (short option only), with flag set, with val bound.
setbind_flag == 0

long option with flag set recognized!
long option name is setbind
the flag value is 115

指令 ./test_long.out -s --setbind 展示了绑定失败（当 flag 字段被设置时）。

--setbind 和 -s 会进入不同的分支。

> ./test_long.out --unsetbind --RequireArg arg:RequireArg
long option, without flag set, with val bound.

long option require argument.
the argument: arg:RequireArg

> ./test_long.out -u -R arg:R
long option, without flag set, with val bound.

long option require argument.
the argument: arg:R

这对比展示了绑定成功的结果（当 flag 字段未设置时）。

--unsetbind 和 -u 被绑定在一起，进入相同的分支。

--RequireArg 和 -R 也是一样。

> ./test_long.out -c arg:c -d arg:d
conflict argument require - 1
the argument: arg:c

conflict argument require - 2
the argument: (null)

Non-option argument arg:d

> ./test_long.out --Conflict1 arg:Conflict1 --Conflict2 arg:Conflict2
conflict argument require - 1
the argument: (null)

conflict argument require - 2
the argument: arg:Conflict2

Non-option argument arg:Conflict1

这对比展示了参数要求的冲突。

-c 和 --Conflict1 被绑定在一起，但 -c 需要一个参数。

-d 和 --Conflict2 被绑定在一起，但 --Conflict2 需要一个参数。

结果显示，绑定在一起的选项会进入相同的分支。

但是，是否读取或忽略参数取决于用户提供的选项是否需要参数。

> ./test_long.out -c arg:c --Conflict1 arg:Conflict1
conflict argument require - 1
the argument: arg:c

conflict argument require - 1
the argument: (null)

Non-option argument arg:Conflict1


> ./test_long.out --Conflict1 arg:Conflict1 -c arg:c
conflict argument require - 1
the argument: (null)

conflict argument require - 1
the argument: arg:c

Non-option argument arg:Conflict1

冲突选项的另一个对比结果。