c-advanced

C 高级实践

本文档是从 @c-basics 分割出来的高级主题部分，涵盖测试策略、性能优化、安全实践和最佳实践。

⚠️ 执行原则

MUST 遵循以下C高级开发准则：

• MUST 正确管理内存和资源
• NEVER 忽略缓冲区溢出风险
• ALWAYS 使用静态分析工具
• DO NOT 使用不安全的函数
• MUST 进行性能测试和优化
• ALWAYS 验证跨平台兼容性

编译优化

// 条件编译优化
#ifdef __GNUC__
#define LIKELY(x) __builtin_expect(!!(x), 1)
#define UNLIKELY(x) __builtin_expect(!!(x), 0)
#else
#define LIKELY(x) (x)
#define UNLIKELY(x) (x)
#endif

// 内联函数优化
static inline int fast_max(int a, int b) {
    return LIKELY(a > b) ? a : b;
}

// 分支预测优化
int process_data_optimized(const int* data, size_t count) {
    int sum = 0;
    for (size_t i = 0; i < count; ++i) {
        if (LIKELY(data[i] > 0)) { // 正数更常见
            sum += data[i];
        } else {
            sum -= data[i]; // 负数处理
        }
    }
    return sum;
}

// SIMD优化 (需要编译器支持)
#ifdef __AVX2__
#include <immintrin.h>

void vector_add_float(float* result, const float* a, const float* b, size_t count) {
    size_t i = 0;

    // SIMD处理
    for (; i + 8 <= count; i += 8) {
        __m256 va = _mm256_load_ps(&a[i]);
        __m256 vb = _mm256_load_ps(&b[i]);
        __m256 vr = _mm256_add_ps(va, vb);
        _mm256_store_ps(&result[i], vr);
    }

    // 处理剩余元素
    for (; i < count; ++i) {
        result[i] = a[i] + b[i];
    }
}

#else

void vector_add_float(float* result, const float* a, const float* b, size_t count) {
    for (size_t i = 0; i < count; ++i) {
        result[i] = a[i] + b[i];
    }
}

#endif

🔒 安全实践

缓冲区溢出防护

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

// ✅ 推荐：安全的字符串操作
size_t safe_strncpy(char* dest, const char* src, size_t dest_size) {
    if (!dest || !src || dest_size == 0) {
        return 0;
    }

    size_t src_len = strnlen(src, dest_size);
    if (src_len < dest_size) {
        // 源字符串完全适合
        memcpy(dest, src, src_len);
        dest[src_len] = '\0';
        return src_len;
    } else {
        // 需要截断
        memcpy(dest, src, dest_size - 1);
        dest[dest_size - 1] = '\0';
        return dest_size - 1;
    }
}

size_t safe_strncat(char* dest, const char* src, size_t dest_size) {
    if (!dest || !src || dest_size == 0) {
        return 0;
    }

    size_t dest_len = strnlen(dest, dest_size);
    if (dest_len >= dest_size) {
        return 0; // 目标缓冲区已满或无效
    }

    size_t remaining = dest_size - dest_len;
    size_t src_len = strnlen(src, remaining);

    memcpy(dest + dest_len, src, src_len);
    dest[dest_len + src_len] = '\0';

    return src_len;
}

// ✅ 推荐：安全的内存操作
void* safe_memcpy(void* dest, const void* src, size_t count) {
    if (!dest || !src) {
        return NULL;
    }

    // 检查重叠
    if ((char*)dest < (char*)src + count &&
        (char*)src < (char*)dest + count) {
        // 重叠，使用memmove
        return memmove(dest, src, count);
    }

    return memcpy(dest, src, count);
}

void* safe_malloc(size_t size) {
    if (size == 0) {
        size = 1; // 避免分配0字节
    }

    if (size > SIZE_MAX / 2) {
        return NULL; // 防止整数溢出
    }

    return malloc(size);
}