C++ | Zeiger als Parameter übergeben, und diesen dann zuweisen

Computer: Software & Programmierung C/C++
#1

Guten Tag alle miteinander!

Ich hab folgendes Problem, ich habe in C++ eine Klasse die einen Zeiger speichert. Ich möchte über eine Memberfunktion diesen Zeiger von außerhalb der Klasse mehr oder weniger kopieren.

Ich weiß auch prinzipiell wie ich das anstellen kann:

class MyClass
{
public:
   MyOtherClass* p_Pointer;
   MyOtherClass* Get_Pointer()
   {
      return p_Pointer;
   }
};

Das funktioniert soweit auch wie ich es möchte.
Nur möchte ich der Funktion den Zeiger als Parameter übergeben, und diesen dann in der Funktion zuweisen.
Den Rückgabetypen möchte ich für Fehlerabfragen verwenden. Ungefähr so:

bool MyOtherClass Get_Pointer(MyOtherClass* point)
{
   point = p_Pointer; // ???
}

Nur ist der Zeiger auf „MyOtherClass“ außerhalb der Funktion dann wieder ungültig.
Mach ich da irgendwas falsch, oder kann das prinzipiell nicht funktionieren?

Bitte um Rat und Hilfe, vielen Dank.

#2

Generel stimmt Deine Lösung schon.

Das Problem ist, dass Du das worauf der Pointer zeigen soll, nicht in der Funktion erzeugen kannst. Erzeugst Du in der Funktion z.B. eine Struktur und setzt den Pointer darauf, dann zeigt der Pointer nach verlassen der Funktion zwar noch dahin - der Speicher für die Struktur wird alledings freigegeben.

Das ganze funktioniert also nur wenn Du das Ziel also auch auserhalb erzeugts und mit übergibst (Ein Klassiker wäre hier das vertauschen von zwei Pointer-Zielen), wenn das zugwiesene Objekt global existiert (eher ein nicht so guter Programmier Style), wenn Du manuell Speicher für das Objekt anlegst (malloc - dann programmierst Du aber schon eher C als C++) oder wenn Du den Pointer direkt mit der Adresse belegst (Die must Du dann aber kennen - und hier programmierst Du dann schon eher assembler als C++).

#3

Nein, das tut sie nicht generell.

Und der Rest deine Antwort hat mit der Frage nur peripher zu tun.

#4

Hi Andi,

ja (1. Teil) und Nein (2. Teil)

Natürlich funktioniert das. Nur hast du in deinem Fall p_Pointer einer lokalen Variablen namens point zugewiesen. Und somit hat das an der Aufrufstelle keine Auswirkungen.

Anders wäre dieses, wenn du

bool MyOtherClass Get_Pointer(MyOtherClass*& rpPoint)
{
  rpPoint = p_Pointer;
  return 0 != rpPoint;
}

schreiben würdest … Ob das schön ist oder nicht, ist ein anderes Thema.

Gruß
HH

#5

eine Variante ist, zu schreiben

bool MyOtherClass Get_Pointer(MyOtherClass* point)
{
*point = *p_Pointer;
}

was passiert hier?
der Rechner geht an die Speicheradresse, auf die point zeigt und speichert dort die Inhalte der Klasse rein, auf die p_Pointer zeigt. Mit anderen Worten: du machst eine Kopie an die Stelle. Dabei wirst du deine Freude haben, den nötigen Speicher bereit zu stellen, ohne dass du Ausnahmefehler generierst.

Wonach du vermutlich eher fragst ist eine Funktion, die die Speicheradresse, die du in p_Pointer hast rausgibt. Damit eine Funktion in einen parameterwert reinschreiben kann, muss der als Pointer übergeben werden. Was willst du aber schreiben? Wieder einen pointer. Also sieht deine Methode dann so aus:

bool MyOtherClass Get_Pointer(MyOtherClass** point)
{
*point = p_Pointer;
}

Er kriegt die Adresse eines pointers. Mit „*point“ schreibt er direkt dort hin, wo dieser pointer steht. Und zwar schreibt er dort die Adresse des Objekts, auf das p_Pointer zeigt. Damit legst du keine Kopie an, sondern kopierst nur die Adresse.

Aufruf des Ganzen sieht so aus:

MyClass c;
MyOtherClass* p_PointerOutside; // Speicher für die Adresse
c.Get_Pointer(&p_PointerOutside); // übergib die Adresse des pointers, damit die Methode dort hinschreiben kann.

viel Erfolg; hoffe, es war einigermaßen verständlich.

Ist im Prinzip ähnlich zur Lösung von HAL