Förord

En liten artikel om hur man skall använda sig av de 4 typkonverterarna (type cast) operatorerna i C++.

Innehåll

  » Typkonvertering i C++

Typkonvertering i C++

Då och då behöver man konvertera(type casta) sina objekt i C++.
Som bekant kan man tex göra detta:

int a;
long int b;

a = int(b);

Vilket konverterar en long int double till en int och trunkerar innehållet i b (vilket i princip innebär att de översta 32 bitarna kastas bort i b).

ANSI C++ standarden har definerat 4 stycken konverterings(casting) operatorer 'reinterpret_cast', 'static_cast', 'dynamic_cast' och 'const_cast'
för att man skall få bättre kontroll över casting förfarandet. Vilket egentligen innebär att man på ett enkelt sätt via tex. sökning
skall kunna se i koden när man gör en type cast.

Jag tänkte gå igenom dessa olika operatorer och förklara vad de är samt när de bör användas.

reinterpret_cast

Syntax: reinterpret_cast(expression)
Begränsning: Kan ej användas till att konvertera mellan två klasspekare som är relaterade utav arv samt casta från const(vilket const_cast skall användas till).
Förklaring: Konverterar en pekare till vilken typ av pekare som helst samt pekare till integer och tvärtom.
Denna operator beter sig precis som vanlig type casting gör, dvs innehållet som konverteras verifieras inte på något sätt.
Konverterar man från en pekare till en integer så sker detta genom kopiering utav värdet.

Exempel:

En funktion som tar en void pekare som argument.


void MyClassA::Function1(void *aTemp)
{
MyClassB *a;
a = reinterpret_cast(aTemp);
}



static_cast

Syntax: static_cast(expression)
Förklaring:
Konverterar en pekare mellan relaterad klasser. Förälderklassen till ärvda klasser och vice versa.
Kan ej användas till att konvertera mellan två klasspekare som inte är relaterade via arv med varandra.
Samt ingen verifiering görs som kollar om objektet som konverteras är ett fullt kompatibelt objekt med destinations objektets typ.
Detta gör att användaren måste försäkra sig om att konverteringen är "säker". Typchecken som görs för dynamic_cast görs inte här.

Exempel:



class MyClassA {};
class DervMyClassA: public MyClassA {};
MyClassA * x = new MyClassA;
DervMyClassA y = static_cast(x);


eller ett icke pekar exempel:


double d = 1.2345;
int i = static_cast(d);



dynamic_cast

Syntax: dynamic_cast(expression)
Förklaring: Syftet med dynamic_cast är att verifiera konverteringen och att resultatet är ett riktigt objekt utav den begärda klassen.
Kan enbart användas med pekare och referenser till objekt som är relaterade till varandra.


Konverteringexempel:



class MyClassA {};
class DervMyClassA: public MyClassA {};

DervMyClassA x;
MyClassA y;

y = dynamic_cast(&x); // Konverterar till basklassen.



eller ett icke pekar exempel:


double d = 1.2345;
int i = static_cast(d);



const_cast

Syntax: const_cast(expression)
Begränsning: Enbart för manipulera konstant begreppet (const) för ett objekt.
Förklaring: Som sagt enbart för att sätta eller tabort const från ett objekt.

Ett exempel är att tabort const för en sträng innan skickar den som ett argument till en funktion som kräver en icke konstant.



const char * c = "test";
print(const_cast(c));




Lycka till med konverterandet.

0 Kommentarer

Skriv en kommentar på artikeln

Ditt betyg på artikeln

UtmärktLäsvärdIntressantMindre braDålig

Kommentar: