指向对象开头的指针 (C++)

Question

我需要一种方法来获取指向 C++ 中对象开头的指针。该对象在模板内部使用，因此它可以是任何类型（多态或非多态），并且可能是使用多重继承的对象。

我发现 这篇文章 描述了一种方法（请参阅名为“动态如果 T 是多态类型，则使用 typeid 和dynamic_cast 将其强制转换为 void*。

这在 MSVC 上运行得很好，但是在 GCC (4.x) 上，当它与非多态类型一起使用时，它似乎会失败并抛出编译器错误。

有谁知道一种方法：

• 使 GCC 表现良好，并正确评估 typeid
• 或者另一种方法来做到这一点，它将在 GCC 上编译

下面是我当前用来尝试实现此目的的代码。

template <typename T>
void* dynamicCastToVoidPtr(T *const ptr)
{
    // This is done using a separate function to avoid a compiler error on some 
    // compilers about non-polymorphic types when calling startOfObject
    return dynamic_cast<void*>(ptr);
}

template <typename T>
void* startOfObject(T *const ptr)
{
    // In cases of multiple inheritance, a pointer may point to an offset within 
    // another object
    // This code uses a dynamic_cast to a void* to ensure that the pointer value 
    // is the start of an object and not some offset within an object
    void *start = static_cast<void*>(ptr);
    if(start)
        typeid(start = dynamicCastToVoidPtr(ptr), *ptr);
    return start;
}

template <typename T>
void doSomethingWithInstance(T *const instance)
{
    // Here is where I need to get a void* to the start of the object
    // You can think of this as the deleteInstance function of my memory pool
    // where the void* passed into freeMemory should point to the
    // start of the memory that the memory pool returned previously
    void *start = startOfObject(instance);
    if(start)
        allocator->freeMemory(start);
}

谢谢。

Answer 1

gcc 的确切错误消息是

错误：无法将&n（类型为struct N*）动态转换为类型void*（源类型不是多态的）

这可以通过使用 boost::is_polymorphic 结合 boost::enable_if 和 boost::disable_if 来处理，不幸的是 gcc 阻塞使用显而易见的方法，所以这里是解决方法：

template <class T>
void* address_of_impl(T* p, boost::enable_if< boost::is_polymorphic<T>, int >)
{
  return dynamic_cast<void*>(p);
}

template <class T>
void* address_of_impl(T* p, ...) { return static_cast<void*>(p); }

template <class T>
void* address_of(T* p) { return address_of_impl(p, 0); }

我们使用 SFINAE 发挥我们的优势（省略号始终被认为是重载决策中的最后一个，因此编译器首先尝试使用 dynamic_cast 版本，该版本对于非多态性失败类型，因为 enable_if）。

我在 gcc 3.4 上测试过，它通过了。我正在调查 另一个问题 为什么使用 < code>disable_if 而不是 ... 不起作用。

编辑：

这是一个简单的拼写错误（忘记了 ::type 位）：

template <class T>
typename boost::enable_if< boost::is_polymorphic<T>, void* >::type
address_of(T* p) { return dynamic_cast<void*>(p); }

template <class T>
typename boost::disable_if< boost::is_polymorphic<T>, void* >::type
address_of(T* p) { return static_cast<void*>(p); }

Answer 2

我做了一些调查，您可能在这里发现了 GCC 中的一个错误；我会举报。然而，可能有一些我找不到的规则表明，在这种情况下，逗号运算符左侧的模板函数确实需要实例化，即使整个表达式没有被评估；在这种情况下，本文中的技术就是错误的。

我建议你看看 boost ::type_traits::is_polymorphic 可以为您服务。

Answer 3

我从另一个问题找到了一个解决方案，可以让我在编译时解决如果类型是多态的，那么我可以将其与模板专业化一起使用，以使用正确的类型转换。显然，如果编译器在子对象之间添加填充，则此方法可能会中断，但我希望可以在某些已知情况下添加一些编译时断言来捕获这一点。它在 MSVC 和 GCC 上都能正确编译和运行。

这是计算类型是否是多态的代码。

#define SIMPLE_POLYMORPHIC(TYPE, POLYMORPHIC)   \
    template <>                                 \
    struct IsPolymorphic<TYPE>                  \
    {                                           \
        static const bool value = POLYMORPHIC;  \
    };

template <typename T>
struct IsPolymorphic
{
    struct Derived : public T { virtual ~Derived(); };
    static const bool value = (sizeof(Derived) == sizeof(T));
};

SIMPLE_POLYMORPHIC(int, false);
SIMPLE_POLYMORPHIC(unsigned int, false);
// ... do this for all intrinsic or non-derivable types

根据类型是否多态执行转换的代码。

template <typename T, bool isPolymorphic = IsPolymorphic<T>::value>
struct StartOfObject
{
    static void* getStart(T *const ptr)
    {
        return static_cast<void*>(ptr);
    }
};

template <typename T>
struct StartOfObject<T, true>
{
    static void* getStart(T *const ptr)
    {
        if(ptr)
            return dynamic_cast<void*>(ptr);
        return NULL;
    }
};

以及它的测试用例。

#define CLASS_STUFF(CLASS)      \
    public:                     \
        CLASS() {}              \
        virtual ~CLASS() {}     \
        int m_##CLASS;

class A
{
    CLASS_STUFF(A);
};

class B : public A
{
    CLASS_STUFF(B);
};

class C
{
};

#include <iostream>

int main()
{
    std::cout << IsPolymorphic<A>::value << std::endl;
    std::cout << IsPolymorphic<B>::value << std::endl;
    std::cout << IsPolymorphic<C>::value << std::endl;
    std::cout << IsPolymorphic<int>::value << std::endl;

    StartOfObject<A>::getStart(new A());
    StartOfObject<B>::getStart(new B());
    StartOfObject<C>::getStart(new C());
    StartOfObject<int>::getStart(new int());

    return 0;
};