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");
}

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.

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");
}

z = static_cast<float>(var);

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

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 ?

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.

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 ?

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;