第四篇：编译器与链接深度

4.1 GCC扩展与内联汇编

/**
 * GCC扩展特性与内联汇编
 * 包括属性、内置函数、SIMD指令等
 */

#include <stdio.h>
#include <stdint.h>
#include <x86intrin.h>

// ========== 函数属性 ==========
// 始终内联
__attribute__((always_inline)) inline int fast_add(int a, int b) {
    return a + b;
}

// 不返回的函数
__attribute__((noreturn)) void fatal_error(const char *msg) {
    printf("%s\n", msg);
    exit(1);
}

// 纯函数（无副作用，结果只依赖参数）
__attribute__((pure)) int square(int x) {
    return x * x;
}

// 构造函数（main之前执行）
__attribute__((constructor)) void init_function() {
    printf("Initialization before main\n");
}

// 析构函数（main之后执行）
__attribute__((destructor)) void cleanup_function() {
    printf("Cleanup after main\n");
}

// ========== 变量属性 ==========
// 对齐
int aligned_var __attribute__((aligned(64))) = 100;

// 放在指定段
__attribute__((section(".my_section"))) int my_section_var = 42;

// ========== 结构体属性 ==========
// 紧凑布局（无填充）
struct __attribute__((packed)) packed_struct {
    char c;
    int i;
    short s;
};

// 对齐到缓存行
struct __attribute__((aligned(64))) cache_aligned {
    int a;
    int b;
    int c;
    int d;
};

// ========== 内联汇编基础 ==========
// 获取CPU时间戳（RDTSC）
uint64_t rdtsc() {
    uint32_t low, high;
    __asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
    return ((uint64_t)high << 32) | low;
}

// 内存屏障
void memory_barrier() {
    __asm__ volatile("mfence" ::: "memory");
}

// 暂停指令（用于自旋等待）
void cpu_pause() {
    __asm__ volatile("pause");
}

// ========== 内联汇编高级 ==========
// 原子递增
int atomic_increment(int *ptr) {
    int result;
    __asm__ volatile(
        "lock xaddl %0, %1"
        : "=r"(result), "+m"(*ptr)
        : "0"(1)
        : "memory"
    );
    return result + 1;
}

// 比较并交换
int compare_and_swap(int *ptr, int old_val, int new_val) {
    int ret;
    __asm__ volatile(
        "lock cmpxchgl %2, %1"
        : "=a"(ret), "+m"(*ptr)
        : "r"(new_val), "0"(old_val)
        : "memory"
    );
    return ret;
}

// 位扫描（找到第一个1的位置）
int find_first_set_bit(unsigned long x) {
    int pos;
    __asm__("bsf %1, %0" : "=r"(pos) : "r"(x));
    return pos;
}

// ========== SIMD指令（SSE/AVX） ==========
#include <immintrin.h>

// SSE向量加法
void sse_vector_add(float *a, float *b, float *c, int n) {
    for (int i = 0; i < n; i += 4) {
        __m128 va = _mm_loadu_ps(a + i);
        __m128 vb = _mm_loadu_ps(b + i);
        __m128 vc = _mm_add_ps(va, vb);
        _mm_storeu_ps(c + i, vc);
    }
}

// AVX向量加法
void avx_vector_add(float *a, float *b, float *c, int n) {
    for (int i = 0; i < n; i += 8) {
        __m256 va = _mm256_loadu_ps(a + i);
        __m256 vb = _mm256_loadu_ps(b + i);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_storeu_ps(c + i, vc);
    }
}

// 矩阵乘法优化（使用AVX）
void matrix_multiply_avx(float *A, float *B, float *C, int N) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            __m256 sum = _mm256_setzero_ps();
            for (int k = 0; k < N; k += 8) {
                __m256 va = _mm256_loadu_ps(A + i * N + k);
                __m256 vb = _mm256_loadu_ps(B + k * N + j);
                sum = _mm256_add_ps(sum, _mm256_mul_ps(va, vb));
            }
            float result[8];
            _mm256_storeu_ps(result, sum);
            C[i * N + j] = result[0] + result[1] + result[2] + result[3] +
                           result[4] + result[5] + result[6] + result[7];
        }
    }
}

