T q = dynamic_cast<T>(p)这种写法对指针p进行运行时转换，将其转换为指向另一个指针类型T，而T必须位于*p的动态类型的继承层次结构中才能成功。这样做通常都是可以的。dynamic_cast<void*>(p)，它将简单地返回一个指向"最派生对象"（参见C++11中的5.2.7::7）的指针。我知道这个特性可能是在实现动态转换时免费提供的，但它在实践中有用吗？毕竟，它的返回类型最多为void*，那么这有什么好处呢？dynamic_cast<void*>() 可以用于检查对象的身份，即使处理多重继承。
尝试以下代码：
#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
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时也可能出错。因此，我不会认为这是一个 brilliant use of dynamic_cast<void*>，但它可以使用。
my_callback 可以使用 dynamic_cast<ActualType*>(static_cast<BaseClass*>(p))，对吧？换句话说，我们可以使用 BaseClass* 作为 C 封装的基础。 - Kerrek SBBaseClass::get_this_for_callback，并让每个派生类完全控制如何打包指针。 - Steve Jessopmy_callback中通过void*传回了p，那么在多重继承的情况下，如果将p转换为最派生类型作为register_listener的第二个参数是否有影响？我问这个问题是因为在my_callback内部，您正在执行一个static_cast到一个ActualType*，所以似乎无论是将指向最派生类型的指针还是指向基类的指针传递给my_callback都没有关系...无论哪种方式，它最终都会成为指向ActualType对象的指针，对吗？ - Jasonvoid*到ActualType*的静态转换仅在输入是ActualType对象的地址时才会产生正确的指针值，因此如果BaseClass恰好是位于不同地址的基类，则会出现错误。 - Steve Jessopvoid*自C语言时代以来就非常重要。最适合的位置是操作系统的内存管理器中，需要存储所有指针和所创建对象的信息。将其存储在void*中，可以将任何对象存储到内存管理器数据结构中，包括堆/ B+树或简单的arraylist。void*实现。void*并从其中转换回来。void*类型转换的实际用途很少，但在低级/嵌入式系统中广泛使用。dynamic_cast<>将任何指针转换为void*，但它并未说明您不能将void*转换回对象。dynamic_cast<>需要类型信息才能将其转换回所请求的类型。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;
}
如果有任何不正确之处，请纠正我。
void*上执行dynamic_cast操作......因此，在通用数据结构中使用dynamic_cast恢复void*的类型是行不通的，即使该void*通过dynamic_cast<void*>生成。执行转换的指针必须是指向完整类类型的指针。 - Jasondynamic_cast的。 - Kerrek SBdynamic_cast<> 是单行道，但如果您确定对象的类型信息，则可以从中获取对象。除此之外，在没有类型信息的情况下，它没有可移植性的用途，除了比较指针。但是，它作为语言功能存在，因为这是可能的，语言只能保证您使用它。 reinterpret_cast<> 也是如此。 - Praveen当我们将存储器放回内存池，但仅保留基类的指针时，这是非常有用的。在这种情况下，我们应该找出原始地址。
p->~T();，然后通过一些提示的工厂（如T::create_inplace(dynamic_cast<void*>(copy_of_p))）进行放置新。 - Kerrek SB在 @BruceAdi 的回答基础上，并受到 this discussion 的启发，这里有一个可能需要指针调整的多态情况。假设我们有这样一个工厂类型的设置：
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
dynamic_cast 可能不是一个好主意。 - Tadeusz Kopec for Ukraine::operator delete。幸运的是，这很容易修复。 - Tadeusz Kopec for Ukraine这可能是通过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";
}
static_cast<Base*>(dynamic_cast<void*>(pointer_to_base)) 是正确的吗？例如，结果指针将无法再次动态转换为void指针，实际上它已经不能再使用了。 - Kerrek SBBase * p;，那么static_cast<Base*>(dynamic_cast<void*>(p))与reinterpret_cast<Base*>(&x)相同，而不是static_cast<Base*>(&x)。 - Kerrek SBdynamic_cast<void*> (new T) 意味着 new T。2）reinterpret_cast<T*> (handle) 应该是 static_cast<T*> (handle)（handle 是一个 void*）。3）在将 impl::Foo*（或 impl::Bar*）转换为 void* 后，唯一可以做的不涉及未定义行为的事情就是将其转换回 impl::Foo*（或 impl::Bar*）。但你不能这样做，因为你甚至不知道你是否有一个 Foo 还是 Bar！4）我会编辑代码以使其正确。 - curiousguystruct 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*);
};
那么这将不会起作用，并且没有办法使其工作。
p也会这样...是否存在这样的情况，即p1 == p2，但dynamic_cast<void*>（p1）！= dynamic_cast<void*>（p2）？ - Kerrek SBp1 != p2，但实际上它们指向相同的对象。我想如果我们有一个以void *为键的索引，那就有意义了。（不过void指针本身将无法使用。） - Kerrek SB