如何检查 void* 是否指向对象类型的有效实例上的指针？

Question

我正在寻找最常见和最可靠的方法来检查 void* 是否可以在给定的 C++ 对象类型中转换。您可以在下面看到有关上下文的一些信息。

当我为 DLL 定义 C API 时，我经常使用 void* 来隐藏我在后面使用的 C++ 对象（如下所示）

typedef void* Instance_t;
int createInstance(Instance_t* pInst);
int processing(Instance_t inst, uint8_t* pBuf, size_t bufLength);

当我createInstance代码cast这样的指针时：

int createInstance(Instance_t* pInst)
{ 
   MyClass* ptr = new MyClass();
   *pInst = (void*)(ptr);
   //.... etc
   return 0;
 }

但问题是我们如何在稍后定义的所有其他 C 函数中检查我们收到的 void* 值是否是有效 MyClass*。我认为我们不能，因为在这种情况下，没有一个 C++ 强制转换运算符是真正类型安全的（即使是 dynamic_cast）。

目前我最好的解决方案是使用 C 转换（或 reinterpret_cast），如果一切正常，则调用 MyClass 定义的 IsValid 函数。

你有更好的方法来做这个检查吗？

Answer 1

你不能这样做，除非你（比如说）从一个内存池中分配你所有的 MyClass 实例，并检查你传递的地址是指向那个内存池的指针。或者维护一个有效实例列表。

但是，如果您需要传递一个不透明的指针，只需让客户端使用

struct MyClass;
typedef struct MyClass *Instance_t;

这将编译干净，让您放心。只要您只使用指针，编译器就会很高兴。当它取消引用它时，编译器需要知道指针实际指向的内容。

Answer 2

我认为你不能这样做，我认为你不应该这样做。 void * 只是指向内存中某个位置的指针。几乎按照定义，没有办法知道它指向什么。

但是，为什么要将所有内容类型转换为 void *，如果您想防止用户摆弄您类的内部结构，为什么不在您的类上使用受保护的和私有的方法？

Answer 3

没有办法检查无类型指针是否指向任何特定类型的有效对象。如果你使用void*，你就抛弃了类型检查。相反，您可以在 C 标头中声明类型，并使用指向该（不完整）类型的指针而不是 void*。

struct Instance;
int createInstance(struct Instance** pInst);
int processing(struct Instance* inst, uint8_t* pBuf, size_t bufLength);

然后在C++中，就可以定义和使用类了。

// Probably better to use "struct" rather than "class" in case
// some compilers complain about mixing class keys.
struct Instance {
    // Whatever
};

int createInstance(Instance** pInst) {
    *pInst = new Instance;
    // and so on
}

Answer 4

无法确定 void* 是否指向有效的 C++ 类。除非您启用了 RTTI，否则没有与类关联的元数据，即使这样，在 C++ 中也有很多情况，void* 没有指向一个类。例如：

int x=10;
void *ptr = &x;

这里ptr 指向一个原始值。没有与整数关联的 RTTI，所以您如何查询它以确定任何内容>

Answer 5

当我需要将一些对象从我的 CPP 库导出到 C 代码时，我会这样做：

typedef void * OBJ1;
typedef void * OBJ2;

OBJ1 createObj1();
OBJ2 createObj2();

void doObj1(OBJ1 obj);

所以在 do 函数中我完全知道期望什么对象

Answer 6

简短的回答：这可能很困难。

问题很多，但基本上归结为 C 和 C++ 中可访问的操作的非常低级别的性质（注意：可访问，但不一定合法）。 void* 的作用是任何指针都可以被强制指向它，但是如果您使用其他类型，滥用reinterpret_cast 仍然可能导致麻烦。

---

一个简单的解决方案是使用标记。本质上，在指针中放置一个类型 id，以便您始终可以知道对象的原始类型。这很繁重（因为每种类型都需要修改），但很容易部署。

