class tDatum
{
public:
    int Tag;
    int Monat;
    int Jahr;

    tDatum() // Default-Konstruktor
    {
        Tag = 1;
        Monat = 1;
        Jahr = 1970;
        cout << "Konstruktor wurde aufgerufen!" << endl;
    }
};

Soweit ja total simpel. Eine einfache Klasse mit einem Konstruktor.

int main()
{
    tDatum meinDatum;
}

Das ist auch noch total simpel. Ein Objekt der Klasse tDatum wird angelegt, der Konstruktor aufgerufen und fertig.

So jetzt kommt aber der Teil mit der Frage.

int main()
{
    tDatum *irgendwann;
    // irgendwann = new tDatum;
    (*irgendwann).Tag = 10;
}

Erstmal vorweg, ich habe die Zeile mit 'new' absichtlich rausgenommen.

Jetzt die Frage: Wieso kann ich auf das Element Tag zugreifen obwohl das Objekt noch garnicht richtig initialisiert wurde (der Konstruktor wird nicht aufgerufen)?

Bzw. was passiert genau in der Zeile wo der Zeiger angelegt wird?

tDatum *irgendwann;

Jetzt die Frage: Wieso kann ich auf das Element Tag zugreifen obwohl das Objekt noch garnicht richtig initialisiert wurde (der Konstruktor wird nicht aufgerufen)?

kannst du nicht; rein syntaktisch gesehen greifst du auf Tag zu (bzw. auf den speicher, den Tag belegen würde, wenn dort ein ensprechendes objekt wäre) - allerdings benutzt du hier einen nicht initialisierten pointer, und das ist UB (undefiniertes verhalten - es kann alles passieren).

Bzw. was passiert genau in der Zeile wo der Zeiger angelegt wird?

tDatum *irgendwann;

du erhälst einen nicht initialisierten pointer. das einzige was du damit machen darfst, ist ihm etwas zuzuweisen - alles andere ist UB (richtig, du darfst ihn nicht einmal kopieren).

Ein Zeiger wird gültig wenn man ihm die Adresse eines neu erzeugten (new) oder bereits existierenden (&objekt) Objekts zuteilt.

Nichtsdestotrotz kannst Du mit einem Zeiger immer arbeiten, nur dass er uninitialisiert auf Speicher verweist der Dir nicht gehört. Wenn "irgendwann" vom Compiler mit 0 initialisiert wurde, und Du greifst auf den zweiten int-Wert zu dann liest Du damit Adresse 0x8...

Jetzt die Frage: Wieso kann ich auf das Element Tag zugreifen obwohl das Objekt noch garnicht richtig initialisiert wurde (der Konstruktor wird nicht aufgerufen)?

Kannst du nicht. Du hast kein Objekt sondern nur einen Zeiger, der ins Nirvana zeigt. Dereferenzierst du diesen (was du tust), führt das zu undefiniertem Verhalten. Es kann also letztlich alles passieren. Vom GPC bis zum Totalabsturz. Es können auch Nasenkobolde fliegen. Bei gutem Wetter kann aber auch mal scheinbar alles "richtig" funktionieren.

Entscheidend ist, dass der von dir gepostete Code kein legales C++ ist, da du auf ein nichtexistierendes Objekt zugreifst.

Doktor Ruff schrieb:

Jetzt die Frage: Wieso kann ich auf das Element Tag zugreifen obwohl das Objekt noch garnicht richtig initialisiert wurde (der Konstruktor wird nicht aufgerufen)?

kannst du nicht; rein syntaktisch gesehen greifst du auf Tag zu (bzw. auf den speicher, den Tag belegen würde, wenn dort ein ensprechendes objekt wäre) - allerdings benutzt du hier einen nicht initialisierten pointer, und das ist UB (undefiniertes verhalten - es kann alles passieren).

Bzw. was passiert genau in der Zeile wo der Zeiger angelegt wird?

tDatum *irgendwann;

du erhälst einen nicht initialisierten pointer. das einzige was du damit machen darfst, ist ihm etwas zuzuweisen - alles andere ist UB (richtig, du darfst ihn nicht einmal kopieren).

Aso! Ich habe mich nämlich total gewundert, als der Compiler nicht gemeckert hat als ich die Zeile mit 'new' weggelassen habe.

Jetzt die Frage: Wieso kann ich auf das Element Tag zugreifen obwohl das Objekt noch garnicht richtig initialisiert wurde (der Konstruktor wird nicht aufgerufen)?

Kannst du nicht. Du hast kein Objekt sondern nur einen Zeiger, der ins Nirvana zeigt. Dereferenzierst du diesen (was du tust), führt das zu undefiniertem Verhalten. Es kann also letztlich alles passieren. Vom GPC bis zum Totalabsturz. Es können auch Nasenkobolde fliegen. Bei gutem Wetter kann aber auch mal scheinbar alles "richtig" funktionieren.

Entscheidend ist, dass der von dir gepostete Code kein legales C++ ist, da du auf ein nichtexistierendes Objekt zugreifst.

Also sehe ich das richtig, dass man solche Konstrukte auch wenn das Objekt richtig initialisiert wurde vermeiden sollte wegen der Fehleranfälligkeit?

Ja, bei C++ handelt der Programmierer noch eigenverantwortlich!!

IrgendEinTyp* pointer = NULL;

Das führt auf den meisten Plattformen zu einem mehr oder weniger kontrolliertem Absturz falls man drauf zugreift und man darf einen Pointer der auf NUL zeigt auch mit delete löschen.

Nehmen wir mal folgendes an:

int main()
{
    int intVar = 1234;
    int * intZeiger = &intVar;

    // jetzt kommt der riskante Code
    for (::) { intZeiger++; }
}

Wenn ich jetzt den Pointer unendlich oft inkrementiere (wie oben), erreicht dieser irgendwann eine Art Überlauf und fängt wieder von vorne an? Oder kackt mir das Programm irgendwann ab?

Wichtig: Ich will nicht die Variable intVar erhöhen sondern die Adresse auf die der Zeiger zeigt.

Die eigentliche Frage ist: Gibt es bei Adressen auch so eine Art Wertebereich der irgendwie abhängig ist von der Größe des Arbeitspeichers? Und was passiert wenn dieser überschritten wird?

Wenn Du allerdings irgendwann mal intZeiger dereferenzierst - nunja das weisst Du ja jetzt