// ========== 内置函数 ==========
void gcc_builtins() {
    int x = 0b00110101;

    // 位操作
    int popcount = __builtin_popcount(x);      // 1的个数
    int trailing = __builtin_ctz(x);           // 末尾0个数
    int leading = __builtin_clz(x);            // 前导0个数
    int parity = __builtin_parity(x);          // 奇偶性

    // 分支预测
    if (__builtin_expect(x > 0, 1)) {
        // 大概率执行
    }

    // 预取
    __builtin_prefetch(&x, 0, 3);  // 读取预取

    // 数学函数
    double sqrt_val = __builtin_sqrt(2.0);
    double sin_val = __builtin_sin(3.14159);

    // 类型检查
    if (__builtin_types_compatible_p(int, long)) {
        printf("int and long are compatible\n");
    }

    // 常量检测
    if (__builtin_constant_p(x)) {
        printf("x is compile-time constant\n");
    }

    // 假设（优化提示）
    __builtin_assume(x > 0);
}

4.2 链接器脚本与自定义内存布局

/**
 * 链接器脚本（linker.ld）
 * 自定义内存布局和段映射
 */

/*
OUTPUT_FORMAT("elf64-x86-64")
ENTRY(_start)

SECTIONS {
    . = 0x400000;

    .text : {
        *(.text)
        *(.text.*)
    }

    .data : {
        *(.data)
        *(.data.*)
    }

    .rodata : {
        *(.rodata)
        *(.rodata.*)
    }

    .bss : {
        *(.bss)
        *(.bss.*)
    }

    .my_section ALIGN(4096) : {
        __my_section_start = .;
        *(.my_section)
        __my_section_end = .;
    }

    /DISCARD/ : {
        *(.comment)
        *(.note)
    }
}
*/

// ========== 使用自定义段 ==========
__attribute__((section(".my_section"))) int my_var = 100;
__attribute__((section(".my_section"))) char my_data[1024];

// 获取段边界
extern char __my_section_start[];
extern char __my_section_end[];

void iterate_custom_section() {
    printf("My section: %p - %p, size: %zu\n",
           __my_section_start, __my_section_end,
           __my_section_end - __my_section_start);
}

// ========== 弱符号 ==========
__attribute__((weak)) int weak_function() {
    return 0;
}

// 如果其他目标文件提供了strong版本，则使用strong版本
// ========== 别名 ==========
int original_function(int x) {
    return x * x;
}

int alias_function(int x) __attribute__((alias("original_function")));

// ========== 可见性 ==========
__attribute__((visibility("hidden"))) int hidden_function() {
    return 42;
}

__attribute__((visibility("protected"))) int protected_function() {
    return 43;
}

// ========== 动态加载示例 ==========
#include <dlfcn.h>

typedef int (*add_func)(int, int);

void dynamic_loading_demo() {
    void *handle = dlopen("./libmath.so", RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "dlopen error: %s\n", dlerror());
        return;
    }

    add_func add = (add_func)dlsym(handle, "add");
    if (!add) {
        fprintf(stderr, "dlsym error: %s\n", dlerror());
    } else {
        int result = add(10, 20);
        printf("Dynamic call result: %d\n", result);
    }

    dlclose(handle);
}

第五篇：性能极致优化

5.1 CPU缓存优化技术

