Différence entre les arguments de la fonction déclarée avec & et * en C++

J'ai tapé l'exemple suivant:

#include <iostream>
double f(double* x, double* y)
{
    std::cout << "val x: " << *x << "\n";
    std::cout << "val y: " << *y << "\n";
    return *x * *y;
}
double f2(double &x, double &y)
{
    std::cout << "val x: " << x << "\n";
    std::cout << "val y: " << y << "\n";
    return x * y;
}
int main()
{
    double a, b;
    a = 2;
    b = 3; 
    std::cout << f(&a, &b) << "\n";
    std::cout << f2(a, b) << "\n";
    return 0;
}

Dans la fonction f je déclare x et y comme des pointeurs de qui je peux obtenir la valeur en utilisant *x. Lors de l'appel de f j'ai besoin de passer l'adresse de mon passé arguments, c'est pourquoi je passe &a, &b. f2 est le même à l'exception de la définition est différente.

Maintenant, ma question est: Sont-ils vraiment la même chose concernant la gestion de la mémoire? Les deux ne font aucune copie de la valeur passée mais au lieu de passer une référence?
Je me demande sur f2 parce que je ne pouvais pas lire l'adresse de x dans f2 donc je savoir plus à propos de x et y dans f (là, je sais, adresse ET valeur).

Merci d'avance!

Modifier: Ok merci, après avoir fait un peu plus de recherche, j'ai trouvé un très utile sujet:

Pointeur vs Référence
Il y a également un lien vers google directives de codage http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Reference_Arguments qui est tout à fait useful je me sens (ce que j'ai compris maintenant, c'est une forme de l'objet goût) pour faire plus de clair

  • Ce n'est pas C, c'est le C++.
  • Ah je vois, donc en C, j'ai toujours utiliser des pointeurs, ok merci! Ne le savais pas jusqu'à présent!
  • >Google guide de style - l'éviter. Il était dépassé en 2008 (date de aswer), et c'est encore pire aujourd'hui.
  • Ok merci pour les informer!
  • éviter laquelle? le " f " du style ou de la 'f2' style?
  • Éviter les Google Guide de Style. Il est tout à fait obsolète.

InformationsquelleAutor tim | 2011-04-28
  1. 53

    f2 est de prendre c'est des arguments par référence, qui est essentiellement un alias pour les arguments que vous avez pass. La différence entre pointeur et référence est une référence ne peut pas être NULL. Avec le f vous avez besoin pour passer le adresse (à l'aide de & operator) des paramètres que vous passez le pointeur, où, quand vous passez par référence vous venez de passer les paramètres et l'alias est créé.

    Passage par référence const (const double& ref) est préféré lorsque vous n'allez pas changer les arguments à l'intérieur de la fonction, et lorsque vous vous apprêtez à changer, l'utilisation non-const de référence.

    Pointeurs sont principalement utilisés lorsque vous en avez besoin pour être en mesure de passer NULL à vos paramètres, évidemment, vous aurez besoin de vérifier à l'intérieur de votre fonction si le pointeur n'a pas été NULL avant de l'utiliser.

    • Pourquoi n'a besoin de quelqu'un pour passer la valeur Null pour les paramètres?
    • Bien ils ont probablement besoin d'être mesure pour passer la valeur null si nécessaire. Évidemment, ils ne vont pas passer tout le temps.
    • Couper et nettoyer, bonne description.merci
    • Q: "La différence entre pointeur et référence est une référence ne peut pas être NULL". La plus simple et la réponse claire, alors que vous devriez et quand ne pas utiliser * vs & que les arguments de la fonction. Un alias ne peut être NULL.
    InformationsquelleAutor Tony The Lion
  2. 12

    C'est juste sucre syntaxique pour éviter d'avoir à utiliser * chaque fois que vous faites référence à l'argument. Vous pouvez toujours utiliser & d'avoir l'adresse de x dans f2.

    • +1 pour le "sucre syntaxique" 🙂
    • Personnellement, je pense qu'il est plus que juste cela. Il affirme que l'argument NE peut pas être nulle et n'est PAS une option. Avec des pointeurs vous ne pouvez jamais dire et doit toujours vérifier. Avec les références de la signature de la fonction veille au respect de l'intention du programmeur et conduit à plus propre code qui reflète avec plus de précision que l'intention.
    • Vous avez raison, je n'ai pas mentionné le cas d'une valeur NULL.
    • Aussi, un pointeur en argument pourrait s'attendre à un tableau. Une référence argument prend spécifiquement un objet unique, avec aucune autre documentation nécessaire.
    InformationsquelleAutor philfr
  3. 10

    Une autre différence qui n'a pas été mentionné, c'est que vous ne pouvez pas changer ce qu'un renvoi fait référence. Cela ne fait pas beaucoup de différence dans l'appel de fonction exemple montré dans la question d'origine.

    int X(10), Y(20);
