Typecasting

Hallo wo ist der unterschieden zwischen der Expliziten und der Implitizen Typekonveriterung ?

charVar hat hier den selben wert wie ret.

Ich verstehe nicht wofür diese Casterei sein soll wenn man doch auch einfach schreiben kann: ret = longVar;

#include <iostream>
using namespace std;

int main()
{

long longVar = 99999;

char charVar;
char ret;

charVar = static_cast<char>(longVar);  // Explizite Konvertierung
cout <<"charVar: " <<  charVar << endl;

ret = longVar;

cout << "var: "<< ret << endl;

system("PAUSE");
}

_matze

Da, wo es möglich ist, wird implizit konvertiert. Das macht es dir ein wenig einfacher. Trotzdem wird manchmal eine Warnung rausgehauen, die dich vor eventuellen Fehlern schützen soll. Wenn du z.B. implizit von float nach int casten lässt, wirst du auf einen eventuellen Datenverlust (Nachkommastellen) hingewiesen.

Und manche Casts gehen einfach nicht implizit. Versuch mal, von char* auf char implizit zu casten. Das gibt einen Fehler, den du nur durch explizites Casting umgehen kannst.

Aber ob ich das hier jetzt Implizit oder Explizit caste ist doch egal als Ergebniss wird ja in beiden fällen eine 3 ausgegeben.

Irgendwie erkenne ich noch nicht den Sinn vom Typecasting.

Außer das man es bei bestimmten Sachen unbedingt braucht wenn man z.b. ein const char in ein char machen will....

#include <iostream>

using namespace std;

int main()
{

float var;
int z;

var = 3.3;
z = var;

z = static_cast<int>(var);

cout << z;

system("PAUSE");
}

oops
So muss das ja aber das Ergebniss bleibt das selbe -.-

z = static_cast<float>(var);

SeppJ

Guck dir das mal an:

char a='A';
cout << a << endl;
cout << static_cast<int>(a) <<endl;

@Seppj

Geht auch so:

Ist kein untschied ob mit oder ohne cast.

#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{

char a='A';
int var;

cout << a << endl;

var = a;

cout << var << endl;

system("PAUSE");
}

Hier bei ist mir aber z.b. klar wieso man hier casten muss:

Wenn man das const entfernen will.

#include <iostream>
using namespace std;

int main()
{
const char *pConst = "Text";
char *pVar;

pVar = const_cast<char*>(pConst);

cout << * pVar;

system("PAUSE");
}

Kann mir jemand noch irgendwelche beispiele zeigen wo man etwas nur mit Explizitem Casting lösen kann ?

Nexus

mr_123 schrieb:

Ist kein untschied ob mit oder ohne cast

Doch, ist es. Wie du siehst, brauchst du mehr Code und eine zusätzliche Variable ohne Cast.

mr_123 schrieb:

Kann mir jemand noch irgendwelche beispiele zeigen wo man etwas nur mit Explizitem Casting lösen kann ?

int num = 3;
int denom = 2;
float quotient = static_cast<float>(num) / static_cast<float>(num);
// Wenn du wieder mit dem Variablen-Argument kommst, stell dir eben
// Typen vor, die keine implizite Konvertierung zueinander besitzen.

Derived obj; // Derived von Base abgeleitet, bietet function() an
Base& ref = obj; // Base hat keine Funktion function().
dynamic_cast<Derived&>(ref).function();
// Annahme, dynamischer Typ von ref sei unbekannt, sonst static_cast.

int integer = 123456789;
char* bytes = reinterpret_cast<char*>(&integer);
bytes[0] = 58;

Und wenn du danach suchst, wirst du noch mehr Anwendungen der C++-Cast-Operatoren finden. In einem richtigen Kontext sind diese wohl besser verständlich.

Ist das so richtig ?

int num = 3;
int denom = 2;
float quotient = (float)num / (float)denom; // C Style ?
float quotient = static_cast<float>(num) / static_cast<float>(denom);  // C++ Style ?

Nexus schrieb:

int num = 3;
int denom = 2;
float quotient = static_cast<float>(num) / static_cast<float>(num);

Ein cast reicht

int num = 3;
int denom = 2;
float quotient = float(num) / denom;