typedef enum {
    SP_ATag,
    SP_BTag,
    SP_CTag,
    ...
} SP_Tag_t;

// External Tag
typedef struct {
    SP_Tag_t tag;
    void* p;
} SP_Any_t;

// Internal Tag
struct A {
    SP_Tag_t tag;
    ...;
};

...

typedef union {
    A* a;
    B* b;
    C* c;
} SP_Any_t;

然后，您使用SP_Any_t，而不是使用void*。

优势：

• 轻量级
• 外部解决方案不需要修改现有类
• 内部解决方案应与现有 C 代码二进制兼容

缺点：

• 一个地方声明所有类型
• 破坏标签很容易（无论是有意还是无意）

---

一个更复杂的解决方案是引入一个每个类型的注册表，这可能是一个很好的调试帮助。缺点是您需要检测现有类型以使其工作，但它仍然很容易，而且它涉及更多的运行时开销。但是，嘿：it works！

template <typename> class Registrable;

//
// class Registry
//
class Registry {
public:
template <typename> friend class Registrable;

template <typename T>
static T* Cast(void*);

private:
struct TagType {};

using Key = std::pair<TagType const*, void*>;
using Store = std::set<Key>;

template <typename T>
static void Register(Registrable<T>* t);

template <typename T>
static void Unregister(Registrable<T>* t);

static Store& Get();
}; // class Registry

template <typename T>
T* Registry::Cast(void* const pointer) {
TagType const* const tag = &Registrable<T>::Tag;

if (Get().count(std::make_pair(tag, pointer)) == 0) { return nullptr; }

return static_cast<T*>(reinterpret_cast<Registrable<T>*>(pointer));
}

template <typename T>
void Registry::Register(Registrable<T>* t) {
TagType const* const tag = &T::Tag;
void* const pointer = reinterpret_cast<void*>(t);

Get().insert(std::make_pair(tag, pointer));
}

template <typename T>
void Registry::Unregister(Registrable<T>* t) {
TagType const* const tag = &T::Tag;
void* const pointer = reinterpret_cast<void*>(t);

Get().erase(std::make_pair(tag, pointer));
}

Registry::Store& Registry::Get() { static Store S; return S; }

//
// class Registrable
//
template <typename T>
class Registrable {
public:
static Registry::TagType const Tag;

Registrable();
~Registrable();

Registrable(Registrable&&) = default;
Registrable& operator=(Registrable&&) = default;

Registrable(Registrable const&) = default;
Registrable& operator=(Registrable const&) = default;
}; // class Registrable

template <typename T> Registry::TagType const Registrable<T>::Tag;

template <typename T>
Registrable<T>::Registrable() { Registry::Register(this); }

template <typename T>
Registrable<T>::~Registrable() { try { Registry::Register(this); } catch(...) {} }

Answer 7

不要使用指针而是使用句柄

• 如果内存在 dll 端，则不要传递指针而是句柄 仅限您的对象
• 如果您的对象的内存由应用程序分配并传递给 dll，则保留这些指针的表并将它们也视为句柄

这适用于单个 dll。当然，如果来自 1.dll 的指针通过应用程序传递给 2.dll，则它不起作用。在这种情况下，无论如何你都在最薄的冰上。

Answer 8

我有一个使用 RTTI 有一些限制的解决方案...

如果您的实例都派生自一个虚拟基类，那么您可以安全地重新解释转换为该基类，然后动态转换为您的其他类...

class Object
{
   virtual ~Object() {}
};

class A : public Object
{
  static bool IsOfThisClass(void *data)
  { 
     return dynamic_cast<A*>((Object*)data) != 0;
  }
}

如果 someData 属于 A 类，则调用 A::IsOfThisClass(someData) 将返回 true。

这不是您想向用户公开的那种 hack，因为它仅在 void* 指向从 Object 派生的类时才有效，但它在受控情况下可能是一个有用的构建块。