Есть ли разница между типом и типом преобразования?

Question

Есть ли разница между типом отливки & Тип преобразования в C++.

Answer 1

Вообще, отливка относится к явному приведению, является ли это сделано C-стиль гипса (T(v) или (T)v) или C++ - стиль гипс (static_cast, const_cast, dynamic_cast или reinterpret_cast). Конверсия, как правило, более общий термин, используемый для любого времени переменная преобразуется в другую:

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

Одна из основных отличий возникает, когда вы работаете со строками. Вы не можете сказать (int) «234» и получить целое число 234. Тип casting обычно работает только с примитивными числовыми типами данных.

Answer 3

Тип отливки означает, что вы берете строку битов и интерпретировать их по-разному. Преобразование типов означает, что вы преобразовываете строку бит из конфигурации, полезной в одном контексте, в конфигурацию, полезную в другой.

Например, предположим, что я пишу

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

с теперь будет содержать символ «A», потому что если я переосмысливать десятичное число 65 в качестве символа, я получаю букву «А». s теперь будет указателем на строку символов, находящуюся в памяти 65. Это почти бесполезно, поскольку я не знаю, что находится в этом месте памяти.

itoa(x, s, 10); 

- это тип преобразования. Это должно дать мне строку «65».

То есть, с литьем мы все еще смотрим на то же место памяти. Мы просто интерпретируем данные по-разному. При конверсиях мы создаем новые данные, полученные из старых данных, но это не то же самое, что старые данные.

Answer 4

Тип отливка может сделать минимальное количество преобразования:

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 

Но это можно считать Тип преобразования:

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 

Примечание: int, как правило, такой же, как short или long в зависимости от компилятора/CPU ПРИМЕЧАНИЕ: signed обычно является необязательным, так как это часто используется по умолчанию

Без преобразования происходит, когда вы задаете все переменные занимают то же пространство памяти:

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 

Примечание: *(unsigned long*)&dbl также производит странные значения. Он: a) принимает адрес (расположение битов и байтов) двойного dbl b) рассматривает адрес как адрес unsigned long c) получает без знака длинный из этого места Конечно, есть некоторые реальные приложения этой техники. Примеры: анализ сложного внешнего двоичного файла или на процессорах с 512 байт памяти и т. Д.