与C #中的C #灵活数组成员进行互操作的正确方法是什么？

Question

我知道灵活的阵列成员不是C11标准的一部分。

那么，与从C 11返回或接受具有灵活数组成员的结构作为参数的C代码互操作的正确方式是什么？

我应该写一个填充程序，将灵活的数组成员从 C 结构映射到 C 中的指针吗？

Answer 1

由于灵活数组成员不能对C (my_type fam[])公开；不是有效的C成员)，我们必须定义自己的类型。

幸运的是，C链接函数没有依赖于其参数的符号。因此，我们可以在共享标头中修改foo的定义，或者定义我们自己的并且不包含它们的标头。

这是一个可能在布局方面兼容的< code>struct。请注意，在C语言中，永远不要在堆栈上声明这些:

struct foo {
  int count;
  #ifndef __cplusplus
  my_type fam[];
  #else
  my_type do_not_use_fam_placeholder;
  my_type* fam() {
    return &do_not_use_fam_placeholder;
  }
  my_type const* fam() const {
    return &do_not_use_fam_placeholder;
  }
  #endif
};

这依赖于C中的< code>foo结构的二进制布局，它是前缀成员，后跟灵活数组成员的元素，不需要进行额外的打包或对齐。它还要求灵活数组成员不能为空。

我会使用这个 1，但如果计数和 fam 之间有填充，则会遇到对齐问题。

不建议在foo上使用memcpy或memmov等。一般来说，在 C 端创建一个 foo 不是一个好主意。如果必须这样做，可以执行以下操作：

struct foo_header {
  int count;
};

foo* create_foo_in_cpp(int count) {
  std::size_t bytes = sizeof(foo)+sizeof(my_type)*(count-1);
  foo* r = (foo*)malloc(bytes);
  ::new((void*)r) foo_header{count};
  for (int i = 0; i < count; ++i)
    ::new( (void*)(r->fam()+i) my_type();
  return r;
};

它构造了 C 中每个有问题的对象。C的客体存在规则比C的更严格;仅仅获取一些 POD 内存并将其解释为 POD 在 C 中不是一个有效的操作，而在 C 中却是有效的。上面的新s 将在运行时优化为 noops，但 C 需要声明在严格读取标准的情况下，应将有问题的内存视为该类型的对象。

现在，手动地按元素构造数组的元素以及数组和元素之间的布局兼容性存在一些标准问题（缺陷），因此您必须在一定程度上相信C编译器的ABI和C代码是兼容的（或检查它）。

一般来说，C和C之间的所有互操作都不是由C标准定义的（除了C包含的标准C库的某些部分；即使在这里，也没有要求C使用相同的C库）。您必须了解您对C和C的特定实现是如何互操作的。

Answer 2

Windows使用了一个技巧，将灵活的数组成员设置为大小1（因为Win32API早在该功能进入C99之前就已经开发出来了，更不用说C了）

struct foo {
    int count;
    my_type fam[1];
};

如果您被允许更改 C 版本，请在 C 和 C 中使用相同的结构。如果您无法更改 C 版本，则需要在 C 中重新定义结构。修改 C 结构时，您仍然需要更改 C 代码，但至少它可以很好地编译

参见

• 灵活的数组成员在 C 中有效吗？
• 为什么有些结构以大小为 1 的数组结尾？

Answer 3

据我所知，标准C甚至不接受带有灵活数组成员的结构声明。既然如此，我认为除了(用C)写包装函数别无选择，除非包含FAM的结构类型对你的C代码来说是不透明的。我不确定包装纸是不是你想要的那种垫片。

然而，在我们进一步讨论之前，我应该指出，如果您的C函数接受并返回指向具有灵活数组成员的结构的指针，那么问题与它们传递并返回实际结构的指针有很大不同。我将假设他们确实使用指向这些结构的指针，否则似乎一开始就没有FAM的意义。

我猜给定C声明，例如

struct foo {
    int count;
    my_type fam[];
};

我将在C中表示相同的数据

struct cpp_foo {
    int count;
    my_type *fam;
};

，这当然也可以由C处理。请注意，无法在这些数组之间成功转换，因为数组不是指针。

给定一个C函数

struct foo *do_something(struct foo *input);

所需的包装可能如下所示:

struct cpp_foo *do_something_wrap(struct cpp_foo *input) {
    struct cpp_foo *cpp_output = NULL;

    // Prepare the input structure
    size_t fam_size = input->count * sizeof(*input->fam);
    struct foo *temp = malloc(sizeof(*temp) + fam_size);

    if (!temp) {
        // handle allocation error ...
    } else {
        struct foo *output;

        temp->count = input->count;
        memcpy(temp->fam, input->fam, fam_size);

        // call the function
        output = do_something(temp);

        if (output) {
            // Create a copy of the output in C++ flavor
            cpp_output = malloc(sizeof(*cpp_output));
            if (!cpp_output) {
                // handle allocation error
            } else {
                fam_size = output->count * sizeof(output->fam[0])
                cpp_output->fam = malloc(fam_size);
                if (!cpp_output) // handle allocation error

                memcpy(cpp_output->fam, output->fam, fam_size);

                // Supposing that we are responsible for the output object ...
                free(output);
            }
        } // else cpp_output is already NULL

        free(temp);
    }

    return cpp_output;
}

自然，如果你有几个函数要包装，那么你可能想写可重用的转换函数来简化它。