/**
 * CPU缓存优化技术
 * 包括缓存行对齐、伪共享避免、数据布局优化、预取等
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <time.h>

#define CACHE_LINE_SIZE 64

// ========== 缓存行对齐 ==========
// 避免伪共享
struct __attribute__((aligned(CACHE_LINE_SIZE))) aligned_counter {
    long value;
    char padding[CACHE_LINE_SIZE - sizeof(long)];
};

// 伪共享示例（性能差）
struct false_sharing {
    long a;
    long b;  // a和b在同一缓存行
};

// 改进：分离到不同缓存行
struct no_false_sharing {
    long a;
    char pad1[CACHE_LINE_SIZE - sizeof(long)];
    long b;
    char pad2[CACHE_LINE_SIZE - sizeof(long)];
};

// ========== 数据布局优化 ==========
// 按大小排序，减少填充
struct optimized_layout {
    double d;      // 8字节
    long l;        // 8字节
    int i;         // 4字节
    short s;       // 2字节
    char c;        // 1字节
    char padding;  // 自动填充到16字节
};

// 未优化布局（产生更多填充）
struct unoptimized_layout {
    char c;        // 1字节 + 7填充
    double d;      // 8字节
    int i;         // 4字节 + 4填充
    short s;       // 2字节 + 6填充
    long l;        // 8字节
};  // 共48字节，而optimized_layout只有24字节

// ========== 内存访问模式优化 ==========
// 行优先 vs 列优先
void row_major_matrix_multiply(int *A, int *B, int *C, int N) {
    // 行优先：缓存友好
    for (int i = 0; i < N; i++) {
        for (int k = 0; k < N; k++) {
            int aik = A[i * N + k];
            for (int j = 0; j < N; j++) {
                C[i * N + j] += aik * B[k * N + j];
            }
        }
    }
}

void column_major_matrix_multiply(int *A, int *B, int *C, int N) {
    // 列优先：缓存不友好
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            int sum = 0;
            for (int k = 0; k < N; k++) {
                sum += A[i * N + k] * B[k * N + j];
            }
            C[i * N + j] = sum;
        }
    }
}

// ========== 循环分块（Blocking） ==========
void matrix_multiply_blocked(int *A, int *B, int *C, int N, int BLOCK_SIZE) {
    memset(C, 0, N * N * sizeof(int));

    for (int i = 0; i < N; i += BLOCK_SIZE) {
        for (int j = 0; j < N; j += BLOCK_SIZE) {
            for (int k = 0; k < N; k += BLOCK_SIZE) {
                // 块内计算
                for (int ii = i; ii < i + BLOCK_SIZE && ii < N; ii++) {
                    for (int kk = k; kk < k + BLOCK_SIZE && kk < N; kk++) {
                        int aik = A[ii * N + kk];
                        for (int jj = j; jj < j + BLOCK_SIZE && jj < N; jj++) {
                            C[ii * N + jj] += aik * B[kk * N + jj];
                        }
                    }
                }
            }
        }
    }
}

// ========== 数据预取 ==========
void prefetch_demo(int *data, int n) {
    for (int i = 0; i < n; i++) {
        // 预取未来可能需要的数据
        __builtin_prefetch(&data[i + 64], 0, 3);

        // 处理当前数据
        data[i] = data[i] * 2;
    }
}

// ========== 分支预测优化 ==========
// 排序后遍历，提高分支预测准确率
int sum_positive_values(int *arr, int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        if (arr[i] > 0) {  // 如果数组已排序，分支更容易预测
            sum += arr[i];
        }
    }
    return sum;
}

// 使用__builtin_expect提示分支概率
int checked_divide(int a, int b) {
    if (__builtin_expect(b == 0, 0)) {
        return -1;  // 极少数情况
    }
    return a / b;
}

// ========== 循环展开 ==========
void loop_unrolling(int *a, int *b, int *c, int n) {
    int i;
    // 主循环：每次处理4个元素
    for (i = 0; i < n - 3; i += 4) {
        c[i] = a[i] + b[i];
        c[i+1] = a[i+1] + b[i+1];
        c[i+2] = a[i+2] + b[i+2];
        c[i+3] = a[i+3] + b[i+3];
    }
    // 剩余元素处理
    for (; i < n; i++) {
        c[i] = a[i] + b[i];
    }
}

// ========== 性能测量 ==========
#ifdef __linux__
#include <time.h>
double get_time() {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return ts.tv_sec + ts.tv_nsec * 1e-9;
}
#else
#include <sys/time.h>
double get_time() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec + tv.tv_usec * 1e-6;
}
#endif

// 性能测试宏
#define MEASURE_TIME(func, ...) do { \
    double start = get_time(); \
    func(__VA_ARGS__); \
    double end = get_time(); \
    printf("%s took %.6f seconds\n", #func, end - start); \
} while (0)

5.2 性能分析工具

/**
 * 性能分析工具使用示例
 * 包括gprof、perf、valgrind等
 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// ========== 用于性能分析的测试函数 ==========
void expensive_function_1(int n) {
    for (volatile int i = 0; i < n; i++) {
        for (volatile int j = 0; j < n; j++) {
            volatile int x = i * j;
        }
    }
}

void expensive_function_2(int n) {
    for (volatile int i = 0; i < n; i++) {
        for (volatile int j = 0; j < n; j++) {
            volatile int x = i + j;
        }
    }
}

void expensive_function_3(int n) {
    for (volatile int i = 0; i < n; i++) {
        volatile int x = rand() % 100;
    }
}

// ========== 插桩式性能分析 ==========
#ifdef PROFILING
#define PROFILE_START(name) \
    double __start_##name = get_time();

#define PROFILE_END(name) \
    double __end_##name = get_time(); \
    printf("Function %s took %.3f ms\n", #name, (__end_##name - __start_##name) * 1000);
#else
#define PROFILE_START(name)
#define PROFILE_END(name)
#endif

void profiled_function() {
    PROFILE_START(profiled_function);

    expensive_function_1(500);
    expensive_function_2(500);
    expensive_function_3(500000);

    PROFILE_END(profiled_function);
}

// ========== 内存分析 ==========
void memory_leak_test() {
    // 故意泄漏内存
    char *leak1 = malloc(1024);
    char *leak2 = malloc(2048);
    char *leak3 = malloc(4096);

    free(leak1);
    // leak2和leak3未释放
}

// ========== 缓存未命中分析 ==========
void cache_miss_test() {
    int size = 1024 * 1024;
    int *arr = malloc(size * sizeof(int));

    // 顺序访问（缓存友好）
    for (int i = 0; i < size; i++) {
        arr[i] = i;
    }

    // 随机访问（缓存不友好）
    for (int i = 0; i < size; i++) {
        int idx = rand() % size;
        arr[idx] = i;
    }

    free(arr);
}

// ========== 使用说明 ==========
/*
 * 编译时加入性能分析选项：
 * 
 * 1. gprof:
 *    gcc -pg -o program program.c
 *    ./program
 *    gprof program gmon.out > analysis.txt
 * 
 * 2. perf (Linux):
 *    perf record ./program
 *    perf report
 *    perf stat ./program
 * 
 * 3. valgrind:
 *    valgrind --tool=callgrind ./program
 *    valgrind --leak-check=full ./program
 * 
 * 4. gcov (代码覆盖率):
 *    gcc -fprofile-arcs -ftest-coverage -o program program.c
 *    ./program
 *    gcov program.c
 * 
 * 5. 使用sanitizer:
 *    gcc -fsanitize=address -g -o program program.c
 *    gcc -fsanitize=thread -g -o program program.c
 *    gcc -fsanitize=undefined -g -o program program.c
 */

