Pointer nach Rückkehr aus Funktion null?

[c-noob (Gast)]

Hallo,

bin grade etwas verwirrt:

habe folgende funktion:

void init(Objekt1 * obj);
{
    // irgendwelcher code der ein paar parameter setzt
    obj = new Objekt( irgendwelche Parameter );
}

wenn ich jetzt

Objekt *obj = 0;
init(Objekt * obj);

ausführe und in die Funktion init reindebugge wird das Objekt alloziert 
und der Pointer zeigt drauf, soweit alles klar.
Nach der Rückkehr aus der Funktion ist der Pointer aber wieder Null.

Wieso?

[(prx) A. K. (prx)]

Das wird kaum
  init(Objekt * obj);
gewesen sein. Sondern
  init(obj);

C übergibt als Parameter den Wert, keine Referenz auf die Variable. 
Daher kann in der aufgerufenen Funktion der Parameter beliebig geändert 
werden, ohne aber in der aufrufenden Funktion etwas zu ändern.

[Sebastian V. (sebi_s)]

Weil beim Aufruf eine Kopie deines Pointers erzeugt wird. Der Pointer an 
der Aufrufstelle bleibt vom Funktionsaufruf unverändert. Das ist wie:

void foo(int i) {
    i = 5;
}

int x = 2;
foo(x);
// x ist immer noch 2

Entweder Pointer auf Pointer benutzen oder Pointer als Rückgabewert. 
Oder im Idealfall gar keine rohen Pointer benutzen wenn man schon C++ 
nutzt.

[Johann L. (gjlayde)]

Weil auch Zeiger per Wert übergeben werden.  Also entweder &obj 
übergeben oder eine Referenz darauf — nach Anpassung des Interface etc.

[(prx) A. K. (prx)]

Wenn du
  void init(Objekt1 & obj) { ... }
draus machst, sieht es besser aus. Denn dann wird nicht der Wert 
übergeben, sondern eine Referenz.

NB: Auch hier ist in deinem Beispiel ein Syntaxfehler.

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Gegenfrage: Warum sollte er einen anderen Wert haben?

Der Wert des Pointers wird an die Funktion übergeben, d.h. Call by 
value. Für die von Dir gewünschte Funktionalität musst Du also einen 
Zeiger auf Deinen Zeiger übergeben, d.h.:

void init(Objekt1 ** obj)
{
    // irgendwelcher code der ein paar parameter setzt
    *obj = new Objekt( irgendwelche Parameter );
}

...

Objekt *obj = 0;
init(&obj);

Falls Du mit C++ arbeiten solltest, könntest Du auch mit Referenzen 
statt Pointern arbeiten (, wobei hinter den Referenzen aber eigentlich 
auch Pointer stecken).

[c-noob (Gast)]

@  A. K.

Entschulding, der Aufruf ist natürlich

init(obj);

ok stimmt, habs glaube ich verstanden, der Pointer wird ja geändert.

so würde es dann funktionieren oder?

void init(Objekt1 ** obj);
{
    // irgendwelcher code der ein paar parameter setzt
    *obj = new Objekt( irgendwelche Parameter );
}

mit dem Aufruf:

init(&obj);

[Theor (Gast)]

Das hat mit dem Geltungsbereich (Scope) von Parametern zu tun.

Es gibt bei Deinem Beispiel die Besonderheit, dass der Name der 
Variablen im globalen Geltungsbereich gleich dem Namen im 
Geltungsbereich der Funktion ist. Das hat hier aber keinerlei Bedeutung.

Zur Klarheit hier eine für Dein Problem äquivalente Variable und 
Funktion:

int * a = NULL;    // Der Standardwert für Zeiger die auf nichts zeigen (nicht 0!=

void function (int * b) {
   b = malloc (sizeof(int));
}

...

function (a);

Auch wenn die Funktion gleich aussieht, tritt hier das selbe Problem 
auf, das wie folgt formuliert werden kann:

Alle Werte innerhalb einer Funktion haben nur Geltung innerhalb der 
Funktion.

Du würdest ja (vermutlich) auch nicht erwarten, das folgender Code

int a = 0;

void function (int b) {
   b = 7;
}

function (a);

den Wert von a in der Weise verändert, dass nach dem Ende der Funktion 
immer noch a = 7 gilt.

Analoges gilt auch für Zeiger.

Ein Zeiger ist an sich nur ein Wert, für den die Regeln des 
Geltungsbereichs genauso gelten, wie für andere Variablen. Das der 
Zeiger auf eine Speicherstelle zeigt ist an sich erstmal nichts 
besonderes.

Zwar wird in der Funktion oben ein Speicher für b alloziiert, aber das 
wirkt sich nicht auf a aus, obwohl es als Parameter übergeben wurde.

Um einen Zeiger, der innerhalb einer Funktion alloziiert werden soll, im 
Geltungsbereich der aufrufenden Funktion (z.B. main) zugreifen zu 
können, muss der Funktion eine Zeiger, auf einen Zeiger übergeben 
werden, nicht nur ein Zeiger.

int * a = NULL;

void function (int * * b) {
   *b = malloc(sizeof(int));
}

function (& a);

In neuerem C gibt es dazu noch einen anderen Operator. Aber dazu guckst 
Du vielleicht erstmal in einem C-Buch nach Zeigern auf Zeiger; und dann 
nach "Referenzen".

[PittyJ (Gast)]

Ich benutze immer eine Referenz, wenn ich in der Funktion den Parameter 
verändert haben möchte.

Also so etwas wie

int * a = NULL;

void function (int * & b)
{
   b = malloc(sizeof(int));
}

function ( a);


Das erspart 'Stern' und 'Und'.

Statt gcc einfach g++ eintippen, und schon mag der Compiler das.

[Rufus Τ. F. (rufus)]

Um ein Problem in Programmiersprache X zu lösen, nehme ich immer 
Programmiersprache Y.

Ist das hilfreich?