如何在C与C++中正确混用stdatomic原子组件？

现有一个使用stdatomic.h头文件的库，无法在C项目中编译，尤其是涉及包含原子组件的结构体时。如何正确实现这类库，让它能同时被C和C编译器编译？下面给出的示例虽然能编译，但实现不够规范，可能存在未定义行为。

原问题示例代码 #

lib.h 头文件 #

#ifndef LIB_HDR_H
#define LIB_HDR_H

#include <stdint.h>
#include <stddef.h>

#if defined(__cplusplus)
/* C++原子头文件 */
#include <atomic>
#define lib_size_t std::atomic<size_t>
#else
/* C语言STDATOMIC头文件 */
#include <stdatomic.h>
typedef atomic_size_t lib_size_t;
#endif

#if defined(__cplusplus)
extern "C" {
#endif /* defined(__cplusplus) */

/* 此处为关键难点... */
typedef struct {
  lib_size_t a;
  lib_size_t b;
} lib_t;

void lib_init(lib_t *l);

#if defined(__cplusplus)
}
#endif /* defined(__cplusplus) */

#endif /* LIB_HDR_H */

lib.c 实现文件 #

#include "lib.h"

/* 当前此处无需过多操作... */
void lib_init(lib_t* l) {
    /* 这些操作需保证原子性 */
    l->a = 5;
    l->b = 10;
}

调用该库的C++应用文件 #

#include <iostream>
#include "lib.h"

lib_t my_lib;

int main() {
    lib_init(&my_lib);
}

原代码的问题 #

1. 类型兼容性风险：C的atomic_size_t与C的std::atomic<size_t>是不同类型，C标准未规定二者内存布局和ABI必须兼容，直接用别名统一会导致C和C++看到的lib_t结构体可能不一致，触发未定义行为。
2. 原子操作不规范：C中直接对atomic_size_t赋值并非标准原子操作方式，无法保证操作的原子性。

正确实现方案 #

方案一：兼容布局的透明结构体 #

适用于需要C++代码直接访问结构体成员的场景，通过断言保证类型布局兼容，同时遵循标准原子操作规范。

修正后的 lib.h

#ifndef LIB_HDR_H
#define LIB_HDR_H

#include <stdint.h>
#include <stddef.h>

#if defined(__cplusplus)
#include <atomic>
extern "C" {
// 声明C的原子类型，用于兼容性检查
typedef _Atomic size_t atomic_size_t;
// 断言保证原子类型的大小和对齐一致
static_assert(sizeof(std::atomic<size_t>) == sizeof(atomic_size_t), "Atomic size mismatch");
static_assert(alignof(std::atomic<size_t>) == alignof(atomic_size_t), "Atomic alignment mismatch");

typedef struct {
    std::atomic<size_t> a;
    std::atomic<size_t> b;
} lib_t;
#else
#include <stdatomic.h>
typedef struct {
    atomic_size_t a;
    atomic_size_t b;
} lib_t;
#endif

void lib_init(lib_t *l);
// 封装原子操作API，避免直接操作成员
size_t lib_get_a(const lib_t *l);
void lib_set_a(lib_t *l, size_t val);
size_t lib_get_b(const lib_t *l);
void lib_set_b(lib_t *l, size_t val);

#if defined(__cplusplus)
}
#endif

#endif /* LIB_HDR_H */

修正后的 lib.c

#include "lib.h"
#include <stdatomic.h>

void lib_init(lib_t* l) {
    // 使用C标准原子初始化函数
    atomic_init(&l->a, 5);
    atomic_init(&l->b, 10);
}

size_t lib_get_a(const lib_t *l) {
    return atomic_load(&l->a);
}

void lib_set_a(lib_t *l, size_t val) {
    atomic_store(&l->a, val);
}

size_t lib_get_b(const lib_t *l) {
    return atomic_load(&l->b);
}

void lib_set_b(lib_t *l, size_t val) {
    atomic_store(&l->b, val);
}

C++调用代码

#include <iostream>
#include "lib.h"

lib_t my_lib;

int main() {
    lib_init(&my_lib);
    std::cout << "a: " << lib_get_a(&my_lib) << std::endl;
    std::cout << "b: " << lib_get_b(&my_lib) << std::endl;
    lib_set_a(&my_lib, 20);
    std::cout << "updated a: " << lib_get_a(&my_lib) << std::endl;
}

方案二：不透明结构体（最安全） #

适用于无需C代码直接访问结构体成员的场景，完全隔离C和C的类型差异，是跨语言兼容的最优解。

不透明版本 lib.h

#ifndef LIB_HDR_H
#define LIB_HDR_H

#include <stdint.h>
#include <stddef.h>

#if defined(__cplusplus)
extern "C" {
#endif

// 仅声明结构体，不暴露内部细节
typedef struct lib_t lib_t;

// 实例创建/销毁API
lib_t* lib_create(void);
void lib_destroy(lib_t* l);

// 原子操作API
size_t lib_get_a(const lib_t *l);
void lib_set_a(lib_t *l, size_t val);
size_t lib_get_b(const lib_t *l);
void lib_set_b(lib_t *l, size_t val);

#if defined(__cplusplus)
}
#endif

#endif /* LIB_HDR_H */

不透明版本 lib.c

#include "lib.h"
#include <stdatomic.h>
#include <stdlib.h>

// 内部结构体定义，仅C实现可见
struct lib_t {
    atomic_size_t a;
    atomic_size_t b;
};

lib_t* lib_create(void) {
    lib_t* l = malloc(sizeof(lib_t));
    if (l) {
        atomic_init(&l->a, 5);
        atomic_init(&l->b, 10);
    }
    return l;
}

void lib_destroy(lib_t* l) {
    free(l);
}

size_t lib_get_a(const lib_t *l) {
    return atomic_load(&l->a);
}

void lib_set_a(lib_t *l, size_t val) {
    atomic_store(&l->a, val);
}

size_t lib_get_b(const lib_t *l) {
    return atomic_load(&l->b);
}

void lib_set_b(lib_t *l, size_t val) {
    atomic_store(&l->b, val);
}

C++调用代码

#include <iostream>
#include "lib.h"

int main() {
    lib_t* my_lib = lib_create();
    if (!my_lib) {
        std::cerr << "Failed to create lib instance" << std::endl;
        return 1;
    }
    std::cout << "a: " << lib_get_a(my_lib) << std::endl;
    std::cout << "b: " << lib_get_b(my_lib) << std::endl;
    lib_set_a(my_lib, 20);
    std::cout << "updated a: " << lib_get_a(my_lib) << std::endl;
    lib_destroy(my_lib);
    return 0;
}

方案选择 #

• 若必须让C++直接访问结构体成员，选择方案一，但需依赖编译器对原子类型布局的兼容保证。
• 若无需直接访问成员，优先选择方案二，完全避免类型兼容问题，符合封装原则。

内容的提问来源于stack exchange，提问作者unalignedmemoryaccess