第六篇：安全编程与防御技术

6.1 缓冲区溢出防护

/**
 * 安全编程技术
 * 包括栈保护、ASLR、NX、格式化字符串防护等
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// ========== 安全字符串函数 ==========
void safe_string_operations() {
    char dest[10];
    const char *src = "Hello World";

    // 不安全
    // strcpy(dest, src);  // 缓冲区溢出

    // 安全：使用strncpy
    strncpy(dest, src, sizeof(dest) - 1);
    dest[sizeof(dest) - 1] = '\0';

    // 更安全：使用snprintf
    snprintf(dest, sizeof(dest), "%s", src);

    // 安全连接
    char dest2[20] = "Hello";
    strncat(dest2, " World", sizeof(dest2) - strlen(dest2) - 1);
}

// ========== 格式化字符串漏洞防护 ==========
void safe_printf(const char *user_input) {
    // 不安全：用户输入作为格式字符串
    // printf(user_input);

    // 安全：固定格式
    printf("%s", user_input);
}

// ========== 整数溢出检查 ==========
int safe_multiply(int a, int b) {
    // 检查乘法是否会溢出
    if (a > 0 && b > 0 && a > INT_MAX / b) {
        return -1;  // 正溢出
    }
    if (a < 0 && b < 0 && a < INT_MAX / b) {
        return -1;  // 正溢出
    }
    if (a > 0 && b < 0 && b < INT_MIN / a) {
        return -1;  // 负溢出
    }
    if (a < 0 && b > 0 && a < INT_MIN / b) {
        return -1;  // 负溢出
    }
    return a * b;
}

int safe_add(int a, int b) {
    if ((b > 0 && a > INT_MAX - b) || (b < 0 && a < INT_MIN - b)) {
        return -1;  // 溢出
    }
    return a + b;
}

// ========== 安全内存管理 ==========
typedef struct {
    void *ptr;
    size_t size;
    int valid;
} safe_ptr_t;

safe_ptr_t* safe_malloc(size_t size) {
    safe_ptr_t *sp = malloc(sizeof(safe_ptr_t));
    if (!sp) return NULL;

    sp->ptr = malloc(size);
    if (!sp->ptr) {
        free(sp);
        return NULL;
    }

    sp->size = size;
    sp->valid = 1;
    return sp;
}

void safe_free(safe_ptr_t *sp) {
    if (sp && sp->valid) {
        // 覆盖敏感数据
        memset(sp->ptr, 0, sp->size);
        free(sp->ptr);
        sp->valid = 0;
        free(sp);
    }
}

// ========== 敏感数据安全清除 ==========
void secure_clear(void *ptr, size_t size) {
    volatile char *p = (volatile char *)ptr;
    while (size--) {
        *p++ = 0;
    }
}

// 安全清除密码
void clear_password(char *password, size_t len) {
    secure_clear(password, len);
}

// ========== 栈保护（编译选项） ==========
/*
 * 编译时启用栈保护：
 * gcc -fstack-protector-strong -o program program.c
 * 
 * 启用ASLR：
 * echo 2 > /proc/sys/kernel/randomize_va_space
 * 
 * 启用NX（非执行栈）：
 * gcc -z noexecstack -o program program.c
 * 
 * 启用完整的RELRO：
 * gcc -Wl,-z,relro,-z,now -o program program.c
 */

