TUTORIAL: Fundición de las variables de

Casting

El casting es al convertir una variable a otro tipo, o tipo de clase derivada. Por ejemplo, si desea convertir un número de punto flotante por ejemplo, de 3,4 a un valor entero 3 necesitaría para emitir ese número de punto flotante a un entero porque el compilador no puede volver a una variable que no es del mismo tipo que el resultado en el derecho había lado de la línea de comandos.

Estilo de C

C El estilo clásico de la fundición es de poner el tipo de retorno de fundición entre paréntesis y luego colocar la variable que desea emitir en el lado derecho. Código de ejemplo sería



lo que resultaría en el valor intFl ser 3, el 0,4 se tiene en cuenta, porque no es parte de un valor entero (sólo números enteros, se redondeará hacia abajo siempre).

Diferentes tipos de fundición

Existen diferentes tipos de variables de calidad de uno a otro, aquí hay una lista de tipos de fundición

const_cast
static_cast
dynamic_cast
reinterpret_cast

Y todos siguen los mismos parámetros

[CODE = cpp]
valor devuelto = casting_type <return <tipo (valor de casting)
E & #46; g & #46;
int value = static_cast <int> (floatValue);
Desde el lenguaje C + +, estas permite verificar mejor el tipo después de que han puesto en la variable.

const_cast

Casting constante es la manera de eliminar la restricción constante de una variable, a veces puede que desee modificar un valor que se celebrará dentro de un valor constante.

[CODE = cpp]
café const int = 3;
int & newCoffees = const_cast <int&> (café);
newCoffees + = 2;
/ / Ahora puede agregar más café a su día y

en que el rendimiento se



porque esa es la primera aparición de la palabra que dentro de la cadena.

static_cast

El reparto estático se utiliza principalmente para la conversión entre los tipos normales, por ejemplo int, float, double, puede hacer los punteros y también de otras variables de los tipos, pero la comprobación de tipos no es tan buena como dynamic_cast si se va a convertir entre las clases.

Los fundamentos del código sería algo similar a

[CODE = cpp]
int pi = 3;
float PIF = static_cast <float> (pi);
[/ CODE]

Esto convertirá a un valor entero a un valor de punto flotante, sin esperar ningún efecto perjudicial, esto es muy similar al estilo C de la conversión, pero este tipo tiene más control en cuestión.

dynamic_cast

Casting dinámica es cuando se quiere convertir de una clase a otra, pero la única restricción es que la clase base tiene que ser polimórfico (por ejemplo, disponer de un método virtual).

Aquí está un ejemplo de la clase base

[CODE = cpp]
basicClass clase (
privado en I + #58;
int x;
público y #58;
basicClass () (x = 0;)
void setX (int value) (x = valor;)

virtual int returnX () (cout << "Hola desde allí, desde la base"; return x;)

);
[/ CODE]

y aquí sería una subclase de base que se hereda de la clase de base

[CODE = cpp]
subclase de la clase & #58; basicClass público (
privado en I + #58;
int y;
público y #58;
subclase () & #58; basicClass () (y = 0;)
/ / Y nuevo a la clase
setY void (int value) (y = value;)
returnY int () (return;)

returnX int () (cout << "Hola desde la subclase" <<endl; return x;)
);
[/ CODE]

la subclase también ha implementado una "y" variable que es muy similar a la X en la que se puede get / set, pero la función returnX también mostrará qué clase está viniendo.

Si usted quería crear una subclase (subclase) y luego convertir a la clase base (basicClass) como

[CODE = cpp]
* subclase sub = nueva subclase ();
sub-> setX (10);
sub-> setY (20);
* basicClass básica = dynamic_cast nuevo <basicClass*> (sub);

cout <<base> returnY ();
[/ CODE]

Asimismo, el código anterior podría hi salida "de la subclase", ya que es la clase real que usted está realmente hablando.

el valor y se sigue celebrando dentro de la clase base que se ha fundido, pero usted no puede "ver" desde la clase base de las llamadas ya que no hay ninguno en la clase, pero si convierte de nuevo a una subclase puede acceder a la "y "de nuevo, porque el yeso convertir el objeto de subclase en la clase de base similar (a la vez que siguen apuntando al mismo lugar en la memoria) ya que ambos tienen cosas similares en común.

[CODE = cpp]
* subclase myNewSub = dynamic_cast <subclass> (básico);
cout <<myNewSub-> returnY ();
[/ CODE]

que se devuelva el valor de Y de 20, ya que ha puesto en la memoria de nuevo a una estructura de la subclase y en que la estructura en Y la memoria llegó al 20.

Para comprobar el resultado puede comprobar el valor de retorno contra 0 (NULL), porque si no ha sido capaz de convertir el tipo que devuelve 0.

[CODE = cpp]
if (myNewSub == 0)
/ / Dynamic_cast no funcionó
[/ CODE]

Cuando se le casting de una clase derivada no es necesario emitir dinámica, porque no es necesario "añadir" algo a la ubicación de la memoria como tal, porque el área dentro de la memoria es lo suficientemente grande como para utilizar la clase base de la subclase, por ejemplo,

[CODE]
* subclase sub = nueva subclase ();
sub-> setX (10);
sub-> setY (20);

/ / No hay necesidad para un casting y dinámica # 46;
* básicos basicClass = sub;

cout <<base> returnY ();
[/ CODE]

sólo tiene que dynamic_cast cuando se está moviendo en la cadena de la herencia.

También puede consultar para cualquier casting mal con el uso de un try y catch, por ejemplo,
[CODE]
try (
* base = dynamic_cast <int> (intValue);
)
catch (std & #58; y #58; bad_cast)
(
cout << "hubo una bad_cast aquí!! "<<Endl;
)
[/ CODE]

reinterpret_cast

El reinterpret_cast en realidad no hace ningún tipo de control, aparte de encaja el tipo de retorno en el zuecos poco del tipo de fundición, y que está sobre él. Usted puede convertir una clase a un vacío y luego de vuelta sin problemas, y también ClassA en un vacío y luego en ClassB, pero si ClassB no era similar a ClassA que sólo volvería con datos divertidos.

[CODE = cpp]
int * AINT = new int (10);
void * bVoid = reinterpret_cast <void*> (AINT);
* float unFlotante = reinterpret_cast <float*> (bVoid);
[/ CODE]

el puntero del unFlotante será una variable float, pero el valor puede ser cualquier cosa, simplemente lo hice y el resultado fue 1.4013e-44, que 1E1 es igual a 10. En caso de que el dynamic_cast trataría de ver si el flotador (afloat) es similar a los tipos AINT.

Conclusión

Yo personalmente sólo con dynamic_cast static_casting para las clases y tipos fundamentales como int, float, etc mejor usar el C + + los métodos de vaciado, porque al menos hay algo de los controles fundamentales.

Que yo hago realmente quieres hacer algún comentario con respecto a cualquier tutorial / post, contesta o PM me .. encantado de ayudar, mejor para compartir el conocimiento.