folgendes bsp.:

Bei der Ausgabe hab ich 2x dieselbe adresse (ist auch logisch für mich)
aber 2x verschiedene Inhalte (unlogisch find ich).

Wie ist das möglich?

#include <iostream>
using namespace std;

int main()
{
    const int i = 7;    
    int& ri = const_cast<int&>(i);

    ri = 9;

    cout << endl << "i = " << i << "\t &i  = " << &i<< endl;   // Inhalt: 7
    cout << endl << "i = " << ri << "\t &ri = " << &ri<< endl; // Inhalt: 9

    system("pause>nul");
    return 0;
}

thx euch

Etwa gleiche Frage:
"Warum hat mein Auto eine Beule, wenn ich doch nur direkt in einen Baum gefahren bin?!"

Du wunderst dich, dass das was anderes ausgibt, wenn du einen const_cast verwendest?!

Naja, ganz offensichtlich ist das ja schon nicht, da sich die Referenz auf das gleiche Objekt bezieht.

const_cast auf Objekte anzuwenden, die ursprünglich const -qualifiziert waren (d.h. nicht nur Referenzen oder Zeiger auf const ), führt zu undefiniertem Verhalten. Ich vermute, hier hat ri den eigentlichen Wert abgeändert, welcher bei der Ausgabe neu vom Speicher gelesen wird, während i direkt als Literal kompiliert wird, da es sich um einen konstanten Ausdruck handelt.

int& ri = const_cast<int&>(i);

funktioniert und das hier nicht:

int& ri = const_cast<int>(i);

Was mich wundert ist, warum denn das hier

int& ri = const_cast<int&>(i);

funktioniert und das hier nicht:

int& ri = const_cast<int>(i);

const_cast<int> erzeugt eine Rvalue, und eine Rvalue kannst du nicht an einen non-const Referenz binden.

EDIT: Unsinn entfernt

const_cast<int> erzeugt eine Rvalue, und eine Rvalue kannst du nicht an einen non-const Referenz binden.

const_cast kann nur Zeiger bzw. Zeiger auf Member oder Referenzen erzeugen.

#include <iostream>
using namespace std;

class A
{};

class B : public A
{};

int main()
{
    A a;
    B& rb = static_cast<B&>(a);

    system("pause>nul");
    return 0;
}

Wieso weiß der Compiler zur Compiletime nicht, dass "a" vom Typ "A" ist ??

Was weiß der Compiler zur Compiletime überhaupt ??
bzw. ich hab gelesen,
dass er weiß, dass "a" von irgendeinem Typen in der Vererbungshierarchie von "A" ist, aber er weiß nicht welcher Typ das genau ist, stimmt das ??

thx a lot

Wieso weiß der Compiler zur Compiletime nicht, dass "a" vom Typ "A" ist ??

Weiß er doch, genau zu dem Zweck hast du doch die Deklaration A a; geschrieben. Dein static_cast danach ist dann allerdings falsch, da a nicht vom Typ B ist.

Wolltest du nicht eigentlich fragen, warum in

B b;
A& ra = static_cast<A&>(b); // der Cast ist übrigens sinnlos

der Compiler nicht weiß, dass ra auf ein Objekt vom Typ B zeigt? Naja, er kann das schon wissen (für die Optimierung), aber er muss nicht, und kann das in komplexeren Fällen auch nicht.

Wieso weiß der Compiler zur Compiletime nicht, dass "a" vom Typ "A" ist ??

Natürlich weiß er das. Wie kommst du da drauf, dass das nicht so wäre?

Was weiß der Compiler zur Compiletime überhaupt ??

Genau die Dinge die im Programm stehen.

edit: Och, bin zu langsam gewesen...

wieso kann der Compiler bei komplexeren Sachen das nicht erkennen?

char c;
cin >> c;
A a;
B b;
A& ra = c == 'Y' ? a : b;

ra kann je nach der Eingabe auf a oder b zeigen, der Compiler kann das also prinzipiell nicht wissen.

Der dynamic_cast arbeitet zur Laufzeit, da kann er natürlich einfach in das Objekt reingucken, welchen Typ es hat.

hustbaer schrieb:

const_cast<int> erzeugt eine Rvalue, und eine Rvalue kannst du nicht an einen non-const Referenz binden.

const_cast kann nur Zeiger bzw. Zeiger auf Member oder Referenzen erzeugen.

OK, auch gut.
Dann eben static_cast<int> . Damit kann er seine non-const Referenz nämlich auch nicht initialisieren.