// ========== 安全的信号处理 ==========
#include <signal.h>

volatile sig_atomic_t signal_received = 0;

void safe_signal_handler(int signum) {
    signal_received = signum;  // 只设置标志
}

void install_signal_handler() {
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = safe_signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;  // 自动重启被中断的系统调用

    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);
}

第七篇：跨平台开发

7.1 平台检测与条件编译

/**
 * 跨平台开发技术
 * 包括平台检测、条件编译、统一抽象层等
 */

#include <stdio.h>
#include <stdlib.h>

// ========== 平台检测 ==========
#if defined(_WIN32) || defined(_WIN64)
    #define PLATFORM_WINDOWS
    #include <windows.h>
#elif defined(__linux__)
    #define PLATFORM_LINUX
    #include <unistd.h>
    #include <sys/types.h>
#elif defined(__APPLE__)
    #define PLATFORM_MACOS
    #include <unistd.h>
    #include <mach/mach_time.h>
#elif defined(__FreeBSD__)
    #define PLATFORM_FREEBSD
#else
    #error "Unsupported platform"
#endif

// ========== 编译器检测 ==========
#if defined(__GNUC__)
    #define COMPILER_GCC
    #define INLINE __inline__
#elif defined(_MSC_VER)
    #define COMPILER_MSVC
    #define INLINE __inline
#else
    #define INLINE inline
#endif

