Verweise auf Zeiger in C ++ übergeben

Soweit ich das beurteilen kann, gibt es keinen Grund, warum ich keinen Verweis auf einen Zeiger in C ++ übergeben darf. Meine Versuche scheitern jedoch, und ich habe keine Ahnung warum.

Das mache ich:

void myfunc(string*& val)
{
    // Do stuff to the string pointer
}

// sometime later 
{
    // ...
    string s;
    myfunc(&s);
    // ...
}

Und ich bekomme diesen Fehler:

Parameter 1 kann nicht von 'std :: string *' in 'std :: string * &' konvertiert werden.

Ihre Funktion erwartet einen Verweis auf einen tatsächlichen Zeichenfolgenzeiger im aufrufenden Bereich, nicht auf einen anonymen Zeichenfolgenzeiger. So:

string s;
string* _s = &s;
myfunc(_s);

sollte gut kompilieren.

Dies ist jedoch nur nützlich, wenn Sie den Zeiger ändern möchten, den Sie an die Funktion übergeben. Wenn Sie die Zeichenfolge selbst ändern möchten, sollten Sie einen Verweis auf die Zeichenfolge verwenden, wie von Sake vorgeschlagen. In diesem Sinne sollte es offensichtlicher sein, warum sich der Compiler über Ihren ursprünglichen Code beschwert. In Ihrem Code wird der Zeiger "on the fly" erstellt. Das Ändern dieses Zeigers hätte keine Konsequenzen, und das ist nicht beabsichtigt. Die Idee einer Referenz (gegenüber einem Zeiger) ist, dass eine Referenz immer auf ein tatsächliches Objekt zeigt.

Das Problem ist, dass Sie versuchen, ein temporäres Element an die Referenz zu binden, was C ++ nur zulässt, wenn die Referenz dies ist const .

Sie können also eine der folgenden Aktionen ausführen:

void myfunc(string*& val)
{
    // Do stuff to the string pointer
}


void myfunc2(string* const& val)
{
    // Do stuff to the string pointer
}

int main()
// sometime later 
{
    // ...
    string s;
    string* ps = &s;

    myfunc( ps);   // OK because ps is not a temporary
    myfunc2( &s);  // OK because the parameter is a const&
    // ...

    return 0;
}

Ändern Sie es in:

  std::string s;
  std::string* pS = &s;
  myfunc(pS);

BEARBEITEN:

Dies wird aufgerufen ref-to-pointerund Sie können keine temporäre Adresse als Referenz auf die Funktion übergeben. (es sei denn, es istconst reference ).

Obwohl ich gezeigt habe std::string* pS = &s;(Zeiger auf eine lokale Variable), wäre seine typische Verwendung: Wenn Sie möchten, dass der Angerufene den Zeiger selbst ändert, nicht das Objekt, auf das er zeigt. Beispielsweise muss eine Funktion, die Speicher zuweist und die Adresse des Speicherblocks zuweist, den sie ihrem Argument zugewiesen hat, einen Verweis auf einen Zeiger oder einen Zeiger auf einen Zeiger enthalten:

void myfunc(string*& val)
{
//val is valid even after function call
   val = new std::string("Test");

}

&s Erzeugt einen temporären Zeiger auf eine Zeichenfolge und Sie können nicht auf ein temporäres Objekt verweisen.

Versuchen:

void myfunc(string& val)
{
    // Do stuff to the string pointer
}

// sometime later 
{
    // ...
    string s;
    myfunc(s);
    // ...
}

oder

void myfunc(string* val)
{
    // Do stuff to the string pointer
}

// sometime later 
{
    // ...
    string s;
    myfunc(&s);
    // ...
}

EDIT: Ich habe einige experimentiert und festgestellt, dass die Dinge etwas subtiler sind, als ich dachte. Ich denke jetzt, dass dies eine genaue Antwort ist.

&sist kein l-Wert, daher können Sie keinen Verweis darauf erstellen, es sei denn, der Typ des Verweises ist ein Verweis darauf const. So können Sie zum Beispiel nicht tun

string * &r = &s;

aber du kannst es tun

string * const &r = &s;

