Erstmal mein Code:

int rInt[5];
	int *pInt = &rInt[0];
	cout << *pInt;

Eigentlich wollte ich *pInt auf den ersten Eintrag von rInt zeigen.
Die Ausgabe ist aber -858993460 und nicht wie erwartet 0. Woran liegt das nun?

int *p = k;

int rInt[5] = { 0 };

sollte es gehen.

Die Ausgabe ist aber -858993460 und nicht wie erwartet 0. Woran liegt das nun?

vielleicht solltest du dein array mal initialisieren

int* p = &r[0];

funktioniert es, wenn r vorher initialisiert wurde.

Was ich nicht verstehe.. wenn ich einen Vektor erstelle..:

vector<int> v(1);

.. dann ist

v.at(0)

ja auch automatisch mit 0 initialisiert worden. Warum ist das beim Array nicht auch einfach so der Fall?

Und noch was..

int* p = r; // und
int* p = &r[0];

sind identisch. Die 2. Zeile verstehe ich auch, aber wie kommt man auf die erste?

int foo; // <- Reserviert lediglich Speicher (auf dem Stack) für ein int-Objekt.
int foo[2]; // <- Dto eben für zwei int-Objekte, wobei foo ein Zeiger auf das erste int-Objekt ist.

Die Betonung liegt hier auf Reservierung. Die Speicherbereiche sind allesamt nicht initialisiert (sprich: Es wird kein Wert zugewiesen, ein Zugriff liefert nur das zutage, was sich zufällig gerade dort befindet).

Letzeres gilt jedoch nur für die "builtin-typen". Bei eigenen Typen (Klassen) wird der Default-Konstruktor aufgerufen:

MyClass foo[4]; // <- vier mal wird der Default-Ctor aufgerufen, die Objekte liegen auf dem Stack.
    // foo ist ein Zeiger auf das erste MyClass-Objekt.

int* foo = new int[2]; // <- Reserviert Speicher für zwei int-Objekte auf dem Heap und
    // erzeugt zwei neue int-Objekte (Aufruf des Default-Konstruktors).

Die Speicherreservierung auf dem Heap ist genau das, was im Inneren des std::vectors erfolgt.

int *foo = &bar[0]; // <- Ist gleichbedeutend mit:
int* foo = &bar;

wobei &bar[n] == &bar + sizeof(type) * n ist.

Grüße...

Heiko

int *foo = &bar[0]; // <- Ist gleichbedeutend mit:
int* foo = &bar;

wobei &bar[n] == &bar + sizeof(type) * n ist.

Du meinst wohl..

int *foo = &bar[0]; // <- Ist gleichbedeutend mit:
int* foo = bar;

wobei &bar[n] = bar + sizeof(type) * n ist.

oder?

int* foo = new int[2]; // <- Reserviert Speicher für zwei int-Objekte auf dem Heap und
    // erzeugt zwei neue int-Objekte (Aufruf des Default-Konstruktors).

Nicht ganz, auch hier wird nicht Initialisiert. Man kann die Defaultinitialisierung aber erzwingen:

int* foo = new int[2] ();

wobei &bar[n] == &bar + sizeof(type) * n ist.

Die Zeigerarithmetik berücksichtigt die Objektgröße bereits!
&bar[n] == bar + n

bwbg schrieb:

int* foo = new int[2]; // <- Reserviert Speicher für zwei int-Objekte auf dem Heap und
    // erzeugt zwei neue int-Objekte (Aufruf des Default-Konstruktors).

Nicht ganz, auch hier wird nicht Initialisiert. Man kann die Defaultinitialisierung aber erzwingen:

int* foo = new int[2] ();

Wusste ich bis dato auch nicht, werde mir das aber mal aneignen. Diese Beispiel hatte ich zuvor ausprobiert und es wurden alle Elemente des Arrays (hier int) mit 0 initialisiert. Lediglich auf dem Stack wurden diese nicht initialisiert.

LordJaxom schrieb:

wobei &bar[n] == &bar + sizeof(type) * n ist.

Die Zeigerarithmetik berücksichtigt die Objektgröße bereits!
&bar[n] == bar + n

Das wollte ich nur noch einmal verdeutlichen.

Wusste ich bis dato auch nicht, werde mir das aber mal aneignen. Diese Beispiel hatte ich zuvor ausprobiert und es wurden alle Elemente des Arrays (hier int) mit 0 initialisiert. Lediglich auf dem Stack wurden diese nicht initialisiert.

Diese Beobachtung habe ich bei manchen Compilern auch gemacht. Bei anderen jedoch nicht (wobei verschiedene GCCs und MSVCs als Grundlage dienten), und wenn ich den Standard richtig interpretiere darf man sich auch nicht darauf verlassen.