// ========== 操作系统抽象层 ==========
// 线程
#ifdef PLATFORM_WINDOWS
    typedef HANDLE ThreadHandle;
    typedef DWORD (WINAPI *ThreadFunc)(void*);

    ThreadHandle create_thread(ThreadFunc func, void *arg) {
        return CreateThread(NULL, 0, func, arg, 0, NULL);
    }

    void join_thread(ThreadHandle thread) {
        WaitForSingleObject(thread, INFINITE);
        CloseHandle(thread);
    }
#else
    typedef pthread_t ThreadHandle;
    typedef void *(*ThreadFunc)(void*);

    ThreadHandle create_thread(ThreadFunc func, void *arg) {
        pthread_t thread;
        pthread_create(&thread, NULL, func, arg);
        return thread;
    }

    void join_thread(ThreadHandle thread) {
        pthread_join(thread, NULL);
    }
#endif

// ========== 高精度计时 ==========
double get_high_precision_time() {
#ifdef PLATFORM_WINDOWS
    LARGE_INTEGER freq, count;
    QueryPerformanceFrequency(&freq);
    QueryPerformanceCounter(&count);
    return (double)count.QuadPart / freq.QuadPart;
#elif defined(__APPLE__)
    static mach_timebase_info_data_t info = {0};
    if (info.denom == 0) mach_timebase_info(&info);
    uint64_t time = mach_absolute_time();
    return time * info.numer / info.denom * 1e-9;
#else
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return ts.tv_sec + ts.tv_nsec * 1e-9;
#endif
}

// ========== 动态库加载 ==========
#ifdef PLATFORM_WINDOWS
    #define LIB_HANDLE HMODULE
    #define LOAD_LIBRARY(name) LoadLibraryA(name)
    #define GET_SYMBOL(handle, name) GetProcAddress(handle, name)
    #define CLOSE_LIBRARY(handle) FreeLibrary(handle)
#else
    #define LIB_HANDLE void*
    #define LOAD_LIBRARY(name) dlopen(name, RTLD_LAZY)
    #define GET_SYMBOL(handle, name) dlsym(handle, name)
    #define CLOSE_LIBRARY(handle) dlclose(handle)
#endif

// ========== 文件系统操作 ==========
#ifdef PLATFORM_WINDOWS
    #define PATH_SEPARATOR '\\'
    #define DIR_SEPARATOR "\\"
    #include <direct.h>
    #define mkdir(path) _mkdir(path)
#else
    #define PATH_SEPARATOR '/'
    #define DIR_SEPARATOR "/"
    #include <sys/stat.h>
    #define mkdir(path) mkdir(path, 0755)
#endif

// 跨平台创建目录
int create_directory(const char *path) {
#ifdef PLATFORM_WINDOWS
    return _mkdir(path);
#else
    return mkdir(path, 0755);
#endif
}

// ========== 字节序处理 ==========
#ifdef __BIG_ENDIAN__
    #define htonll(x) (x)
    #define ntohll(x) (x)
#else
    #define htonll(x) ((((uint64_t)htonl((x) & 0xFFFFFFFF)) << 32) | htonl((x) >> 32))
    #define ntohll(x) htonll(x)
#endif

// ========== 对齐属性 ==========
#ifdef COMPILER_GCC
    #define ALIGNED(n) __attribute__((aligned(n)))
#elif defined(COMPILER_MSVC)
    #define ALIGNED(n) __declspec(align(n))
#else
    #define ALIGNED(n)
#endif

// 使用
ALIGNED(64) struct aligned_struct {
    int a;
    int b;
};

第八篇：调试与逆向工程

8.1 GDB高级调试技术

/**
 * GDB高级调试技术
 * 包括断点、观察点、内存检查、反汇编等
 */

#include <stdio.h>
#include <stdlib.h>

// ========== 用于调试的示例程序 ==========
typedef struct {
    int id;
    char name[64];
    double score;
} student_t;

void init_student(student_t *s, int id, const char *name, double score) {
    s->id = id;
    strncpy(s->name, name, sizeof(s->name) - 1);
    s->name[sizeof(s->name) - 1] = '\0';
    s->score = score;
}

