动态转换为 void 指针有实际用途吗？

Question

在 C++ 中，T q =dynamic_cast(p); 构造将指针 p 执行运行时强制转换为其他指针类型 T > 必须出现在 *p 动态类型的继承层次结构中才能成功。一切都很好。

然而，也可以执行dynamic_cast(p)，它将简单地返回一个指向“最派生对象”的指针（参见 C++ 中的 5.2.7::7 11）。我知道这个功能可能在动态转换的实现中免费出现，但它在实践中有用吗？毕竟，它的返回类型最多就是 void*，那么这有什么好处呢？

Answer 1

dynamic_cast() 确实可以用于检查身份，即使处理多重继承也是如此。

试试这个代码：

#include <iostream>

class B {
public:
    virtual ~B() {}
};

class D1 : public B {
};

class D2 : public B {
};

class DD : public D1, public D2 {
};

namespace {
    bool eq(B* b1, B* b2) {
        return b1 == b2;
    }

    bool eqdc(B* b1, B *b2) {
        return dynamic_cast<void*>(b1) == dynamic_cast<void*>(b2);
    }
};

int
main() {
    DD *dd = new DD();
    D1 *d1 = dynamic_cast<D1*>(dd);
    D2 *d2 = dynamic_cast<D2*>(dd);

    std::cout << "eq: " << eq(d1, d2) << ", eqdc: " << eqdc(d1, d2) << "\n";
    return 0;
}

输出：

eq: 0, eqdc: 1

Answer 2

请记住，C++ 允许您以旧的 C 方式做事。

假设我有一些 API，其中我被迫通过类型 void* 走私对象指针，但它最终传递到的回调将知道其动态类型：

struct BaseClass {
    typedef void(*callback_type)(void*);
    virtual callback_type get_callback(void) = 0;
    virtual ~BaseClass() {}
};

struct ActualType: BaseClass {
    callback_type get_callback(void) { return my_callback; }

    static void my_callback(void *p) {
        ActualType *self = static_cast<ActualType*>(p);
        ...
    }
};

void register_callback(BaseClass *p) {
   // service.register_listener(p->get_callback(), p); // WRONG!
   service.register_listener(p->get_callback(), dynamic_cast<void*>(p));
}

错误！代码是错误的，因为它在存在多重继承的情况下失败（并且也不保证在不存在多重继承的情况下工作）。

当然，该 API 并不是很 C++ 风格，如果我继承自 ActualType，即使是“正确”的代码也可能会出错。因此，我不会说这是对 dynamic_cast 的出色使用，但它确实是一种使用。

Answer 3

自 C 时代以来，将指针强制转换为 void* 就具有其重要性。
最合适的地方是操作系统的内存管理器内部。它必须存储您创建的所有指针和对象。通过将其存储在 void* 中，他们将其概括为将任何对象存储到内存管理器数据结构上，该数据结构可以是堆/B+树或简单的数组列表。

为了简单起见，以创建通用项目的列表为例（列表包含完全不同类的项目）。这只有使用 void* 才能实现。

标准规定，对于非法类型转换，dynamic_cast 应该返回 null，并且标准还保证任何指针都应该能够将其类型转换为 void* 并从中返回，只有函数指针除外。

正常应用程序级别的 void* 类型转换的实际使用量非常少，但它广泛用于低级/嵌入式系统。

通常你会想使用reinterpret_cast来处理低级的东西，比如在8086中，它用于偏移相同基址的指针来获取地址，但不限于此。

编辑：
标准表示，即使使用dynamic_cast<>，您也可以将任何指针转换为void*，但没有任何地方表明您不能转换void* > 回到对象。

对于大多数用途来说，它是一条单向街道，但也有一些不可避免的用途。

它只是说 dynamic_cast<> 需要类型信息才能将其转换回请求的类型。

有许多 API 要求您将 void* 传递给某些对象，例如。 java/Jni 代码将对象作为 void* 传递。
如果没有类型信息，您将无法进行转换。如果您有足够的信心，请求的类型是正确的，您可以要求编译器使用一个技巧来执行dynmaic_cast。

看看这段代码：

class Base_Class {public : virtual void dummy() { cout<<"Base\n";} };
class Derived_Class: public Base_Class { int a; public: void dummy() { cout<<"Derived\n";} };
class MostDerivedObject : public Derived_Class {int b; public: void dummy() { cout<<"Most\n";} };
class AnotherMostDerivedObject : public Derived_Class {int c; public: void dummy() { cout<<"AnotherMost\n";} };

