C++ Klassen - Zeiger und Zugriff auf Member

Gast #5840840
Lesenswert?

Moin Zusammen,
ich hätte eine Verständnisfrage zum Thema C++ und zwar basierend auf 
folgendes Beispiel:
1
#include <iostream>
2

3
using namespace std;
4

5
class Klasse
6
{
7
public:
8
  int *p;
9
  Klasse()
10
  {
11
    p=nullptr;
12
  }
13

14
};
15

16

17
int main() {
18
        // Beispiel 1
19
  Klasse * Schiff[2];
20
  Schiff[0] = new Klasse;
21
  Schiff[1] = new Klasse;
22

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

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

28
        // Beispiel 2
29
  Klasse * Schiff2;
30
  Schiff2 = new Klasse[2];  
31

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

35
  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.
#5840895
Lesenswert?

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
Gast #5841055
Lesenswert?

Klar genug?
1
Schiff
2
 |         ----------
3
 |-------->|      --|----|
4
           ----------    |    ----------
5
           |      --|-------->|        |
6
          ----------     |    ~        ~
7
                         |    |        | 
8
                         |    ----------
9
                         |
10
                         |    ----------
11
                         |--->|        |
12
                              ~        ~
13
                              |        |
14
                              ----------
15

16

17

18
Schiff2
19
 |         ---------- 
20
 |-------->|        |
21
           ~        ~
22
           |        |
23
           ----------
24
           |        |
25
           ~        ~
26
           |        |
27
           ----------
#5841080
Lesenswert?

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

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren