Welche Bedeutung hat die Rückgabe durch Verweis?

Question

In C++,

function() = 10;

funktioniert, wenn die Funktion eine Variable per Referenz zurückgibt.

Was sind die Anwendungsfälle dafür?

Answer 1

Der häufigste Fall ist die Implementierung von Dingen wie operator[].

struct A {
    int data[10];
    int & operator[]( int i ) {
         return data[i];
    }
};

Eine andere Möglichkeit ist die Rückgabe eines großen Objekts aus einer Klasse über eine Accessor-Funktion:

struct b {
    SomeBigThing big;
    const SomeBigThing & MyBig() const {
         return big;
    }
};

um den Kopieraufwand zu vermeiden.

Answer 2

Betrachten Sie den folgenden Code: MyFunction gibt einen Zeiger auf einen int zurück, und Sie setzen einen Wert auf diesen int.

int  *i;
i = MyFunction();
*i = 10;

Kürzen Sie das jetzt auf

*(MyFunction()) = 10;

Er bewirkt genau dasselbe wie der erste Codeblock.

Sie können eine Referenz als einen Zeiger betrachten, der immer dereferenziert wird. Wenn meine Funktion also einen Verweis - und keinen Zeiger - auf einen int zurückgibt, würde der erste Codeblock wie folgt aussehen

int  &i;
i = MyFunction();
i = 10;

und die zweite würde zu

MyFunction() = 10;

Das ist es, wonach ich gesucht habe

Answer 3

Getters/Setters zum Beispiel

class C
{
    int some_param_;
public:
    int& param() { return some_param_; }
    int const& param() const { return some_param_; }
};

aber hier sollten Sie some_param als öffentlichen int verwenden. Container bieten Funktionen, die per Referenz zurückgeben, z. B. vector<T>::operator[] so dass Sie schreiben können v[k] = x .

Answer 4

Ein ganz normaler Anwendungsfall ist, wenn Sie eine arrayähnliche Klasse schreiben. Hier wollen Sie die operator [] so wie Sie es tun können a[0] = 10; In diesem Fall sollte die Signatur wie folgt aussehen int& operator[](int index);

Answer 5

Wenn Sie eine Klasse haben, die eine andere Struktur enthält, kann es nützlich sein, die enthaltene Struktur direkt zu ändern:

struct S
{
    int value;
};

class C
{
    public:

        S& ref() { return m_s; }

    private:

        S m_s;
};

Ermöglicht es Ihnen, etwas zu schreiben wie:

void foo()
{
    C c;

    // Now you can do that:

    c.ref().value = 1;
}

Hinweis: In diesem Beispiel könnte es einfacher sein, direkt die m_s öffentlich, anstatt eine Referenz zurückzugeben.