Mal &, mal *

[Krux]

ich finds auch etwas komisch, dass man da zwei verschiedene Methoden für die gleiche sache verwenden kann, und damit ordendlich chaos erstellen kann.

Seikilos schrieb:

Einmal ging es um das Thema pass-by-reference und die Methodensignatur sah ungefähr so aus:

void methode(int* value){
*value = 5;
}

Ist klar, der Aufruf der Methode sieht dann irgendwie so aus

int i = 6;
methode(&i);

das ist übrigens call by value, denn der Datentyp ist int*, und die methode bekommt eine Kopie von dem Pointer . Übrigens kann man in C++ auch referenzen auf pointer verteilen .

[Seikilos]

Ja, aber ändern tu ich doch den Wert des ints, oder?

[Don06]

Jap, wie gesagt der Zeiger wird ja per Call-by-Value übergeben, den kannst du folglich garnicht ändern (nur die interne Kopie). Das, worauf er zeigt, kannst du natürlich verändern (und tust du auch in dem Beispiel).

Gruß
Don06

[*D*Evil]

@Seikilos: Probier mal:

void new_array(int* arr, std::size_t size)
{
    delete [] arr;
    arr = new int[size];
}

int main()
{
    int* arr = new int[10];
    new_array(arr, 11);
}

...

[Seikilos]

Was bitte soll ich bezüglich dieses Codes probieren?

[*D*Evil]

Hmm geh mal mitm debugger durch und vergleich arr vor und nach dem Funktionsaufurf ...

[Krux]

Seikilos schrieb:

Was bitte soll ich bezüglich dieses Codes probieren?

ich glaub er möchte, das du feststellst, das das so nicht funktioniert, wie es soll, denn die Adresse des von new_array erstellten arrays ist mit dem ende der Methode verloren, weil der Pointer selbst nur als kopie übergeben wurde, also änderungen an diesem haben keinerlei auswirkungen auf das Original.

[Simon2]

Krux schrieb:

...

Seikilos schrieb:

Einmal ging es um das Thema pass-by-reference und die Methodensignatur sah ungefähr so aus:

void methode(int* value){
*value = 5;
}

...

Don06 schrieb:

Jap, wie gesagt der Zeiger wird ja per Call-by-Value übergeben, ...

das ist übrigens call by value, denn der Datentyp ist int*, und die methode bekommt eine Kopie von dem Pointer ...

Das ist nicht so eindeutig. Diese "call-by-pointer-value"-Argumentation haben sich die Javaisten zurechtgelegt, um ihr Weltbild einfach zu halten, in C++ würde ich das als call-by-reference bezeichnen, weil das fachliche Objekt, mit dem man arbeiten möchte, nicht der Pointer, sondern das int ist.

Wir haben hier schon 1000 Seiten über die "call-by-"-Begriffe diskutiert und sind letztlich zu keinem Ergebnis gekommen. Letztlich sind das theoretische Konstrukte, die der Realität in der Praxis mehr oder minder eindeutig zugeordnet werden können.

template <typename T>
void f(T i) {  // call-by-value ? call-by-reference ?
   i = (T) 0xABCDEF;
}
struct MyClass {
   MyClass(int i) {}
};

void g(int i) { // call-by-value ? call-by-reference ?
   MyClass* p = reinterpret_cast<MyClass*>(i); *p = 3;
}

int main() {
   int i=0;
   int* pi = &i;
   int& ri = i;

   f(i);
   f(pi);
   f(ri);

   g(0xABCDEF);
   return 0;
}

Gruß,

Simon2.

[Seikilos]

Hm je mehr Code gepostet wird, desto mehr verwirrt mich das.
Ich muss Freitag ne 4 Stunden Klausur über Theorie schreiben.
Bei Devils code müsste die Signatur ein int **arr nehmen, richtig?

Und aufrufen mit &arr um die Referenz und keine Kopie zu erzeugen?

[Simon2]

Seikilos schrieb:

...
Bei Devils code müsste die Signatur ein int **arr nehmen, richtig?...

Oder einfach ein int*& arr....

Dies ist eben ein Beispiel, wo das fachliche Objekt wirklich der Pointer ist - schließlich geht es hier um Speicherverwaltung (im Prinzip ist es sogar egal, auf welche Objekte hier gezeigt wird), weswegen ich das durchaus als "call-by-value" bezeichen würde.
Die C++-Syntax ist hier in dieser Richtung nicht eindeutig (bei Pointern) - anders herum aber schon:
"Signatur einer Funktion, die einen optionalen Verweis (call-by-reference) auf ein int entgegennimmt" : void f(int*);
"Signatur einer Funktion, die einen int-Pointer (call-by-value) entgegennimmt" : void f(int*);

Gruß,

Simon2.

[Seikilos]

Simon2 schrieb:

Die C++-Syntax ist hier in dieser Richtung nicht eindeutig (bei Pointern) - anders herum aber schon:
"Signatur einer Funktion, die einen optionalen Verweis (call-by-reference) auf ein int entgegennimmt" : void f(int*);
"Signatur einer Funktion, die einen int-Pointer (call-by-value) entgegennimmt" : void f(int*);

...ööh

[Simon2]

Seikilos schrieb:

...
...ööh

Probleme ?
so ist das eben mit "nicht-bijektiven Abbildungen": Zwei unterschiedliche Ausgangspunkte werden auf dasselbe Ergebnis abgebildet...
Aber tröste Dich: Es gibt auch eindeutige Zuordnungen:
"Signatur einer Funktion, die einen verpflichtenden Verweis (call-by-ref) auf ein int entgegennimmt: void f(int&);"
"Signatur einer Funktion, die ein int (call-by-val) entgegennimmt: void f(int);"

Gruß,

Simon2.