Passer des références aux pointeurs en C ++

Question

Autant que je sache, il n'y a aucune raison pour que je ne sois pas autorisé à transmettre une référence à un pointeur en C ++. Cependant, mes tentatives pour y parvenir échouent et je ne sais pas pourquoi.

Voici ce que je fais:

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

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

Et j'obtiens cette erreur:

ne peut pas convertir le paramètre 1 de 'std :: string *' en 'std :: string * &'

Je fais probablement une erreur stupide quelque part, mais je ne vois pas ce que je fais de mal pour ma vie.

Answer 1

Votre fonction s'attend à une référence à un pointeur de chaîne dans l'appel de la portée, non pas un anonyme, un pointeur de chaîne. Donc:

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

devrait compiler l'amende juste. Cependant, ce n'est utile que si vous avez l'intention de modifier le pointeur de vous passer à la fonction. Si vous avez l'intention de modifier la chaîne elle-même, vous devez utiliser une référence à la chaîne, comme le Souci suggéré. Avec cela à l'esprit devrait être plus évident pourquoi le compilateur se plaint de vous code original. Dans votre code, le pointeur est créé "à la volée", en modifiant le pointeur aurait pas de conséquence et qui n'est pas ce qui est prévu. L'idée d'une référence (ou un pointeur) est une référence renvoie toujours à un objet réel.

Answer 2

Le problème est que vous essayez de lier un temporaire à la référence, ce que C ++ n'autorise pas, sauf si la référence est const .

Vous pouvez donc effectuer l’une des opérations suivantes:

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

Answer 3

Modifier:

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

EDIT:

Cela s'appelle ref-to-pointer et vous ne pouvez pas passer adresse temporaire comme une référence à la fonction. ( sauf si c'est const reference).

Cependant, j'ai montré std::string* pS = &s; (pointeur sur une variable locale), son utilisation typique serait : lorsque vous souhaitez que le destinataire de l'appel pour changer le pointeur lui-même, pas de l'objet vers lequel il pointe. Par exemple, une fonction qui alloue de la mémoire et assigne l'adresse de la zone mémoire, elle a alloué à son argument doit prendre une référence à un pointeur, ou un pointeur de pointeur:

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

}

Answer 4

&s produit un pointeur temporaire sur une chaîne et vous ne pouvez pas faire référence à un objet temporaire.

Answer 5

Essayer:

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

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

ou

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

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