C'è qualche differenza tra il tipo di casting e la conversione del tipo?

Question

C'è qualche differenza tra il tipo di conversione di tipo & in C++.

Answer 1

In generale, la fusione si riferisce ad una conversione esplicita, se è fatto da cast di tipo C (T(v) o (T)v) o C++ - ghisa stile (static_cast, const_cast, dynamic_cast o reinterpret_cast). La conversione è generalmente un termine più generico utilizzato per qualsiasi momento una variabile viene convertito in un altro:

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 delle principali differenze si verifica quando si lavora con le stringhe. Non è possibile pronunciare (int) "234" e ottenere l'intero 234. La trasmissione di tipo generalmente funziona solo su tipi di dati numerici primitivi.

Answer 3

Tipo di fusione significa che si prende una stringa di bit e li interpreta in modo diverso. La conversione del tipo significa che trasformi una stringa di bit da una configurazione utile in un contesto a una configurazione utile in un'altra.

Per esempio, supponiamo che io scrivo

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

c ora contenere il carattere 'A', perché se io reinterpretare il numero decimale 65 come personaggio, ho la lettera 'A'. s ora sarà un puntatore a una stringa di caratteri che si trova nella posizione di memoria 65. Questa è quasi sicuramente una cosa inutile da fare, poiché non ho idea di cosa sia in quella posizione di memoria.

itoa(x, s, 10); 

è una conversione di tipo. Questo dovrebbe darmi la stringa "65".

Cioè, con i cast stiamo ancora guardando la stessa locazione di memoria. Stiamo semplicemente interpretando i dati in modo diverso. Con le conversioni stiamo producendo nuovi dati derivati ​​dai vecchi dati, ma non è lo stesso dei vecchi dati.

Answer 4

Tipo di fusione può fare un importo minimo di conversione:

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 

Ma questo potrebbe essere considerato Tipo di conversione:

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 di solito è lo stesso di short o long a seconda del compilatore/CPU NOTA: signed è in genere facoltativo poiché questo è spesso il valore predefinito

Nessuna conversione avviene quando si specificano tutte le variabili occupano lo stesso spazio di 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 produce anche valori strani. Funziona: a) prende indirizzo (posizione dei bit e byte) di double dbl b) considera l'indirizzo come un indirizzo di un unsigned long c) ottiene unsigned long da quella posizione Ovviamente, ci sono alcune applicazioni reali di questa tecnica. Esempi: analisi di un complicato file binario esterno o di CPU con 512 byte di memoria, ecc.