Wenn Sie eine ähnliche Deklaration in den Funktionsheader einfügen, funktioniert dies.

void myfunc(string * const &a) { ... }

Es gibt noch ein anderes Problem, nämlich Provisorien. Die Regel ist, dass Sie nur dann einen Verweis auf eine temporäre Datei erhalten können, wenn dies der Fall ist const. In diesem Fall könnte man also argumentieren, dass & s vorübergehend ist und daher deklariert werden mussconst im Funktionsprototyp . Aus praktischer Sicht macht es in diesem Fall keinen Unterschied. (Es ist entweder ein r-Wert oder ein temporärer Wert. In beiden Fällen gilt die gleiche Regel.) Genau genommen denke ich jedoch, dass es kein temporärer, sondern ein r-Wert ist. Ich frage mich, ob es einen Weg gibt, zwischen den beiden zu unterscheiden. (Vielleicht wird einfach definiert, dass alle Provisorien r-Werte sind und alle Nicht-l-Werte temporäre Werte. Ich bin kein Experte für den Standard.)

Davon abgesehen liegt Ihr Problem wahrscheinlich auf einem höheren Niveau. Warum möchten Sie einen Verweis auf die Adresse von s? Wenn Sie einen Verweis auf einen Zeiger auf möchten s, müssen Sie einen Zeiger wie in definieren

string *p = &s;
myfunc(p);

Wenn Sie einen Verweis auf soder einen Zeiger auf möchten s, gehen Sie einfach vor.

Ich habe gerade einen Verweis auf einen Zeiger verwendet, um alle Zeiger in einem gelöschten Binärbaum außer dem Stamm sicher zu machen. Um den Zeiger sicher zu machen, müssen wir ihn nur auf 0 setzen. Ich konnte die Funktion, die den Baum löscht (nur die Wurzel behalten), nicht dazu bringen, einen Verweis auf einen Zeiger zu akzeptieren, da ich die Wurzel (diesen Zeiger) als erste verwende Eingabe, um links und rechts zu durchlaufen.

void BinTree::safe_tree(BinTree * &vertex ) {
    if ( vertex!=0 ) {  // base case
        safe_tree(vertex->left);    // left subtree.
            safe_tree(vertex->right);   //  right subtree.
          // delete vertex;  // using this delete causes an error, since they were deleted on the fly using inorder_LVR. If inorder_LVR does not perform delete to the nodes, then, use delete vertex;
        vertex=0;  // making a safe pointer
    }
} // end in

Unterm Strich ist ein Verweis auf einen Zeiger ungültig, wenn der formale Parameter der (dieser) Zeiger ist.

Willkommen bei C ++ 11 und rvalue Referenzen:

#include <cassert>
#include <string>

using std::string;

void myfunc(string*&& val)
{
    assert(&val);
    assert(val);
    assert(val->c_str());
    // Do stuff to the string pointer
}

// sometime later 
int main () {
    // ...
    string s;
    myfunc(&s);
    // ...
}

Jetzt haben Sie Zugriff auf den Wert des Zeigers (auf den verwiesen wird val), der die Adresse der Zeichenfolge ist.

Sie können den Zeiger ändern, und es interessiert niemanden. Das ist ein Aspekt dessen, was ein Wert überhaupt ist.

Achtung: Der Wert des Zeigers ist nur bis zur myfunc()Rückkehr gültig . Endlich ist es eine vorübergehende.

Ich weiß, dass es möglich ist, Verweise auf Zeiger zu übergeben, ich habe es letzte Woche getan, aber ich kann mich nicht erinnern, wie die Syntax lautete, da Ihr Code für mein Gehirn im Moment korrekt aussieht. Eine andere Option ist jedoch die Verwendung von Zeigern von Zeigern:

Myfunc(String** s)

myfunc ("string * & val") das selbst macht keinen Sinn. "string * & val" impliziert "string val", * und & heben sich gegenseitig auf. Schließlich kann man keine Stringvariable an eine Funktion übergeben ("string val"). Es können nur grundlegende Datentypen an eine Funktion übergeben werden, da andere Datentypen als Zeiger oder Referenz übergeben werden müssen. Sie können entweder string & val oder string * val für eine Funktion haben.