¿Hay alguna diferencia entre conversión de tipo y conversión de tipo?

Question

¿Hay alguna diferencia entre conversión de tipo & tipo en C++.

Answer 1

Generalmente, la fundición se refiere a una conversión explícita, ya sea hecho por la conversión de estilo C (T(v) o (T)v) o C++ - Reparto estilo (static_cast, const_cast, dynamic_cast, o reinterpret_cast). La conversión es generalmente un término más genérico que se utiliza para cualquier momento una variable se convierte a otra:

std::string s = "foo"; // Conversion from char[] to char* to std::string 
int i = 4.3; // Conversion from float to int 
float *f = reinterpret_cast<float*>(&i); // (illegal) conversion from int* to float* 

Answer 2

Una de las principales diferencias se produce cuando trabajas con cadenas. No puede decir (int) "234" y obtener el número entero 234. La conversión de tipo generalmente solo funciona en tipos de datos numéricos primitivos.

Answer 3

Tipo de fundición significa que se toma una cadena de bits e interpretar de manera diferente. La conversión de tipo significa que transforma una cadena de bits de una configuración útil en un contexto a una configuración útil en otro.

Por ejemplo, supongamos que yo escribo

int x=65; 
char c=(char) x; 
char* s=(char*) x; 

c contendrá ahora el carácter 'A', porque si reinterpretar el número decimal 65 como un personaje, tengo la letra 'A'. s ahora será un puntero a una cadena de caracteres que resida en la ubicación 65 de la memoria. Esto es casi seguro algo inútil, ya que no tengo idea de qué hay en esa ubicación de la memoria.

itoa(x, s, 10); 

es una conversión de tipo. Eso debería darme la cadena "65".

Es decir, con los moldes todavía estamos buscando en la misma ubicación de memoria. Simplemente estamos interpretando los datos allí de manera diferente. Con las conversiones estamos produciendo nuevos datos que se derivan de los datos antiguos, pero no es lo mismo que los datos anteriores.

Answer 4

Tipo de colada puede hacer una cantidad mínima de conversión:

signed char Schar; // 1 byte (8 bits) to hold 256 values: -128 to 127 
unsigned char Uchar; // 1 byte (8 bits) to hold 256 values: 0 to 255 
... 
if (Schar < -10 ) ... // compiler uses SIGNED comparision 
Uchar = Schar; // implicit conversion only copies the 8 bits 
Uchar = (char) Schar; // explicit conversion may be required by compiler 
if (Uchar > 200) ... // compiler uses UNSIGNED comparision 
...OR... 
if ((unsigned char) Schar > 200) ... // explicit conversion for UNSIGNED comparision 

short Sshort; // 2 bytes (16 bits) to hold 65536 values: -32768 to 32767 
unsigned short Ushort; // 2 bytes (16 bits) to hold 65536 values: 0 to 65536 
... 
// when moving 8 bits into 16 bit variables, what to do with other 8 bits ? 
Sshort = (signed short) Uchar; // move 8 bits over and use 0s for other 8 bits 
Sshort = (signed short) Schar; // same, but use 1s if negative to make Sshort negative 

Pero esto podría ser considerado Tipo de conversión:

float dbl; // 4 bytes to store floating number in IEEE format 
long lng; // 4 bytes to store 32 bit integer value in 2's complement format 
... 
dbl = lng; // convert from 2's comp to IEEE format - all bits change ! 
dbl = (float) lng; // explicit form 

NOTA: int suele ser el mismo que short o long dependiendo del compilador/CPU NOTA: signed suele ser opcional, ya que suele ser el valor predeterminado

Sin conversión tiene lugar cuando se especifica todas las variables ocupan el mismo espacio de memoria:

typedef union MYUNION // all members occupy same space (memory bytes) 
{ 
    signed char Schar; // usual default for char 
    unsigned char Uchar; 
    signed short Sshort; // usual default for short 
    unsigned short Ushort; 
    signed long Slong; // usual default for long 
    unsigned long Ulong; 
    float flt; 
    double dbl; 
}; 

MYUNION myunion; 

myunion.Schar = ... // set variable (memory byte) to value 

if ((unsigned char) myunion.Schar > 200) ... // unsigned compare works ok 
... is same as (also without moving any data around) ... 
if (myunion.Uchar > 200) ... // unsigned compare works ok 

... myunion.Sshort ... // other 8 bits are UNASSIGNED GARBAGE ! 

myunion.Sshort = myunion.Schar; // provide all 16 bits from Schar 
... myunion.Sshort ... // Sshort of valid now 

myunion.dbl = 12345.0; 
... myunion.Ulong ... // has weird value from odd IEEE bit format 

myunion.Ulong = (unsigned long) myunion.dbl; // do explicit conversion 
... myunion.Ulong ... // has CONVERTED 12345 value 

NOTA: *(unsigned long*)&dbl también produce valores extraños. Lo hace: a) tomar la dirección (ubicación de los bits y bytes) de doble dbl b) considerar la dirección como una dirección de un largo sin signo c) obtener unsigned desde esa ubicación Por supuesto, hay algunas aplicaciones reales de esta técnica. Ejemplos: analizar un archivo binario externo complicado o en CPU con 512 bytes de memoria, etc.