ich habe mich in einem Buch zum Thema Zeiger belesen. Zeiger sind demnnach Adressen und Dereferenzierung beutet über dieses Adresse auf das referenzierte Datenobjekt zuzugreifen. Statt des *-Operators kann auch der ->-Operator verwendet werden, um Derenferenzierung und Memberzugriff zu kombinieren. Dazu habe ich ein kleines Prgramm geschrieben:

#include <iostream>
#include <string>
using namespace std;

class demo
{

public:
void tueEtwas()
{
cout <<"Dies ist die Basis" <<endl;
}

int gebeZahl()
{
return 2;
}
};

class abgeleitet : public demo
{
};

class Punkt : public abgeleitet
{
int a;

private:

int x;
int y;

public:

Punkt()
{
x =0;
y =0;
}

Punkt (int n,int m)
{
x = n;
y = m;
}

void verschieben(int dx, int dy)
{
x +=dx;
y +=dy;

}
void ausgeben()
{
cout << "(" << x <<"," << y <<")";
}
};

int main()
{
demo P;

demo *ptr5 = new demo;

//ptr5 ->gebeZahl();
ptr5 ->tueEtwas();
return 0;
}

Der Zeiger ptr5 vom Typ demo zeigt auf die Funktion tueEtwas() der Klasse demo.
Trotzdem steht in dem Zeiger die Adresse drinnen. Wenn ich über den Zeiger ptr5
auf die Funktion gebeZahl() zugreife, was in dem Fall ausgeklammert ist, gibt er mir auch die Adresse zurück. Müsste nicht der Rückgabewert der Funktion dann im Zeiger stehen? Vielen Dank für eure Hilfe!

Ic hverstehe nicht warum die Adresse der Funktion im Zeiger steht

Tut sie nicht. Der Zeiger ist die Adresse des Objektes, mit dem du ihn initialisiert hast (new demo).

müsst nicht eigentlich der Rückgabewert der Funktion im Zeiger stehen.

Nein, der Zeiger ist die Adresse des Objektes, mit dem du ihn initialisiert hast (new demo).

Der Operator -> kombiniert ja Dereferenzierung und Memberzugriff.

Korrekt. zeiger->member bedeutet exakt das gleiche wie (*zeiger).member.

"if (!controller ->GetManufactererHardwareVersion(getMaHaVer))
return false"

vor, wobei controller der Zeiger ist und die Funktion GetManufactererHardwareVersion(get...) entwerder TRUE oder FALSE zurückgibt. In dem Zeiger muss in dem Fall doch der Rückgabewert 1 bzw. 0 stehen, anderfalls würde die KOntrollstruktur doch gar nicht funktionieren?

Der operator-> bewirkt lediglich die Dereferenzierung, d.h. dass das, was nach dem "->" kommt, auf die Instanz angewendet wird, die sich an der Speicheradresse befindet.

edit:

C++Pete schrieb:

In dem Zeiger muss in dem Fall doch der Rückgabewert 1 bzw. 0 stehen, anderfalls würde die KOntrollstruktur doch gar nicht funktionieren?

wieso in dem Zeiger? Du rufst eine Methode auf, die einen Wert zurückliefert. Dieser Rückgabewert wird ausgewertet.

bool AddController(const std:: string& cfgData);

Es handelt sich also um eine Funktion, welche einen bool'schen Wert zurückgibt und die konstante Variable cfgData vom Datentyp String als Eingangsvariable aufnimmt. Bedeutet das Zeichen "&" hinter dem String, dass nur die Adresse dieser Variablen übernommen wird? Wenn ja, was bringt mir das? Vielen Dank für eure Hilfe!

Im Vergleich zur Übergabe als Wert: Es musst nicht kopiert werden.

Und welchen Vorteil bringt mir es, eine Eingangsvariable als Referenz zu deklarieren?

Das nennt sich call-by-reference (manchmal auch pass-by-reference). D.h. das Argument, das du an deine Funktion übergibst, wird nicht kopiert, sondern du hast eine Referenz auf das Argument. Das wiederum bedeutet, du arbeitest in deiner Funktion mit der originalen Variable (von der aufrufenden Funktion). Das const ist wichtig, um sicherzustellen, dass die originale Variable in deiner Funktion nicht verändert wird. Der offensichtliche Vorteil ist also, eine Kopie zu vermeiden.
Im Übrigen solltest du dir eine Referenz als Aliasname für eine Variable vorstellen. Eine Referenz ist nämlich kein Objekt, sie belegt kein Speicher. Sie ist einfach nur ein zweiter Name für etwas.

Referenzen als Member sind fast immer ein Designfehler, sie bieten gegenüber konstanten Zeigern keine Vorteile (Syntax ist irrelevant, schliesslich ist die Referenz nicht public), dafür mehrere Nachteile:
- man kann keine Zeiger-auf-Member bilden,
- es gilt nicht mehr sizeof(Member1)+sizeof(Member2)+... <= sizeof(Klasse)