Eine Funktion arbeitet mit bestimmten Daten, die ich dynamisch alloziere. Dabei möchte ich das Reservieren des Speichers auslagern. In etwa so

void MyClass::init(MyType1* my1, MyType2* my2)
{
  my1 = new MyType1;
  my2 = new MyType2;
}

void MyClass::run()
{
  MyType1* my1 = NULL;
  MyType2* my2 = NULL;

  init( my1, my2 );

  /* Problem: An dieser Stelle sind my1 und my2 immernoch NULL */
}

Was mache ich hier falsch bzw. wo genau liegt der Denkfehler? Gibt es sowas wie Call-By-Reference für Pointer?

Gruss. mbu.

Was mache ich hier falsch bzw. wo genau liegt der Denkfehler?

Du übergibst die Zeiger per Wert - das heißt die Zuweisungen haben keinen Effekt nach außen.

Gibt es sowas wie Call-By-Reference für Pointer?

Ja - das sieht dann so aus: void MyClass::init(MyType1*& my1, MyType2*& my2) .

Jockel

Jockelx schrieb:

Wenn du das wirklich so machen willst, was ziemlich sicher Mist ist, dann
musst du deine Pointer natürlich als Referenzen übergeben.

Warum sollte das Mist sein? Wenn ich eine Methode (wie oben run) habe, die einen bestimmten Algorithmus durchläuft und ich die Methode etwas übersichtlicher gestalten will, weil eben auch die Initialisierung etwas länger ist, kann ich doch nichts anderes machen?

Das Problem liegt einfach darin, dass "Ownership" nicht klar ist. Sprich: Ist gewährleistet, dass die Objekte korrekt (zuverlässig und nur einmal) abgeräumt werden ? ... und dass init() nur einmal aufgerufen wird ? ... und nicht auf anderem Wege versehentlich Speicher "vergessen" wird ? ...

Brauchst Du eigentlich wirklich das Zeug auf dem Heap ? Oder reichen nicht auch "Stackvariablen".

GGf. würde ich eine Wrapperklasse drumrumstricken:

struct MyVars {
   MyType1* my1;
   MyType2* my2;
   MyVars() : my1(new MyType1), my2(new MyType2) {}
   ~MyVars() { delete my2; delete my1; }
private: // Kopieren verbieten ... sonst Gedanken drüber machen.
   MyVars(MyVars const&);
   operator=(MyVars const&);
};

void MyClass::run() {
  MyVars v;

  // Hier kannst Du mit v.my1->, v.my2-> arbeiten wie Du willst.
  // Am Ende (egfal ob return oder throw/catch räumt der MyVars-Destruktor auf
}

Aber wie gesagt: Ich würde nur aus wirklich gutem Grund mit new/delete arbeiten und sonst einfach auf dem Stack:

void MyClass::run() {
   MyType1 my1;
   MyType2 my2;

   // direkt mit my1. und my2. arbeiten ... Aufräumen, Kopieren, ..l alles kein Problem.

Gruß,

Simon2.