Verweise auf Zeiger in C ++ übergeben

Soweit ich das beurteilen kann, gibt es keinen Grund, ich sollte nicht erlaubt werden, übergeben Sie eine Referenz auf einen Zeiger in C++. Aber meine versuche, um so zu tun sind gescheitert, und ich habe keine Ahnung, warum.

Dies ist, was ich Tue:

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

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

Und ich bin immer diese Fehlermeldung:

cannot convert parameter 1 von 'std::string *' in 'std::string *&'

InformationsquelleAutor der Frage Alex | 2009-05-05

  1. 94

    Ihrer Funktion erwartet eine Referenz auf eine tatsächliche Zeichenfolge Zeiger in der aufrufenden scope, nicht eine anonyme string-Zeiger. Also:

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

    sollten kompilieren einwandfrei.

    Dies ist jedoch nur sinnvoll, wenn Sie beabsichtigen, ändern den Zeiger übergeben Sie an die Funktion. Wenn Sie beabsichtigen, ändern Sie die Zeichenfolge selbst, sollten Sie eine Referenz auf den string als Sake vorgeschlagen. Mit diesem Gedanken im Hinterkopf sollte es deutlicher werden, warum der compiler beschwert sich über Sie original-code. In Ihrem code, der Zeiger wird erstellt 'on the fly', ändern, die Zeiger hätte keine Konsequenz, und das ist nicht das, was vorgesehen ist. Die Idee einer Referenz (vs. pointer) ist, dass eine Referenz immer auf ein Tatsächliches Objekt.

    InformationsquelleAutor der Antwort Chris

  2. 76

    Das problem ist, dass Sie versuchen zu binden, der vorübergehend auf die Referenz, die C++ nicht erlaubt, es sei denn, der Verweis ist const.

    So können Sie entweder die folgenden:

    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;
}

    InformationsquelleAutor der Antwort Michael Burr

  3. 7

    Ändern:

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

    EDIT:

    Dies wird als ref-to-pointer und Sie nicht passieren können temporäre Adresse als eine Referenz auf die Funktion. ( es sei denn, es ist const reference).

    Obwohl, ich habe gezeigt std::string* pS = &s; (Zeiger auf eine lokale variable), deren typische Verwendung wäre :
    wenn Sie möchten, dass der angerufene zu ändern, den Zeiger selbst, nicht das Objekt, auf das es Punkte. Zum Beispiel, eine Funktion, reserviert Speicher und weist die Adresse des Speicherbereichs zugewiesen, um Ihr argument muss ein Verweis, ein Zeiger oder ein Zeiger auf Zeiger:

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

}

    InformationsquelleAutor der Antwort aJ.

  4. 5

    &s produziert temporäre Zeiger auf string, und Sie können nicht mit Verweis auf temporäres Objekt.

    InformationsquelleAutor der Antwort n0rd

  5. 3

    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);
    //...
}

    InformationsquelleAutor der Antwort Sake

  6. 2

    EDIT: ich experimentierte etwas und entdeckt was sind ein bisschen subtiler, als ich dachte. Hier ist, was ich jetzt denke, ist eine genaue Antwort.

    &s ist kein lvalue, so dass Sie nicht erstellen einen Verweis darauf, sofern der Typ der Referenz ist Verweis auf const. So zum Beispiel können Sie nicht tun

    string * &r = &s;

    aber Sie tun können,

    string * const &r = &s;

    Wenn du von einer ähnlichen Deklaration in der header-Funktion, wird es funktionieren.

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

    Gibt es ein weiteres Problem, nämlich, Provisorien. Die Regel ist, dass man eine Referenz auf ein temporäres nur, wenn es const. Also in diesem Fall könnte man argumentieren, dass &s ist eine temporäre, und so müssen deklariert werden const in der Funktionsprototyp. Aus praktischer Sicht macht es keinen Unterschied in diesem Fall. (Entweder ist es ein rvalue oder einem vorübergehenden. So oder so gilt die gleiche Regel.) Jedoch, streng genommen, ich denke, es ist nicht eine vorübergehende, sondern eine rvalue. Ich Frage mich, ob es eine Möglichkeit gibt, zwischen beiden zu unterscheiden. (Vielleicht ist es einfach definiert, dass alle Provisorien sind rvalues, und alle nicht-lvalues sind Provisorien. Ich bin kein Experte auf dem standard.)

    Dass gesagt wird, Ihr problem ist vermutlich auf ein höheres Niveau. Warum wollen Sie einen Verweis auf die Adresse von s? Wenn Sie möchten, eine Referenz auf einen Zeiger auf s müssen Sie definieren einen Zeiger wie in

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

    Wenn Sie möchten, einen Verweis auf s oder einen Zeiger auf s, gehen einfache Sache.

    InformationsquelleAutor der Antwort Ari

  7. 1

    Habe ich nur einen Verweis auf einen Zeiger alle Zeiger in einem gelöschten binären Baumes außer der Wurzel sicher. Damit der Zeiger sicher, die wir gerade haben, um es zu 0. Ich konnte nicht die Funktion, die löscht den Baum (nur die Wurzel) zu akzeptieren, die ein ref auf einen Zeiger, da ich mich mit dem root (this-Zeiger) als die erste Eingabe zu durchqueren, Links und rechts.

    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

    Unteren Zeile ein Verweis (ein Zeiger ist ungültig, wenn der formale parameter ist die () - Zeiger.

    InformationsquelleAutor der Antwort Mohd

  8. 0

    Willkommen zu 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);
    //...
}

    Nun haben Sie Zugriff auf den Wert des Zeigers (nach val), der die Adresse des Strings.

    Können Sie ändern den Zeiger, und niemand kümmert. Das ist der eine Aspekt von dem, was ein rvalue ist in den ersten Platz.

    Vorsichtig sein: Der Wert, den der Zeiger ist nur solange gültig, bis myfunc() gibt. Endlich, es ist eine vorübergehende.

    InformationsquelleAutor der Antwort not-a-user

  9. -1

    Ich weiß, dass es posible-pass-Referenzen von Zeigern, ich habe es Letzte Woche, aber ich kann mich nicht erinnern, was die syntax war, wie dein code sieht richtig um mein Gehirn jetzt. Aber eine andere option ist die Verwendung von Zeigern Zeiger:

    Myfunc(String** s)

    InformationsquelleAutor der Antwort Robert Gould

  10. -8

    myfunc("string*& val") dieser an sich macht keinen Sinn. "string*& val" steht für "string " val",* und & hebt sich gegenseitig. Schließlich kann man nicht pas string-variable an eine Funktion("string " val"). Nur die grundlegenden Datentypen können an eine Funktion übergeben, für andere Datentypen übergeben zu müssen, als Zeiger oder Referenz.
    Sie können zwischen string& val oder string* val an eine Funktion.

    InformationsquelleAutor der Antwort Shashikiran

Schreibe einen Kommentar