double calculate_average(student_t *students, int count) {
    double sum = 0;
    for (int i = 0; i < count; i++) {
        sum += students[i].score;
    }
    return sum / count;
}

int find_best_student(student_t *students, int count) {
    int best_idx = 0;
    for (int i = 1; i < count; i++) {
        if (students[i].score > students[best_idx].score) {
            best_idx = i;
        }
    }
    return best_idx;
}

void debug_demo() {
    student_t students[5];

    init_student(&students[0], 1, "张三", 85.5);
    init_student(&students[1], 2, "李四", 92.0);
    init_student(&students[2], 3, "王五", 78.5);
    init_student(&students[3], 4, "赵六", 88.0);
    init_student(&students[4], 5, "钱七", 95.5);

    double avg = calculate_average(students, 5);
    int best = find_best_student(students, 5);

    printf("平均分: %.2f\n", avg);
    printf("第一名: %s (%.1f分)\n", students[best].name, students[best].score);
}

// ========== GDB使用说明 ==========
/*
 * 编译调试版本：
 * gcc -g -O0 -o program program.c
 * 
 * 启动GDB：
 * gdb ./program
 * 
 * 设置断点：
 * break main
 * break function_name
 * break file.c:line_number
 * break *address
 * 
 * 条件断点：
 * break calculate_average if count > 10
 * 
 * 观察点：
 * watch variable
 * watch *address
 * 
 * 运行程序：
 * run [args]
 * 
 * 单步执行：
 * step     # 进入函数
 * next     # 不进入函数
 * finish   # 执行完当前函数
 * continue # 继续执行
 * 
 * 查看信息：
 * print variable
 * print *array@10
 * info locals
 * info registers
 * backtrace
 * 
 * 内存查看：
 * x/10x address
 * x/s address
 * x/i address
 * 
 * 反汇编：
 * disassemble
 * disassemble function_name
 * 
 * 线程调试：
 * info threads
 * thread 2
 * 
 * 核心转储：
 * ulimit -c unlimited
 * gdb ./program core
 */

知识体系图谱

C语言高级开发
├── 操作系统内核
│   ├── 内核模块开发
│   ├── 系统调用Hook
│   ├── 内存管理（slab/内存池）
│   └── 设备驱动框架
├── 并发与同步
│   ├── POSIX线程高级
│   ├── 无锁编程（CAS/ABA）
│   ├── 原子操作与内存序
│   └── 线程池/连接池
├── 高性能网络
│   ├── 原始套接字
│   ├── epoll/IOCP
│   ├── 协议栈实现
│   └── 零拷贝技术
├── 编译器与链接
│   ├── GCC扩展属性
│   ├── 内联汇编
│   ├── 链接器脚本
│   ├── SIMD向量化
│   └── 动态加载
├── 性能优化
│   ├── CPU缓存优化
│   ├── 分支预测
│   ├── 循环展开/分块
│   ├── 数据预取
│   └── 性能分析工具
├── 安全编程
│   ├── 缓冲区溢出防护
│   ├── 整数溢出检查
│   ├── 格式化字符串防护
│   ├── ASLR/NX/StackGuard
│   └── 安全内存管理
├── 跨平台开发
│   ├── 平台检测
│   ├── 条件编译
│   ├── 抽象层设计
│   └── 构建系统
└── 调试与逆向
    ├── GDB高级调试
    ├── 内存分析
    ├── 反汇编
    └── 核心转储分析

C语言高级开发是一条从“应用”到“系统”的深度探索之路。从内核模块开发到系统调用Hook，从无锁并发到高性能网络服务器，从编译器扩展到底层性能优化，每一步深入都让你对计算机系统的理解更加透彻。愿你在C语言的世界里，不仅掌握编程的技巧，更理解计算机的本质，成为能够构建系统级软件的高级工程师。
来源：
https://app-a7illrp9pngh.appmiaoda.com/