将 C 识别的指针类型定义为内部 C++ 类

Question

我想在 C 和 C++ 之间共享一个类，其中 C 只能将它作为指针获取。然而，因为它是一个内部类，它不能被前向声明。相反，这是我们当前代码在一个通用头文件中所做的：

#ifdef __cplusplus
class Container {
public:
    class Object {
        public:
        int x;
    };
};

typedef Container::Object * PObject;
#else

typedef void* PObject;

#endif

这看起来违反了单一定义规则 (ODR)，因为 C 和 C++ 使用 #ifdef 看到不同的定义。但是因为这是一个指针，我不确定这是否会造成真正的问题。 C 仅使用指针将其传递给 C++ 函数，它不直接对它做任何事情。比如通用头文件中的这段代码：

#ifdef __cplusplus
extern "C" {
#endif
int object_GetX(PObject pObject);

#ifdef __cplusplus
}
#endif /* __cplusplus */

这就像我们在 C++ 文件中实现它的方式：

int object_GetX(PObject pObject) {
    return pObject->x;
}

我的问题是：

1. 像这样违反 ODR 会导致任何实际问题吗？
2. 如果是这样，是否有其他方便的方法可以将课程共享给 C？

Answer 1

首先，类型别名指针通常会带来麻烦。
不要这样做。

其次，“内部”类是一个被过度使用的概念，所以我的第一反应是考虑它是否真的有必要。

如果有必要，您可以定义一个不透明的空类型并从它派生以实现某种类型安全：

在共享标头中：

struct OpaqueObject;

#ifdef __cplusplus
extern "C" {
#endif

int object_GetX(OpaqueObject* pObject);

#ifdef __cplusplus
}
#endif /* __cplusplus */

在 C++ 标头中：

struct OpaqueObject {};

class Container {
public:
    class Object : public OpaqueObject {
        public:
        int x;
    };
};

实施：

int object_GetX(OpaqueObject* pObject) {
    return static_cast<Container::Object*>(pObject)->x;
}

Answer 2

像这样违反 ODR 会导致任何实际问题吗？

“真正的问题”？可能是。也许不会。

没有“混合 C/C++ ODR 规则”。规则被“包含”在一种编程语言中，规范是为一种编程语言编写的。 C++ 有自己的规则，C++ 有 ODR 规则。 C有自己的规则，C对ODR一无所知。其他编程语言有自己的规则。

您没有违反 C++ 中的 ODR - C++ 在任何地方都可以看到一个单一的 Container 定义。

extern "C" 中的内容使用 C 调用约定，我可以假设它也遵守 C 语言。在这种情况下，您只是违反了规则 https://port70.net/~nsz/c/c11/n1570.html#6.5.2.2p9 。假设这就像 C 中函数的 ODR。

如果不是，那么您违反了语言之间的某些内容，那就是 ABI。您从 C 端传递 void * 指针的值，而您的函数从 C++ 端读取 Container::Object * 指针的值。这可能是您的编译器正在使用的特定 ABI 允许的，它可能未指定。安全的方法是假设它是不允许的。

还有其他方便的方法可以将课程分享给 C 吗？

C 语言也像 C++ 一样提供静态类型检查，但使用 void * 基本上是关闭它。不要将 C++ 与 C 混用。只需为 C 端取一个不同的唯一名称，您就不会那么困惑了。

另外，pObject 与 PObject？你的班次一定要快！

// object.hpp
#ifdef __cplusplus
class Container {
public:
    class Object {
        public:
        int x;
    };
};

typedef Container::Object PObject;

extern "C" {
#endif  

struct C_PObject {
   void *pnt;
};

int object_GetX(struct C_PObject obj);
// ...

// object_c.cpp
PObject *object_from_c(struct C_PObject obj) {
    return reinterpret_cast<PObject *>(obj.pnt);
}

extern "C"
int object_GetX(struct C_PObject obj) {
    return object_from_c(obj)->x;
}