Tipo Conversión/Confusión de lanzamiento en C++

Question

¿Qué es Tipo Conversión y qué es Tipo Fundición?

¿Cuándo debo usar cada uno de ellos?

Detalle: Lo siento si esta es una pregunta obvia; Soy nuevo en C++, provengo de un fondo de rubí y estoy acostumbrado a to_s y to_i y similares.

Answer 1

Conversión es cuando un valor es , um, convertido a un tipo diferente. El resultado es un valor del tipo de destino, y hay reglas para qué resultado de valor de salida de qué entrada (del tipo de fuente).

Por ejemplo:

int i = 3; 
unsigned int j; 
j = i; // the value of "i" is converted to "unsigned int". 

El resultado es el valor unsigned int que es igual al módulo iUINT_MAX+1, y esta regla es parte del lenguaje. Entonces, en este caso, el valor (en inglés) sigue siendo "3", pero es un valor int sin signo de 3, que es sutilmente diferente de un valor int firmado de 3.

Tenga en cuenta que la conversión se realizó automáticamente, solo usamos un valor int firmado en una posición donde se requiere un valor int sin firmar, y el lenguaje define lo que eso significa sin que realmente digamos que estamos convirtiendo. Eso se llama una "conversión implícita".

"Casting" es una conversión explícita.

Por ejemplo:

unsigned int k = (unsigned int)i; 
long l = long(i); 
unsigned int m = static_cast<unsigned int>(i); 

son todos los moldes. Específicamente, de acuerdo con 5.4/2 de la norma, k usa una expresión de conversión , y de acuerdo con 5.2.3/1, l usa una cosa equivalente (excepto que he usado un tipo diferente). m utiliza un "operador de conversión de tipo" (static_cast), pero otras partes de la norma se refieren a esos como "moldes" también.

tipos definidos por el usuario pueden definir "funciones de conversión" que proporcionan normas específicas para la conversión de su tipo a otro tipo, y constructores sola-ARG se utilizan en las conversiones también:

struct Foo { 
    int a; 
    Foo(int b) : a(b) {}     // single-arg constructor 
    Foo(int b, int c) : a(b+c) {}   // two-arg constructor 
    operator float() { return float(a); } // conversion function 
}; 

Foo f(3,4);    // two-arg constructor 
f = static_cast<Foo>(4); // conversion: single-arg constructor is called 
float g = f;    // conversion: conversion function is called 

Answer 2

Fundición clásica (algo así como (Bar)foo en C, utilizado en C++ con reinterpret_cast<>) es cuando se asume que el contenido real de la memoria es una variable de un tipo diferente. La conversión de tipo (es decir, lexical_cast<> de Boost u otras funciones definidas por el usuario que convierten tipos) es cuando se realiza cierta lógica para convertir una variable de un tipo a otro, como entero a una cadena, donde algún código se ejecuta lógicamente para formar un cadena de un entero dado.

También hay conversión estática y dinámica, que se utilizan en herencia, por ejemplo, para forzar el uso de las funciones miembro de un padre en el tipo de un hijo (dynamic_cast<>) o viceversa (static_cast<>). fundición estática también le permite realizar la típica conversión de tipo "implícita" que se produce cuando se hace algo así como:

 
float f = 3.14; 
int i = f; //float converted to int by dropping the fraction 

que se puede reescribir como:

 
float f = 3.14; 
int i = static_cast<int>(f); //same thing 

Answer 3

En C++, cualquier expresión tiene un tipo. cuando usa una expresión de un tipo (digamos tipo S) en un contexto donde se requiere un valor de otro tipo (digamos tipo D), el compilador intenta convertir la expresión de tipo S a tipo D. Si tal conversión implícita no 't existir, esto resulta en un error. El tipo de palabra emitida no es estándar, pero es lo mismo que la conversión.

E.G.

void f(int x){} 

char c; 

f(c); //c is converted from char to int. 

Las conversiones se clasifican y se puede google para promotions vs. conversions para más detalles.

Hay 5 operadores de conversión explícitos en C++ static_cast, const_cast, reinterpret_cast y dynamic_cast, y también la conversión Tipo C-style cast

Answer 4

es cuando realmente convertir un tipo en otro tipo, por ejemplo una cadena en un entero y vice -versa, un tipo de conversión es cuando el contenido real de la memoria no se cambia, pero el compilador lo interpreta de una manera diferente.

Answer 5

La fundición de tipo indica que está tratando un bloque de memoria de manera diferente.

int i = 10; 
int* ip = &i; 
char* cp = reinterpret_cast<char*>(ip); 
if (*cp == 10) // Here, you are treating memory that was declared 
{     // as int to be char. 
} 

La conversión de tipo indica que está convirtiendo un valor de un tipo a otro.

char c = 'A'; 
int i = c; // This coverts a char to an int. 
      // Memory used for c is independent of memory 
      // used for i.