Przekazywanie odwołań do wskaźników w C ++

O ile wiem, nie ma powodu, dla którego nie powinienem mieć możliwości przekazywania referencji do wskaźnika w C ++. Jednak moje próby kończą się niepowodzeniem i nie mam pojęcia, dlaczego.

Oto co robię:

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

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

Otrzymuję ten błąd:

nie można przekonwertować parametru 1 z „std :: string *” na „std :: string * &”

Twoja funkcja oczekuje odwołania do rzeczywistego wskaźnika ciągu w zakresie wywołującym, a nie anonimowego wskaźnika ciągu. A zatem:

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

powinien się dobrze skompilować.

Jest to jednak przydatne tylko wtedy, gdy zamierzasz zmodyfikować wskaźnik przekazany do funkcji. Jeśli zamierzasz zmodyfikować sam łańcuch, powinieneś użyć odniesienia do łańcucha, zgodnie z sugestią Sake. Mając to na uwadze, powinno być bardziej oczywiste, dlaczego kompilator narzeka na Twój oryginalny kod. W twoim kodzie wskaźnik jest tworzony „w locie”, modyfikowanie tego wskaźnika nie miałoby konsekwencji i nie jest to zamierzone. Ideą odniesienia (a nie wskaźnika) jest to, że odniesienie zawsze wskazuje na rzeczywisty obiekt.

Problem polega na tym, że próbujesz powiązać tymczasowy z odwołaniem, na co C ++ nie zezwala, chyba że odwołanie tak const.

Możesz więc wykonać jedną z następujących czynności:

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

Zmień to na:

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

EDYTOWAĆ:

Nazywa się to ref-to-pointeri nie można przekazać adresu tymczasowego jako odniesienia do funkcji. (chyba że takconst reference ).

Chociaż pokazałem std::string* pS = &s;(wskazałem na zmienną lokalną), jego typowym zastosowaniem byłoby: gdy chcesz, aby odbiorca zmienił sam wskaźnik, a nie obiekt, na który wskazuje. Na przykład funkcja przydzielająca pamięć i przypisująca adres bloku pamięci, którą zaalokowała do swojego argumentu, musi mieć odniesienie do wskaźnika lub wskaźnik do wskaźnika:

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

}

&s tworzy tymczasowy wskaźnik do łańcucha i nie możesz odwołać się do tymczasowego obiektu.

Próbować:

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

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

lub

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

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

EDYCJA: trochę eksperymentowałem i odkryłem, że rzeczy są nieco subtelniejsze niż myślałem. Oto, co teraz uważam za dokładną odpowiedź.

&snie jest lwartością, więc nie można utworzyć do niej odwołania, chyba że jest to odniesienie do typu const. Na przykład nie możesz tego zrobić

string * &r = &s;

ale możesz to zrobić

string * const &r = &s;

Jeśli umieścisz podobną deklarację w nagłówku funkcji, zadziała.

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

Jest jeszcze jedna kwestia, a mianowicie prowizoryczne. Zasada jest taka, że ​​odwołanie do pliku tymczasowego można uzyskać tylko wtedy, gdy tak jest const. Więc w tym przypadku można by argumentować, że & s jest tymczasowe i dlatego musi być zadeklarowane constw prototypie funkcji. Z praktycznego punktu widzenia nie ma to znaczenia w tym przypadku. (Jest to albo wartość r, albo wartość tymczasowa. Tak czy inaczej, obowiązuje ta sama reguła.) Jednakże, mówiąc ściśle, myślę, że nie jest to wartość tymczasowa, ale wartość r. Zastanawiam się, czy istnieje sposób na rozróżnienie tych dwóch. (Być może jest po prostu zdefiniowane, że wszystkie wartości tymczasowe są wartościami r, a wszystkie wartości inne niż l są tymczasowe. Nie jestem ekspertem w zakresie standardów).

Biorąc to pod uwagę, twój problem jest prawdopodobnie na wyższym poziomie. Dlaczego chcesz podać adres s? Jeśli chcesz odwołać się do wskaźnika do s, musisz zdefiniować wskaźnik, tak jak w

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

Jeśli chcesz mieć odniesienie slub wskaźnik do s, zrób prostą rzecz.

Właśnie skorzystałem z odniesienia do wskaźnika, aby wszystkie wskaźniki w usuniętym drzewie binarnym z wyjątkiem katalogu głównego były bezpieczne. Aby wskaźnik był bezpieczny, musimy po prostu ustawić go na 0. Nie mogłem sprawić, aby funkcja, która usuwa drzewo (zachowując tylko korzeń), akceptowała odniesienie do wskaźnika, ponieważ używam korzenia (tego wskaźnika) jako pierwszego wejście do przejścia w lewo iw prawo.

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

Podsumowując, odwołanie do wskaźnika jest nieprawidłowe, gdy parametrem formalnym jest (ten) wskaźnik.

Witamy w C ++ 11 i referencjach rvalue:

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

Teraz masz dostęp do wartości wskaźnika (do którego odwołuje się val), czyli adresu ciągu.

Możesz modyfikować wskaźnik i nikogo to nie obchodzi. To jest przede wszystkim jeden aspekt tego, czym jest wartość r.

Uważaj: wartość wskaźnika jest ważna tylko do momentu myfunc()powrotu. W końcu to tymczasowe.

Wiem, że możliwe jest przekazywanie referencji wskaźników, zrobiłem to w zeszłym tygodniu, ale nie pamiętam, jaka była składnia, ponieważ Twój kod wygląda teraz poprawnie w moim mózgu. Jednak inną opcją jest użycie wskaźników wskaźników:

Myfunc(String** s)

myfunc ("string * & val") to samo w sobie nie ma żadnego sensu. „string * & val” implikuje „string val”, * i & anulują się nawzajem. Wreszcie nie można przekazać zmiennej typu string do funkcji („string val”). Do funkcji można przekazywać tylko podstawowe typy danych, ponieważ inne typy danych muszą być przekazywane jako wskaźnik lub referencja. Do funkcji można przypisać string & val lub string * val.