是否有实际用途的dynamic铸造无效指针?

在C ++中, T q = dynamic_cast<T>(p); 构造执行一个指针p到一些其他指针typesT的运行时间转换,它必须出现在dynamictypes*p的inheritance层次结构中才能成功。 这一切都很好。

但是,也可以执行dynamic_cast<void*>(p) ,它将简单地返回一个指向“最大派生对象”的指针(参见C ++ 11中的5.2.7 :: 7)。 我明白,这个function可能在dynamic演员的执行中免费出来,但是在实践中有用吗? 毕竟,它的返回types至多是void* ,所以这有什么好处呢?

7 Solutions collect form web for “是否有实际用途的dynamic铸造无效指针?”

dynamic_cast<void*>()确实可以用来检查身份,即使处理多重inheritance。

试试这个代码:

 #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 

请记住,C ++可以让你以旧C的方式来做事情。

假设我有一些API被迫通过void*types走私对象指针,但是最终传递给它的callback将知道它的dynamictypes:

 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)); } 

错的! 代码是错误的,因为它在多重inheritance的情况下失败(并且不保证在没有的情况下工作)。

当然,这个API并不是非常的C ++风格,如果我inheritance了ActualType那么即使是“正确的”代码也会出错。 所以我不会声称这是一个辉煌的使用dynamic_cast<void*> ,但它是一个用途。

投射指向void*指针自C天以来就具有其重要性。 操作系统内存pipe理器内部最合适的地方。 它必须存储你创build的所有指针和对象。 通过将其存储在void *中,它将其推广到将任何对象存储到可能是heap/B+Tree或简单数组列表的内存pipe理器数据结构上。

为了简单起见,创build一个通用项目list的例子(列表包含完全不同的类的项目)。 这将只能使用void*

标准说dynamic_cast应该为非法types转换返回null,标准还保证任何指针都能够将types转换为void *,并且只有函数指针除外。

对于void*types转换,正常应用程序的实际使用情况非常less,但是它被广泛用于低级/embedded式系统。

通常你会想使用reinterpret_cast作为低级别的东西,就像在8086中,它被用来抵消同一个基地址的指针来获取地址,但不限于此。

编辑:标准说,即使使用dynamic_cast<> ,您可以将任何指针转换为void* ,但不能在其中声明不能将void*转换回对象。

对于大多数用法,它是一条单行道,但有一些不可避免的用法。

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

有很多API要求你将void*传递给某个对象。 java / Jni代码以void*传递对象。
没有types信息,你不能做铸造。 如果你足够自信,请求的types是正确的,你可以让编译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; } 

请纠正我,如果这是不正确的任何方式。

当我们把存储放回内存池时,它是有用的,但是我们只保留一个指向基类的指针。 这个情况我们应该找出原来的地址。

根据@ BruceAdi的回答,并从这个讨论中得到启发,这里有一个可能需要指针调整的多态情况。 假设我们有这个工厂types的设置:

 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 

不要在家里这样做

 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 *);
 };

而且没有办法使它工作。

这可能是通过ABI提供不透明指针的一种方法。 不透明指针 – 更一般地说, 不透明数据types – 用于在库代码和客户端代码之间传递对象和其他资源,以便客户端代码可以与库的实现细节隔离。 还有其他 方法可以做到这一点,可以肯定的是,其中一些方法对于特定用例会更好。

Windows在其API中大量使用了不透明指针。 HANDLE ,我相信HANDLE通常是一个指向实际资源的不透明指针。 HANDLE可以是文件,GDI对象等内核对象,也可以是各种types的用户对象 – 所有这些对象在执行时必须有很大的不同,但都是作为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"; } 
  • 如何判断一个.NET程序集是dynamic的?
  • 何时使用dynamic库和静态库
  • dynamic加载python模块
  • 我如何反映dynamic对象的成员?
  • 如何dynamic新的匿名类?
  • 在.NET 4.0中dynamic实现接口(C#)
  • dynamic编程 - 最大的方形块
  • 什么是使用JavaScript编写HTML的正确方法?
  • 连接器是做什么的?
  • 如何根据名字dynamic调用方法?
  • Javascript从stringdynamic调用对象方法