L'Argument le passage par référence au problème de pointeur

Chaque fois que j'essaie de compiler mon code j'obtiens l'erreur:

impossible de convertir le paramètre 1 de 'int *' int *&"

Il des tests du code ressemblant à ceci:

void set (int *&val){
   *val = 10;
}

int main(){
   int myVal;
   int *pMyVal = new int;
   set(&myVal); //<- this cause trouble
   set(pMyVal); //<- however this doesn't
}

Je voudrais appeler cette fonction dans seul coup, sans créer de pointeur quelque part pour seule raison pour la passer. Et comme les pointeurs n'ont pas de constructeur, quelque chose comme cela ne peut pas être fait. set(int*(&myVal)); . Est-il un autre moyen de passer le pointeur de référence sans avoir besoin de créer de variable temporaire?

Edit: d'ailleurs je sais pas pourquoi le code ne peut pas compiler (je suis juste de passage de l'adresse qui est peut-être de type int et non pas réelle pointeur). La question est de savoir comment d'autre peut-il être accompli.

Si vous ne voulez pas créer un pointeur, pourquoi avez-vous besoin de la fonction de prendre un pointeur (par référence)? Pourquoi ne pas set (int &v){v=10;}?
Parce que ma classe est de stocker de la valeur, mais cette valeur est ensuite passé en tant que pointeur vers une autre classe qui stocke ce pointeur. Ce pointeur doit être définie par référence à l'argument pointeur de fonction qui ne fait que ça, parce que sinon, le passé pointeur n'est pas vraiment de pointage de valeur, mais c'est de la copie. Et avant de fixer ce pointeur je ne veux pas créer temporaire pointeur juste pour être en mesure de passer.. C'est pourquoi je n'introduisent pas de problème réel, mais seulement ce qui ressemble à de la mon et il est plus facile.

OriginalL'auteur Raven | 2011-09-05

  1. 12

    Une référence à la non-const ne peut pas se lier à une rvalue. Le résultat de & opérateur est une rvalue. Jetez un oeil à la différence entre lvalues et rvalues ou lire une bonne C++ livre.

    Aussi, dans votre contexte, vous n'avez pas besoin de passer par référence. Ce qui suit est OK ainsi:

    void set (int *val){
   *val = 10;
}

    La référence pourrait être nécessaire si vous faites quelque chose comme cela;

    void set (int*& val){
   val = new int; //notice, you change the value of val, not *val
   *val = 10;
}
    donc int* const& p est une référence à une constante pointeur vers un entier, et il peut donc être attribué rvalue, droit?
    Oui, c'est correct. Mais pas besoin de passer des types intégrés par référence const. C'est moins efficace que le passage par valeur. Pour les Types Définis par l'Utilisateur, il est préférable de passer par référence à const

    OriginalL'auteur Armen Tsirunyan

  2. 2

    &myval est une rvalue (de type int*), parce que c'est temporaire. C'est un pointeur, mais vous ne pouvez pas le modifier, parce que c'est juste créé à la volée. Votre fonction set nécessite toutefois une non-const de référence, de sorte que vous ne pouvez pas passer à un temporaire.

    En revanche, pMyVal est un nom de variable, donc une lvalue, de sorte qu'il peut être passé comme un non-référence constante.

    Je dirais &myval est de type int * const &.
    Désolé, mais c'est incorrect et trompeur dans de nombreuses façons. Pour l'un, const int * & est une "référence à un pointeur sur un int const", pas une "référence de pointeur constant". Deuxièmement, il y a une distinction entre les références à const et rvalues (rvalues ne pas de type const T&). Troisièmement, un objet n'a pas besoin d'être nommé à être une lvalue.
    Oui, mon erreur. Fixe, et merci à vous!
    Je n'ai pas dit lvalues être nommé objets, j'ai dit que cet objet nommé est une lvalue. Pas tous les chats...
    ad objets nommés: je trouve votre formulation trompeuse, il indique que "lvalues" sont synonymes de "les objets nommés". Vous auriez pu écrire "... est un nom de variable (qui est une lvalue) ..." ou quelque chose. Pour l'autre question, lisez ce Armen a écrit.

    OriginalL'auteur Kerrek SB

  3. 0

    Un très simple exemple peut être trouvé dans cet endroit.
    http://markgodwin.blogspot.de/2009/08/c-reference-to-pointer.html

    OriginalL'auteur humblefool

  4. 0

    Vous pouvez voir l'exemple de code suivant:

    #include <iostream>
