c++ ejemplo - ¿Cuándo es dynamic_cast<void *>útil?



conversion de (3)

Una razón común es averiguar si dos interfaces IA* y IB* son de hecho punteros al mismo objeto subyacente. Si necesitas eso, usa el molde.

IIRC, incluso es posible en caso de herencia múltiple con una base no virtual repetida tener dos punteros IA* que comparan desiguales, pero apuntan al mismo objeto, ya que apuntan a dos subobjetos IA diferentes.

Esta pregunta ya tiene una respuesta aquí:

5.2.7 / 7 dice algo en la línea de:

Si T es "puntero a cv void ", el resultado es un puntero a la clase más derivada apuntada por x .

¿Qué es una buena aplicación de este synatx? ¿Cuándo debería dynamic_cast<void*> ?


Cuando tienes algo como:

template<typename X, typename Y>
bool operator==(const X* px, const Y* py) {
     return dynamic_cast<void*>(px) == dynamic_cast<void*>(py);
}

Aquí está el enlace para respuestas similares: http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html

Un puntero inteligente es un objeto que actúa, se ve y se siente como un puntero normal pero ofrece más funcionalidad. En C ++, los punteros inteligentes se implementan como clases de plantilla que encapsulan un puntero y anulan los operadores de puntero estándar. Tienen una serie de ventajas sobre los punteros regulares. Se garantiza que se inicialicen como punteros nulos o punteros a un objeto de montón. Se comprueba la dirección a través de un puntero nulo. Nunca es necesario eliminar. Los objetos se liberan automáticamente cuando el último puntero hacia ellos ha desaparecido. Un problema importante con estos punteros inteligentes es que, a diferencia de los punteros regulares, no respetan la herencia. Los punteros inteligentes no son atractivos para el código polimórfico. A continuación se muestra un ejemplo para la implementación de punteros inteligentes.

Ejemplo:

template <class X>
class smart_pointer
{
          public:
               smart_pointer();                          // makes a null pointer
               smart_pointer(const X& x)            // makes pointer to copy of x

               X& operator *( );
               const X& operator*( ) const;
               X* operator->() const;

               smart_pointer(const smart_pointer <X> &);
               const smart_pointer <X> & operator =(const smart_pointer<X>&);
               ~smart_pointer();
          private:
               //...
};

Esta clase implementa un puntero inteligente a un objeto de tipo X. El objeto en sí está ubicado en el montón. Aquí está cómo usarlo:

smart_pointer <employee> p= employee("Harris",1333);

Al igual que otros operadores sobrecargados, p se comportará como un puntero normal,

cout<<*p;
p->raise_salary(0.5);




c++ c++11 casting void-pointers dynamic-cast