在 C++ 中转发声明静态 C 结构实例

Question

我正在编写一个代码生成器，嗯，实际上是一个数据生成器，它将生成这种形式的数据结构（显然实际的数据结构要复杂得多）：

typedef struct Foo {
  int a;
  struct Foo* foo;
} Foo;

extern Foo f1;
extern Foo f2;

Foo f1 = {1, &f2};
Foo f2 = {2, &f1};

这对于我尝试过的所有 C 和 C++ 编译器都是可移植的。

我想将这些struct实例转发声明为static，以免污染全局变量空间，如：

typedef struct Foo {
  int a;
  struct Foo* foo;
} Foo;

static Foo f1;
static Foo f2;

static Foo f1 = {1, &f2};
static Foo f2 = {2, &f1};

虽然这适用于 gcc 和可能所有的 C 编译器，但上述代码不适用于 C++ 编译器并导致编译错误：

error: redefinition of ‘Foo f1’
error: ‘Foo f1’ previously declared

我明白为什么在 C++ 中会发生这种情况。是否有一个简单的解决方法，不涉及在运行时使用代码来实现可移植到所有 C++ 编译器的相同效果，而无需使用 C 编译器来编译某些文件？

Answer 1

这应该使用 C 或 C++ 编译，并为您提供相同的名称以在两个编译器中访问相同的内容。

#ifdef __cplusplus
 namespace // use anonymous namespace to avoid poluting namespace.
 {
    struct StaticFoos
    {
       static Foo f1;
       static Foo f2;
    };

    Foo StaticFoos::f1 = {1, &StaticFoos::f2};
    Foo StaticFoos::f2 = {2, &StaticFoos::f1};
 }

 static const &Foo f1 = StaticFoos::f1;
 static const &Foo f2 = StaticFoos::f2;
#else
 static Foo f1 = {1, &f2_};
 static Foo f2 = {1, &f1_};
#endif

现在在 C 和 C++ 中，您可以访问 f1 和 f2。

Answer 2

这似乎与 Josh 的回答有类似的效果，但复杂度较低：

#ifdef __cplusplus
namespace {
    extern Foo f1;
    extern Foo f2;

    Foo f1 = {1, &f2};
    Foo f2 = {2, &f1};
}
#else
    static Foo f1;
    static Foo f2;

    Foo f1 = {1, &f2};
    Foo f2 = {2, &f1};
#endif

当为 C++ 编译时，f1 和 f2 的外部定义在目标文件中以可外部链接的符号公开；但是，因为它们位于匿名命名空间内，所以符号会以不会与来自另一个翻译单元的符号冲突的方式进行修改。

使用宏魔法，您可以进行设置，因此只有一个地方可以声明和定义 f1 和 f2，但如果这是机械生成的，则可能没有太多理由这样做。

类似：

#ifdef __cplusplus
#define START_PRIVATES namespace {
#define END_PRIVATES   }
#define PRIVATE extern
#else
#define START_PRIVATES 
#define END_PRIVATES   
#define PRIVATE static
#endif

START_PRIVATES
    PRIVATE Foo f1;
    PRIVATE Foo f2;

    Foo f1 = {1, &f2};
    Foo f2 = {2, &f1};
END_PRIVATES

Answer 3

您试图避免的称为Static Initialization Order Fiasco。您可以使用函数代替，也可以使用默认值初始化各个对象，然后重新设置成员指针。

您的代码示例意味着完全不同的东西。你将不得不重新审视。第一个成功是因为您有一个对象的定义和另一个对象的声明。这适用于 C 和 C++。

extern Foo f1;

这是一个声明和暂定定义。

static Foo f1;

这是struct Foo类型的对象f1的声明和定义。

static Foo f2;

同上。

static Foo f1 = {1, &f2};

这是一个重新定义。您违反了One Definition Rule，它说，翻译单元中的符号必须有一个且准确的定义。除此之外，您可以有多个定义，但当然每个此类事件都必须具有相同的语法和语义。

static Foo f2 = {2, &f1};

同上。

extern Foo fn;
/* some code */
extern Foo fn;
/* some more ... */
Foo fn; /* finally a definition */

这很好，因为可以有多个临时声明。

Answer 4

您不能转发声明对象，只能转发类型。外部解决方案是正确的解决方案。或者，如果您确实需要避免全局命名空间污染，请将它们设为静态并使用您在所有其他人之前调用的函数对其进行初始化。

编辑： Michael Burr 在评论中提到了原因，我想我会将其添加到帖子中：

@dirkgently：它是有效的 C，因为 C标准说：“在一个 翻译单元，每个声明 具有内部链接的标识符 表示相同的对象或函数”。

C++ 没有这样的规则。

编辑：

如另一篇文章所述。您也可以使用匿名命名空间来限制变量的范围。只需将命名空间的内容包装在 #ifdef __cplusplus 中，就可以开始使用了。

Answer 5

我遇到过这个问题。这种限制令人沮丧，我看不出 C++ 与 C 有这种无缘无故的不兼容的任何原因。

我的解决方案是使用静态函数——您可以转发声明——它只返回 f1 和 f2：

typedef struct Foo {
  int a;
  struct Foo* foo;
} Foo;

static Foo* link_f1();
static Foo* link_f2();

static Foo f1 = {1, link_f2()};
static Foo f2 = {2, link_f1()};

static Foo* link_f1() { return &f1; }
static Foo* link_f2() { return &f2; }

很遗憾，这不是有效的 C，因此您仍然需要 C 和 C++ 的不同代码。

Answer 6

我会创建两个文件（.cpp 和 .h）：

code.h:

typedef struct Foo {
  Foo() {}
  Foo(int aa, struct Foo* ff) : a(aa), foo(ff) {}
  int a;
  struct Foo* foo;
} Foo;

static Foo f1;
static Foo f2;

code.cpp:

void myfun()
    {
    f1 = Foo(1, &f2);
    f2 = Foo(2, &f1);
    }

我还希望将所有变量（如 f1、f2 ...）放入某种“存储”对象（属于我自己的类或某些 STL 容器）。然后，我会将这个对象定义为静态对象。

Answer 7

这是我在项目中所做的。我没有尝试使用匿名命名空间来解决这个问题，而是使用了命名命名空间。

[ 然后感谢 Matt McNabb 的帮助 cmets，事实证明，匿名命名空间将成为一个超级整洁的解决方案，它使用更少的宏，不会产生外部名称污染。 ]

这允许我有两个独立的程序文本区域，中间有常规文件范围，以获得整洁的解决方案：

一切都隐藏在这些宏后面：

#ifdef __cplusplus
#define static_forward(decl) namespace { extern decl; }
#define static_def(def) namespace { def; }
#else
#define static_forward(decl) static decl;
#define static_def(def) static def;
#endif

所以我们可以这样做：

static_forward(struct foo foo_instance)

void some_function(void)
{
  do_something_with(&foo_instance);
}

static_def(struct foo foo_instance = { 1, 2, 3 })

C 扩展很简单，如下所示：

static struct foo foo_instance;

void some_function(void)
{
  do_something_with(&foo_instance);
}

static struct foo foo_instance = { 1, 2, 3 };

C++ 扩展如下所示：

namespace { extern struct foo foo_instance; }

void some_function(void)
{
  do_something_with(&foo_instance);
}

namespace { struct foo foo_instance = { 1, 2, 3 }; }

因此，简而言之，由于匿名命名空间，C++ 实际上并没有静态前向引用问题，只有以 C 不兼容的方式实现它的问题，这可以与宏桥接。

同一个翻译单元中的多个匿名命名空间区域是同一个命名空间，命名空间外的周围文件范围可以看到。