Zeiger innerhalb einer Klasse - Zugriff?

[Frank (Gast)]

Guten Morgen,
kann mir jemand sagen, ob es möglich ist, Zeiger innerhalb einer Klasse 
zu deklarieren und darauf dann über eine Klassen Instanz auf dem Stack 
zuzugreifen?

Beispiel:

class CSpieler 
{
  public:
  int *ptr;
};

// Hauptprogramm
//
int main ()
{
  CSpieler Spieler1;
  Spieler1.ptr = 50;
  
  system ("Pause");
  return 0;
}

Das Beispiel funktioniert so aber nicht. Oder ist es erforderlich mit 
new eine neue Instanz zu erstellen?

[J. F. (Firma: Père Lachaise) (rect)]

Ohne deine genaue Absicht zu erkennen, möchtest du sowas?

*(Spieler1.ptr) = 50;

Oder sowas?

Spieler1.ptr = (int*)50;

[Frank (Gast)]

Ich habe meine Fehler gefunden. Mein Zeiger "ptr" zeigt auf keine 
Adresse und das, was ich versuche ist eine Zuweisung eines int-Wertes. 
Der Zeiger kann aber lediglich Adressen speichern.

Dennoch verstehe ich eine Sache nicht. Warum heißt es nicht 
"(Spieler1.(*ptr))"? Spieler1 ist doch eine Instanz auf dem Stack. Wäre 
Spieler1 auf dem Heap, würde ich z.B. wie folgt auf Member zugreifen: 
Spieler1->ptr oder *(Spieler1.ptr). Aber ich habe nur einen Zeiger als 
Member einer Klasse, die Klasse selbst aber kein zeiger. warum dennoch 
die selbe Schreibweise?

[ui (Gast)]

Frank schrieb:
> Dennoch verstehe ich eine Sache nicht. Warum heißt es nicht
> "(Spieler1.(*ptr))"? Spieler1 ist doch eine Instanz auf dem Stack. Wäre
> Spieler1 auf dem Heap, würde ich z.B. wie folgt auf Member zugreifen:
> Spieler1->ptr oder *(Spieler1.ptr). Aber ich habe nur einen Zeiger als
> Member einer Klasse, die Klasse selbst aber kein zeiger. warum dennoch
> die selbe Schreibweise?

Es spielt eigentlich keine Rolle ob der Spieler auf dem Heap oder Stack 
ist (aus Sicht der Syntax). Wo er genau liegt gibt dir dein 
Betriebssystem. Du musst dich nur u.U. selbst darum kümmern.

[nicht"Gast" (Gast)]

Hä?

viel verwirrendes Zeug, was du schreibst :)


Frank schrieb:
> Ich habe meine Fehler gefunden. Mein Zeiger "ptr" zeigt auf keine
> Adresse und das, was ich versuche ist eine Zuweisung eines int-Wertes.
> Der Zeiger kann aber lediglich Adressen speichern.

Du kannst ja im Konstruktor deinem Zeiger etwas Speicher mit new 
zuweisen.

Frank schrieb:
> wäre
> Spieler1 auf dem Heap, würde ich z.B. wie folgt auf Member zugreifen:
> Spieler1->ptr oder *(Spieler1.ptr).

Das erste ist richtig, das zweite nicht. Das müsste (*Spieler1).ptr 
heißen.


Zum Schluss. Spieler1.ptr gibt dir einen Zeiger auf einen int zurück, 
den du mit * dereferenzieren muss. Macht am Ende des Tages 
*Spieler1.ptr. Die Klammern sind unnötig, da '.' eine höhere prio 
genießt als '*'

[M.K. B. (mkbit)]

Nachdem meine Vorgänger bereits ausführlich die Syntax erklärt haben, 
hier noch eine paar Punkte zum Design.
Mir fallen spontan drei Fälle ein, warum man etwas mit oder ohne Pointer 
in einer Klasse speichert.

1) Die Klasse soll Zugriff auf einen externen int haben.

class CSpieler 
{
  public:
  int *ptr;
};

int main ()
{
  int i = 50;
  CSpieler Spieler1;
  *Spieler1.ptr = &i;
}

1a) Wenn der Zeiger auf den externen Integer sich nie ändert und schon 
bei der Konstruktion feststeht, kann du auch eine Referenz nehmen (die 
kann dann auch kein null_ptr sein). Allerdings muss man diese im 
Konstruktor setzen.

class CSpieler 
{
  public:
  CSpieler(int &x) : n(x) {}
  int &n;
};

int main ()
{
  int i = 50;
  CSpieler Spieler1(i);
}

2) Die Klasse soll den Integer nur als Parameter haben. In diesem Fall 
kannst du den Wert direkt in einen Member kopieren. Vom Speicherplatz 
macht es beim int keinen Unterschied zum Pointer, allerdings ist der 
Pointerzugriff evtl. langsamer, weil beim Zugriff erst der Pointer aus 
der Klasse geladen werden muss und dann anhand dieser Adresse im 
Speicher der Wert des int.

3) Die Variante 2 ist nicht gewünscht, weil es statt dem int eine 
größere Datenstruktur ist, die nicht auf dem Stack liegen soll. Oder 
weil man die Lebenszeit der Struktur unabhängig von CSpieler 
kontrollieren möchte.
Ich verwende einen unique_ptr, damit der Speicher in jedem Fall wieder 
freigegeben wird. Sonst könnte man vergessen im Destruktor den Speicher 
für den int wieder freizugeben.

class CSpieler 
{
  public:
  CSpieler() : ptr(new int) // Speicher für den int anlegen.
  std::unique_ptr<int> ptr;
};

int main ()
{
  int i = 50;
  CSpieler Spieler1;
  *Spieler1.ptr = &i;
}

[Rolf M. (rmagnus)]

Frank schrieb:
> Ich habe meine Fehler gefunden. Mein Zeiger "ptr" zeigt auf keine
> Adresse und das, was ich versuche ist eine Zuweisung eines int-Wertes.
> Der Zeiger kann aber lediglich Adressen speichern.

Richtig.

> Dennoch verstehe ich eine Sache nicht. Warum heißt es nicht
> "(Spieler1.(*ptr))"? Spieler1 ist doch eine Instanz auf dem Stack. Wäre
> Spieler1 auf dem Heap, würde ich z.B. wie folgt auf Member zugreifen:
> Spieler1->ptr oder *(Spieler1.ptr).

Es ist vollkommen irrelevant, wo die Instanz liegt. Die Syntax hängt 
nicht davon ab, wo das Objekt liegt, auf das du zugreifst, sondern nur 
davon, wie  du darauf zugreifst.

> Aber ich habe nur einen Zeiger als Member einer Klasse, die Klasse selbst
> aber kein zeiger. warum dennoch die selbe Schreibweise?

Weil der Operator . stärker bindet als es * tut.
*Spieler1.ptr ist also das selbe wie *(Spieler1.ptr) und nicht wie 
(*Spieler1).ptr.