using namespace std;

void change(int*& ptr) {
    cout << endl;
    cout << "==================change(int*& ptr)====================" << endl;
    cout << "    &ptr = " << &ptr << endl;
    cout << "    ptr  = " << ptr << endl;
    cout << "=======================================================" << endl;
    cout << endl;
    *ptr *= *ptr;
}

int main(void) {
    int* ptrNumber = new int(10);

    cout << endl;
    cout << "&ptrNumber = " << &ptrNumber << endl;
    cout << "ptrNumber = " << ptrNumber << endl;
    cout << ">>> *ptrNumber = " << *ptrNumber << endl;
    change(ptrNumber);
    cout << "<<< *ptrNumber = " << *ptrNumber << endl;
}

    J'ai installé Cygwin et utilisée g++ pour compiler le ci-dessus le code source, le fichier binaire est out_pointer.exe.
    L'exécution de out_pointer.exe, la sortie est comme suit:

    $ ./out_pointer.exe

&ptrNumber = 0x28ac3c
ptrNumber = 0x800102c0
>>> *ptrNumber = 10

==================change(int*& ptr)====================
    &ptr = 0x28ac3c
    ptr  = 0x800102c0
=======================================================

<<< *ptrNumber = 100

    À partir du dessus de la sortie, nous voyons 

    &ptrNumber = &ptr

    Donc, ptr est un alias de ptrNumber. Vous pouvez modifier ptrNumber à l'intérieur de la fonction void modifier(int*& ptr) en modifiant les ptr. Par exemple, vous pouvez pointer un pointeur vers un autre emplacement de mémoire comme ci-dessous:

    #include <iostream>
using namespace std;

void change(int*& ptr) {
    cout << endl;
    cout << "==================change(int*& ptr)====================" << endl;
    cout << "    &ptr = " << &ptr << endl;
    cout << "    >>> ptr = " << ptr << endl;
    ptr = new int(20);
    cout << "    <<< ptr = " << ptr << endl;
    cout << "=======================================================" << endl;
    cout << endl;
}

int main(void) {
    int* ptrNumber = new int(10);

    cout << endl;
    cout << ">>> &ptrNumber = " << &ptrNumber << endl;
    cout << ">>> ptrNumber = " << ptrNumber << endl;
    cout << ">>> *ptrNumber = " << *ptrNumber << endl;
    change(ptrNumber);
    cout << "<<< &ptrNumber = " << &ptrNumber << endl;
    cout << "<<< ptrNumber = " << ptrNumber << endl;
    cout << "<<< *ptrNumber = " << *ptrNumber << endl;
}

    Nouveau de sortie:

    $ ./out_pointer.exe

>>> &ptrNumber = 0x28ac3c
>>> ptrNumber = 0x800102c0
>>> *ptrNumber = 10

==================change(int*& ptr)====================
    &ptr = 0x28ac3c
    >>> ptr = 0x800102c0
    <<< ptr = 0x80048328
=======================================================

<<< &ptrNumber = 0x28ac3c
<<< ptrNumber = 0x80048328
<<< *ptrNumber = 20

    OriginalL'auteur Son Nguyen

  5. 0

    Le problème est, int*&val ne peuvent être transmises qu'une lvalue, le résultat de &myVal ne l'est pas. Par la modification de la signature de void set(int* const& val), c'est à dire le compilateur ne va pas changer la valeur du pointeur.

    Toutefois, vous ne le ferais pas, parce que si vous n'allez pas à modifier la valeur du pointeur de la souris, puis en passant le pointeur de la valeur est la façon la plus simple de passer la valeur. Et si vous allez modifier la valeur du pointeur, alors vous avez besoin pour créer un temporaire pour recevoir le résultat.

    OriginalL'auteur Dave S