C++ Klassen - Zeiger und Zugriff auf Member

[Janes (Gast)]

Moin Zusammen,
ich hätte eine Verständnisfrage zum Thema C++ und zwar basierend auf 
folgendes Beispiel:

#include <iostream>

using namespace std;

class Klasse
{
public:
  int *p;
  Klasse()
  {
    p=nullptr;
  }

};


int main() {
        // Beispiel 1
  Klasse * Schiff[2];
  Schiff[0] = new Klasse;
  Schiff[1] = new Klasse;

  (Schiff[0]->p) = new int;
  *(Schiff[0]->p) = 5;

  cout << *(Schiff[0]->p) << endl;

        // Beispiel 2
  Klasse * Schiff2;
  Schiff2 = new Klasse[2];  

  (Schiff2[0].p) = new int;
  *(Schiff2[0].p) = 5;

  cout << *(Schiff2[0].p) << endl;

Beispiel 1 und Beispiel 2 haben unterschiedliche Zugriffsarten und zwar 
mit "->" und mit ".". Irgendwie hat mich das Beispiel jedoch verwirrt, 
da ich nicht verstehe, wieso es sich unterscheidet.

Im Beispiel 1 deklariere ich mir ja einen Zeiger auf ein Array, dass 
Objekte beinhalten soll. Dann reserviere ich mir mit "new" den 
entsprechenden Speicher. Oder handelt es sich eher um ein Array, dass 
Zeiger auf die Objektinstanzen enthält? Das würde bedeuten, dass z.B. 
Schiff[0] eben einem zeiger entspricht, während im Beispiel 2 Schiff2[0] 
sozusagen aufgrund des "[]" dem Zugriff auf den Zeigerwert entspricht 
und somit "." statt "->" verwendet wird.

Eventuell kann das jemand verständlich ausdrücken.

[Dirk K. (merciless)]

Janes schrieb:
> Im Beispiel 1 deklariere ich mir ja einen Zeiger auf ein Array, dass
> Objekte beinhalten soll. Dann reserviere ich mir mit "new" den
> entsprechenden Speicher. Oder handelt es sich eher um ein Array, dass
> Zeiger auf die Objektinstanzen enthält?
Letzteres.

> während im Beispiel 2 Schiff2[0]
nicht initialisierter Speicher ist.

Ich weiß nicht, wo du den Code gefunden hast, aber
es gibt mit Sicherheit bessere Möglichkeiten, C++
zu lernen.

merciless

[Janes (Gast)]

Ich hatte mir diese Beispiele selbst aufgeschrieben, um mit Zeigern zu 
experimentieren. Es ging mir eher um den Lernfaktor. Es gibt immer 
bessere Möglichkeiten ;)

[C101 (Gast)]

Klar genug?

Schiff
 |         ----------
 |-------->|      --|----|
           ----------    |    ----------
           |      --|-------->|        |
          ----------     |    ~        ~
                         |    |        | 
                         |    ----------
                         |
                         |    ----------
                         |--->|        |
                              ~        ~
                              |        |
                              ----------



Schiff2
 |         ---------- 
 |-------->|        |
           ~        ~
           |        |
           ----------
           |        |
           ~        ~
           |        |
           ----------

[Dirk K. (merciless)]

Janes schrieb:
> [code]
>         // Beispiel 1
>   Klasse * Schiff[2];
Schiff ist ein Array mit Zeigern auf Klasse;

>   Schiff[0] = new Klasse;
>   Schiff[1] = new Klasse;
Jetzt sind beide Zeiger initialisiert, beiden
zeigen jeweils auf ein Objekt von Klasse.

>   (Schiff[0]->p) = new int;
Schiff[0] ist ein Zeiger, also -> -Operator.


>         // Beispiel 2
>   Klasse * Schiff2;
Schiff2 ist ein Zeiger auf Klasse.

>   Schiff2 = new Klasse[2];
Schiff2 zeigt jetzt auf ein Array mit 2 Objekten
von Klasse (Schiff2 zeigt auf das erste Objekt).

>   (Schiff2[0].p) = new int;
Schiff2[0] ist ein Objekt (und/oder eine Referenz
darauf), . -Operator ist hier korrekt.

Meine obige Bemerkung mit dem nicht initialisierten
Speicher ist falsch. Ich war etwas verwirrt durch die
Operatoren.

merciless