int main () {
  try {
    Base_Class * ptr_a = new Derived_Class;
    Base_Class * ptr_b = new MostDerivedObject;
    Derived_Class * ptr_c,*ptr_d;

        ptr_c = dynamic_cast< Derived_Class *>(ptr_a);
        ptr_d = dynamic_cast< Derived_Class *>(ptr_b);

        void* testDerived = dynamic_cast<void*>(ptr_c);
        void* testMost = dynamic_cast<void*>(ptr_d);
        Base_Class* tptrDerived = dynamic_cast<Derived_Class*>(static_cast<Base_Class*>(testDerived));
        tptrDerived->dummy();
        Base_Class* tptrMost = dynamic_cast<Derived_Class*>(static_cast<Base_Class*>(testMost));
        tptrMost->dummy();
        //tptrMost = dynamic_cast<AnotherMostDerivedObject*>(static_cast<Base_Class*>(testMost));
        //tptrMost->dummy(); //fails

    } catch (exception& my_ex) {cout << "Exception: " << my_ex.what();}
    system("pause");
  return 0;
}

如果这有任何不正确的地方，请纠正我。

Answer 4

扩展@BruceAdi的答案并受到此讨论的启发，这里有一个可能需要指针调整的多态情况。假设我们有这个工厂类型的设置：

struct Base { virtual ~Base() = default; /* ... */ };
struct Derived : Base { /* ... */ };

template <typename ...Args>
Base * Factory(Args &&... args)
{
    return ::new Derived(std::forward<Args>(args)...);
}

template <typename ...Args>
Base * InplaceFactory(void * location, Args &&... args)
{
    return ::new (location) Derived(std::forward<Args>(args)...);
}

现在我可以说：

Base * p = Factory();

但是我如何手动清理它？我需要实际的内存地址来调用 ::operator delete：

void * addr = dynamic_cast<void*>(p);

p->~Base();              // OK thanks to virtual destructor

// ::operator delete(p); // Error, wrong address!

::operator delete(addr); // OK

或者我可以重新使用内存：

void * addr = dynamic_cast<void*>(p);
p->~Base();
p = InplaceFactory(addr, "some", "arguments");

delete p;  // OK now

Answer 5

当我们将存储放回内存池但我们只保留指向基类的指针时，它很有用。这种情况我们应该弄清楚原来的地址。

Answer 6

不要在家里这样做

struct Base {
    virtual ~Base ();
};

struct D : Base {};

Base *create () {
    D *p = new D;
    return p;
}

void *destroy1 (Base *b) {
    void *p = dynamic_cast<void*> (b);
    b->~Base ();
    return p;
}

void destroy2 (void *p) {
    operator delete (p);
}

int i = (destroy2 (destroy1 (create ())), i);

警告：如果D定义为：则这不会工作，

struct D : Base {
    void* operator new (size_t);
    void operator delete (void*);
};

并且没有办法让它工作。

Answer 7

这可能是通过 ABI 提供不透明指针的一种方法。不透明指针——更一般地说，不透明数据类型——用于传递对象和其他库代码和客户端代码之间的资源，使得客户端代码可以与库的实现细节隔离。还有其他方法 可以肯定的是，其中一些方法可能更适合特定的用例。

Windows 在其 API 中大量使用不透明指针。例如，我相信，HANDLE 通常是一个不透明的指针，指向您拥有 HANDLE 的实际资源。 HANDLE 可以是内核对象，如文件、GDI 对象和各种类型的用户对象 - 所有这些对象在实现上都必须有很大不同，但都作为 HANDLE 返回 给用户。

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;


/*** LIBRARY.H ***/
namespace lib
{
    typedef void* MYHANDLE;

    void        ShowObject(MYHANDLE h);
    MYHANDLE    CreateObject();
    void        DestroyObject(MYHANDLE);
};

/*** CLIENT CODE ***/
int main()
{
    for( int i = 0; i < 25; ++i )
    {
        cout << "[" << setw(2) << i << "] :";
        lib::MYHANDLE h = lib::CreateObject();
        lib::ShowObject(h);
        lib::DestroyObject(h);
        cout << "\n";
    }
}

/*** LIBRARY.CPP ***/
namespace impl
{
    class Base { public: virtual ~Base() { cout << "[~Base]"; } };
    class Foo   : public Base { public: virtual ~Foo() { cout << "[~Foo]"; } };
    class Bar   : public Base { public: virtual ~Bar() { cout << "[~Bar]"; } };
};

lib::MYHANDLE lib::CreateObject()
{
    static bool init = false;
    if( !init )
    {
        srand((unsigned)time(0));
        init = true;
    }

    if( rand() % 2 )
        return static_cast<impl::Base*>(new impl::Foo);
    else
        return static_cast<impl::Base*>(new impl::Bar);
}

void lib::DestroyObject(lib::MYHANDLE h)
{
    delete static_cast<impl::Base*>(h);
}

void lib::ShowObject(lib::MYHANDLE h)
{
    impl::Foo* foo = dynamic_cast<impl::Foo*>(static_cast<impl::Base*>(h));
    impl::Bar* bar = dynamic_cast<impl::Bar*>(static_cast<impl::Base*>(h));

    if( foo ) 
        cout << "FOO";
    if( bar )
        cout << "BAR";
}