programacion - ¿Qué es el tipo polimórfico en C++?

polimorfismo genético

Question

Encontré en un artículo que "static_cast se usa para la conversión de tipo no polimórfico y dynamic_cast se usa para la conversión de tipo polimórfico". Entiendo que int y double no son tipos polimórficos.

Sin embargo, también encontré que static_cast se puede usar entre la clase base y la clase derivada. ¿Qué significa aquí el tipo polimórfico? Algunas personas dicen que tipo polimórfico significa la clase base con función virtual. ¿Está bien? ¿Es esta la única situación? ¿Qué más? ¿Alguien puede elaborarme más para mí?

Answer 1

Bueno, la respuesta es simple. Una clase que tiene al menos una función virtual se denomina tipo polimórfico. Esto puede ser solo un destructor también.

Así que lo siguiente es un '' tipo polimórfico''.

struct Test {
virtual ~Test();
};

Answer 2

Creo que la frase completa es " casting de tipo polimórfico". Tiene razón en que static_cast funciona en tipos que no están relacionados por herencia (doble int, etc.) y las otras respuestas señalan cómo funcionan los moldes.

No creo que la declaración implicara la existencia de un tipo polimórfico mítico, solo que static_cast también funciona en tipos no relacionados. Sin embargo, la declaración fue un poco confusa y es bueno aclararla.

Answer 3

Creo que siempre definimos / declaramos el destructor de cualquier clase como virtual, especialmente en un árbol de herencia. Entonces podemos decir que casi todas las clases en un árbol de herencia son polimórficas.

Answer 4

En primer lugar, el artículo no es del todo correcto. dynamic_cast verifica el tipo de un objeto y puede fallar, static_cast no verifica y requiere en gran medida que el programador sepa lo que está haciendo (aunque emitirá errores de compilación para algunos errores graves), pero ambos pueden usarse en situaciones polimórficas . ( dynamic_cast tiene el requisito adicional de que al menos uno de los tipos involucrados tenga un método virtual).

El polimorfismo en C ++, en pocas palabras, está utilizando objetos a través de una interfaz definida por separado . Esa interfaz es la clase base, y casi siempre solo es útil hacer esto cuando tiene métodos virtuales.

Sin embargo, es raro, pero es posible tener polimorfismo sin ningún método virtual; a menudo, esto es un signo de mal diseño o de tener que cumplir con requisitos externos, y debido a eso, no hay manera de dar un buen ejemplo que se ajuste aquí. ("Sabrás cuándo usarlo cuando lo veas", es, desafortunadamente, el mejor consejo que puedo darte aquí).

Ejemplo de polimorfismo:

struct Animal {
virtual ~Animal() {}
virtual void speak() = 0;
};
struct Cat : Animal {
virtual void speak() { std::cout << "meow/n"; }
};
struct Dog : Animal {
virtual void speak() { std::cout << "wouf/n"; }
};
struct Programmer : Animal {
virtual void speak() {
std::clog << "I refuse to participate in this trite example./n";
}
};

Ejercitando las clases anteriores ligeramente, también vea mi ejemplo genérico de fábrica :

std::auto_ptr<Animal> new_animal(std::string const& name) {
if (name == "cat") return std::auto_ptr<Animal>(new Cat());
if (name == "dog") return std::auto_ptr<Animal>(new Dog());
if (name == "human") return std::auto_ptr<Animal>(new Programmer());
throw std::logic_error("unknown animal type");
}
int main(int argc, char** argv) try {
std::auto_ptr<Animal> p = new_animal(argc > 1 ? argv[1] : "human");
p->speak();
return 0;
}
catch (std::exception& e) {
std::clog << "error: " << e.what() << std::endl;
return 1;
}

También es posible usar el polimorfismo sin herencia , ya que es realmente una técnica o estilo de diseño. (Me niego a usar el patrón de palabras de moda aquí ...: P)

Answer 5

static_cast puede realizar conversiones entre punteros a clases relacionadas, no solo de la clase derivada a su base, sino también de una clase base a su derivada. Esto garantiza que al menos las clases sean compatibles si se convierte el objeto adecuado, pero no se realiza una verificación de seguridad durante el tiempo de ejecución para verificar si el objeto que se está convirtiendo es de hecho un objeto completo del tipo de destino. Por lo tanto, depende del programador asegurarse de que la conversión sea segura. Por otro lado, se evita la sobrecarga de las comprobaciones de seguridad de tipo de dynamic_cast.

static_cast también se puede utilizar para realizar cualquier otra conversión no puntero que también se podría realizar de forma implícita, como por ejemplo la conversión estándar entre tipos fundamentales:

double d=3.14159265;
int i = static_cast<int>(d);

dynamic_cast solo se puede utilizar con punteros y referencias a objetos. Su propósito es asegurar que el resultado de la conversión de tipo sea un objeto completo válido de la clase solicitada.

Por lo tanto, dynamic_cast siempre es exitoso cuando lanzamos una clase a una de sus clases base.

// dynamic_cast
#include <iostream>
#include <exception>
using namespace std;
class CBase { virtual void dummy() {} };
class CDerived: public CBase { int a; };
int main () {
try {
CBase * pba = new CDerived;
CBase * pbb = new CBase;
CDerived * pd;
pd = dynamic_cast<CDerived*>(pba);
if (pd==0) cout << "Null pointer on first type-cast" << endl;
pd = dynamic_cast<CDerived*>(pbb);
if (pd==0) cout << "Null pointer on second type-cast" << endl;
} catch (exception& e) {cout << "Exception: " << e.what();}
return 0;
}

Nota de compatibilidad : dynamic_cast requiere la información de tipo de tiempo de ejecución (RTTI) para realizar un seguimiento de los tipos dinámicos. Algunos compiladores admiten esta característica como una opción que está deshabilitada de forma predeterminada. Esto debe estar habilitado para que la verificación del tipo de tiempo de ejecución utilizando dynamic_cast funcione correctamente.

Las funciones virtuales son responsables del polimorfismo en tiempo de ejecución en C ++. Una clase que tiene al menos una función virtual tiene un tipo polimórfico.

Lee mas....

Lee this tambien Se ha escrito claramente que A class that declares or inherits a virtual function is called a polymorphic class.