[C++] FF een stomme vraag over type casting

[Verwijderd]

Hoi,

bij deze: Als ik een BYTE (1 byte) cast naar een int (4 bytes) klopt de waarde dan nog? Of wordt de waarde van die 1e byte dan de 1e byte van die int, waardoor je dus:

code:

    1    2    3    4
 | * |     |     |     |

waardoor die dus geen 8 maar uuuh....een veel groter getal voorsteld?

Ik denk dat ik het antwoord al weet (het laatste geval), maar ik moet het heel ff zeker weten...en als dat idd zo is, hoe kan ik dan het beste de waarde casten zodat het wel "klopt"?

[Soultaker]

Nee; je cast de waarde en niet het geheugenadres. Het door jou genoemde effect treed wel op als je een pointer (juist wel een geheugenadres dus) cast:

code:

BYTE A = 5;
LONG B = (LONG)A;          // B == 5
LONG C = *(LONG*)(&A);     // C == onbepaald (en waarschijnlijk geen 5)

[Verwijderd]

Aha...thanx...is inderdaad wel logisch als je er over nadenkt...weer wat geleerd

[^Mo^]

Maar het kan weer niet andersom, toch?
Dus:

code:

    LONG A = 5;
    BYTE B = (BYTE)A;

[Zoijar]

Je moet niet de oude cast operators gebruiken eingelijk. (type)foo is oud. C++ ondersteund nu veel betere, duidelijkere manieren.
Bv reinterpret_cast<> of static_cast<>

Zie hier

[Verwijderd]

nee, de 3 extra bytes worden met nullen gevuld zover ik weet, maar hoe dat bij negatieve waarden zit weet ik niet, dus of -127 -127 wordt of 129, probeer het uit zou ik zeggen

[Verwijderd]

Het proces wat je bedoelt is typcasten. Hiermee kan je een variabele van type veranderen. Dus een long naar een int en een int naar een double. Hierbij wordt altijd informatie toegevoegd of weggelaten. Een praktisch voorbeeld:
Je typcast een een int naar een double. De waarde van je int was 5 en is nu een double dus 5.00. Hier zien we dat er meergeheugen adressen worden gereserveerd voor het opslaan van je variabele.
Andersom is het iets lastiger. Stel we hebben een double met de variabele 5.67 en gaan deze typcasten naar int. De waarde van de variabele wordt dan 5 en niet 6 zoals men zou verwachten. De waarde van de variabele wordt afgehakt tot het aantal geheugenplaatsen waar het type van de variabele voor bedoelt is. Lastig, nietwaar?
In het kort is het typcasten van laag naar hoog geen probleem, de variabele krijgt dan gewoon extra geheugenadressen vrij met de waarde nul, maar van hoog naar laag verlies je altijd informatie omdat de geheugenadressen juist afgekapt worden. Hopelijk dat het zo een beetje duidelijk wordt.

P.S. Ik ben een JAVA man, dus vraag me niet om code in C++

[Soultaker]

Ten eerste: 'andersom' (dus een LONG naar een BYTE cast, bijvoorbeeld) gaat ook perfect, tenzij de LONG niet in de BYTE past (ik weet niet of daar regels voor bestaan, maar in het algemeen heb je er dan vrij weinig meer aan).

Ten tweede: sign bits worden bij casts van waarden gewoon doorgetrokken (dus negatieve getallen kun je ook veilige casten).

HTH.