int *pX = X;
int& rY = Y;

*pX = 15; //change value of X
rY = 25;  //change value of Y

pX = Y;   //pX now points to Y

    rY toujours des points à Y et ne peut pas être déplacé.

    Références ne peut pas être utilisé pour indexer dans des tableaux simples comme des pointeurs.

    InformationsquelleAutor DanS
  4. 6

    Dans ma tête, les paramètres des fonctions sont toujours passé par valeur. Passage d'un int est facile d'imaginer, en passant un double est juste plus grand et le passage d'un struct ou class pourrait être très grande en effet.

    Mais en passant un pointeur vers quelque chose, eh bien, vous êtes juste de passage d'une adresse en valeur. (Un pointeur est souvent une taille appropriée pour le CPU comme un int.)

    Une référence est très similaire, et certainement, je pense à une référence comme un pointeur, mais avec du sucre syntaxique pour la faire ressembler à l'objet de son renvoi a été transmis par valeur.

    Vous pouvez aussi penser à une référence en tant que const pointeur, c'est à dire:

    int i;
int j;
int* p = &i;           //pointer to i
int* const cp = p;     //cp points to i, but cp cannot be modified
p = &j;                //OK - p is modified to point to j
*cp = 0;               //OK - i is overwritten
cp = &j;               //ERROR - cp cannot be modified

int& ri = i;           //ri refers to i
ri = 1;                //i is overwritten
ri = j;                //i is overwritten again
                       //Did you think ri might refer to j?

    Donc, un pointeur ne le double de temps: C'est une valeur sur dans son propre droit, mais il peut également point à un autre de valeur lorsque vous déréférencement d'elle, par exemple: *p.

    Aussi, pour avoir des paramètres de référence signifie que vous ne pouvez pas faire référence à quelque chose d'autre pendant la durée de vie de la fonction, car il n'y a aucun moyen d'exprimer cela.

    Une référence est supposée ne pas être en mesure d'être initialisé avec des null, mais pensez à ceci:

    void foo(int& i);

int* p = 0;
foo(*p);

    Cela signifie que les pointeurs doit être vérifié avant de vous les utilisez, mais les références ne peuvent pas être vérifiés. La mise en œuvre de foo() pourrait essayer de lire ou d'écrire dans i qui va provoquer une violation d'accès.

    Dans l'exemple ci-dessus le pointeur de la p devrait ont été vérifiées avant d'être utilisées dans l'appel à foo:

    if (p) foo(*p);
    • C'est vraiment très utile, d'excellents exemples. Vous pourriez peut-être ajouter un commentaire à votre void foo(int& i); exemple-à-dire quel est exactement le problème avec l'appeler avec un NULL pointeur.
    InformationsquelleAutor quamrana
  5. 2

    Vous auriez été en mesure de lire x adresse dans les deux fonctions.

    De le faire dans f2, vous devez bien sûr préfixe x par un & depuis, x est un référence à un double, et que vous voulez un adresse.

    Un bon de remarquer la différence entre les références et les pointeurs, c'est que l'ancien ne peut pas être NULL. Vous doit passer quelque chose (valide), tandis que lors de la fourniture d'un pointeur, vous devez indiquer dans la documentation si le passage de la valeur NULL est autorisé/bien définis.

    Une autre différence est une question de lisibilité: à l'aide des références à la place des pointeurs (si possible) rend le code moins encombré avec * et ->.

    InformationsquelleAutor ereOn