Was bedeutet es für die Rückgabe einer Referenz?

Ich verstehen, das Konzept der Referenzen in C++, und ich verstehe, was Sie tun werden, wenn in Parameter der Funktion, aber ich bin immer noch sehr verwirrt darüber, wie Sie arbeiten mit Rückgabetypen.

Beispielsweise, wenn in Parameter, dieser code:

int main (void) {
  int foo = 42;
  doit(foo);
}

void doit (int& value) {
  value = 24;
}

ähnlich wie in diesem code:

int main (void) {
  int foo = 42;
  doit(&foo);
}

void doit (int* value) {
  *value = 24;
}

(im wissen, dass der compiler automatisch ein Sternchen vor Wert jedes mal, wenn es verwendet wird, in der ersten code-Beispiel von doit, aber in der letzteren würden Sie haben, um den Stern in sich selbst jedes mal, wenn Sie versuchen, verwenden Sie Wert)

So, wenn als Referenz verwendet, was bedeutet dieser code (Verwendung der Referenz in einem return-Typ) zu übersetzen? Hat es wieder einen Zeiger auf ein int? Oder würde es nur int zurückgeben?

int main (void) {
  int* foo = /*insert useful place in memory*/;
  foo = doit(foo);
}

int& doit (int* value) {
  //insert useful code
}

Würde es wieder eine Referenz auf eine int, Eine Referenz, die Sie an denken können als namens-Zeiger, aber ohne all die rohe Kraft von einem Zeiger. Das große problem mit allen, die , Rückgabe einer Referenz auf ein Objekt, dass sehr wahrscheinlich wird auf dem Stapel erzeugt wird, dass Ihr gehen zu müssen, einige böse Speicher-Probleme, wenn die Funktion zurückgibt und Funktionen-stack wird aufgeräumt. Also , seien Sie sich dessen bewusst, dass, nur weil es einen Hinweis, dass die Dosis NICHT bedeuten, dass Sie haben keine Speicher Probleme, und mit Referenzen, es ist wirklich noch schlimmer, weil das Speicher-Problem versteckt ist.

InformationsquelleAutor crodriguez | 2012-12-05

c++parameters reference return-type

14

Es bedeutet, dass Sie zurückkehren, indem Sie auf die Referenz, die ist, zumindest in diesem Fall wohl nicht gewünscht. Im Grunde bedeutet es, der zurückgegebene Wert ist ein alias auf das, was Sie von der Funktion zurückgegeben. Es sei denn, es ist ein persistentes Objekt, das es illegal ist.

Beispiel:
```
int& foo () {
    static int x = 0;
    return x;
}

//...
int main()
{
    foo() = 2;
    cout << foo();
}
```
legal wäre und drucken Sie 2, weil foo() = 2 ändert den tatsächlichen Wert zurückgegeben foo.

Jedoch:
```
int& doit () {
    int x = 0;
    return x;
}
```
illegal wäre (gut, der Zugriff auf den Rückgabewert würde), weil x zerstört wird, wenn die Methode beendet, so würden Sie Links mit einem baumelnden Referenz.

Rückgabe per Referenz ist nicht üblich für freie Funktionen, aber es ist für Methoden wieder Mitglieder. Zum Beispiel, in der std, die operator [] für Allgemeine Container Rückgabe durch Referenz. Beispiel: Zugriff auf Elemente eines Vektors mit [i] gibt eine tatsächliche Referenz zu diesem element, so v[i] = x tatsächlich ändert, dass element.

Ich hoffe auch, dass "im wesentlichen gleich diesem code" bedeutet, dass Sie semantisch in gewisser Weise (aber nicht wirklich) ähnlich. Nichts mehr.
- Dank Luchian, das hat mir sehr geholfen! Und ja, ich meinte "ähnlich". Ich werde Bearbeiten, die für zukünftige Referenzen.
- Nur um zu helfen, klare, Rückgabe durch Referenz gibt die Adresse was auch immer Objekt, das Sie versuchten zurückzukehren. Sie offensichtlich nicht wollen, zurück zu kehren, die Adresse eines Objekts mit dem lokalen Bereich, weil das Objekt wird zerstört, wenn die Funktion aufgerufen wird gemacht, was wird, verlassen Sie mit einem baumelnden Referenz (das wäre wiederum kann dazu führen, ein use-after-free-bug). Daher ist eine gute Nutzung der Rückgabe per Referenz wäre, als Luchian sagte, wenn wieder ein Mitglied.
- Rückgabe per Referenz zurück nicht die Adresse ist, gibt es einen alias.
- Nein, es gibt einen Verweis, und nicht ein alias. Referenzen sind in der Regel umgesetzt mit Maschinen-Adressen unter der Haube.
- eine Referenz ist ein "alias" von Objekt es sich bezieht - ein anderer name für das gleiche Objekt.
- Das Objekt muss nicht persistent sein, die Lebensdauer des Objekts muss größer sein als der Umfang der Funktionen, die zum Beispiel über die Laufzeitverlängerung.
InformationsquelleAutor Luchian Grigore
3

Bedeutet es, dass Sie zurück einen Zeiger auf die Speicheradresse, wo der Korrespondent Daten, anstatt die Daten sehr.

InformationsquelleAutor John Maura
1

Vorausgesetzt, dieser code (vergleichbar zu machen, um das erste Beispiel) :
```
int main (void) {
  int* foo = /*insert useful place in memory*/;
  *foo = doit(foo);
}

int& doit (int* value) {
  *value = 24;
  return *value;
}
```
Den int& ist nicht wirklich nützlich, da ein return-Typ in diesem Fall, weil es bietet Zugriff auf die variable im Speicher (von denen übergeben Sie den Zeiger an die Funktion).

Tut es wieder ein Zeiger auf ein int? Oder würde es nur int zurückgeben?

Nein, es gibt einen Verweis auf ein int. Wenn Sie möchten, können Sie betrachten es als einen pointer, die können nicht nullptr.

InformationsquelleAutor BЈовић
0

Hmm, der beste Weg, zu wissen, dass die Antwort, einen Versuch zu haben...

Ihre codes wird nicht passieren-Typ überprüfen, weil doit zurückkehren wird, ein Verweis auf int, während Sie akzeptieren die Rückgabe-Wert als Zeiger int.

Können Sie einen Blick auf diese:
```
#include<iostream>
using namespace std;
int& doit (int* value) {
    value[0] = 3;
    return value[4];
}
int main (void) {
  int* foo = new int[10];
  for (int i=0; i<10; i++)
    foo[i] = i;
  int& bar = doit(foo);
  cout<<bar<<endl;
  for (int i=0; i<10; i++)
      cout<<foo[i]<<" ";
  cout<<endl;
  bar = 12;
  for (int i=0; i<10; i++)
      cout<<foo[i]<<" ";
  cout<<endl;
  return 0;
}
```
Die variable "bar" wird die den Rückgabewert aufnimmt, und es kann verwendet werden, ändern Sie den Inhalt des "foo". Wie erwähnt Luchian, der es vielleicht gefährlich für die Rückgabe einer Referenz von der Funktion, denn die später-codes ändern Sie einen Wert in den stack.

InformationsquelleAutor sleepsort

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.