Existe-il des avantages de passer par un pointeur sur le passage par référence en C++?

Quels sont les avantages de passer par un pointeur sur le passage par référence en C++?

Dernièrement, j'ai vu un certain nombre d'exemples qui ont choisi passage d'arguments par des pointeurs au lieu de passer par référence. Existe-il des avantages à le faire?

Exemple:

func(SPRITE *x);

avec un appel de

func(&mySprite);

vs

func(SPRITE &x);

avec un appel de

func(mySprite);
  • N'oubliez pas new créer un pointeur et les problèmes qui en découlent de la propriété.
InformationsquelleAutor Matt Pascoe | 2008-12-02
  1. 208

    Un pointeur peut recevoir un paramètre NULL, un paramètre de référence ne peut pas. Si il y a toujours une chance que vous pourriez désirer pour passer à "sans objet", puis utiliser un pointeur au lieu d'une référence.

    Aussi, le passage par pointeur vous permet explicitement de le voir sur le site d'appel si l'objet est passé par valeur ou par référence:

    //Is mySprite passed by value or by reference?  You can't tell 
//without looking at the definition of func()
func(mySprite);

//func2 passes "by pointer" - no need to look up function definition
func2(&mySprite);
    • Réponse incomplète. En utilisant les pointeurs de ne pas autoriser des utilisations temporaires/objets promus, ni d'utiliser d'objet pointu similaire à la pile d'objets. Et il suggère que l'argument peut être NULL quand, la plupart du temps, une valeur NULL devrait être interdite. Lire litb de réponse pour une réponse complète.
    • Le deuxième appel de fonction utilisé pour être annoté func2 passes by reference. Alors que je comprends que vous vouliez dire, il passe "par référence" à partir d'une perspective de haut niveau, mis en œuvre par le passage d'un pointeur à un code de niveau de point de vue, c'était très déroutant (voir stackoverflow.com/questions/13382356/...).
    • Je ne pas acheter ce. Oui, vous pouvez passer un pointeur, donc qu'il doit être un paramètre de sortie, parce que ce qui est fait ne peut pas être const?
    • N'avons-nous pas ce passage de référence en C? J'utilise codeblock (mingw) dernière version et que la sélection d'un projet C. Toujours le passage par référence (func (int& a)) fonctionne. Ou est-il disponible en C99 ou C11 partir?
    • Non, C n'a pas de passé par référence à tous. func(int& a) n'est pas valide C dans n'importe quelle version de la norme. Vous êtes probablement de la compilation de vos fichiers en C++ par accident.
    • Vous êtes de droite. Mon nom de fichier a été .rpc et après modification .c il a donné d'erreur.
    • Voulez-vous dire "argument null?" Le paramètre est dans la déclaration de la fonction.
    • Un paramètre de référence peut recevoir NULL, @AdamRosenfield. Passer comme func(*NULL). Puis à l'intérieur de la fonction, test avec if (&x == NULL). Je suppose que cela semble laid, mais la différence entre pointeur et référence des paramètres est sucre syntaxique.
    • Non, c'est un Comportement Indéfini déréférencer un pointeur null

    InformationsquelleAutor Adam Rosenfield
  2. 231

    Passage par pointeur

    • Appelant doit prendre l'adresse -> n'est pas transparent
    • Une valeur 0 peut être fourni à dire nothing. Ceci peut être utilisé pour fournir des arguments optionnels.

    Passer par référence

    • Appelant transmet simplement l'objet -> transparent. Doit être utilisé pour la surcharge d'opérateur, comme la surcharge pour les types pointeur n'est pas possible (les pointeurs sont builtin types). Si vous ne pouvez pas faire string s = &str1 + &str2; à l'aide de pointeurs.
    • Non 0 valeurs possibles -> fonction Appelée n'a pas à vérifier pour eux
    • Référence à const accepte aussi temporaires: void f(const T& t); ... f(T(a, b, c));, les pointeurs ne peut pas être utilisé comme cela, puisque vous ne pouvez pas prendre l'adresse d'une mesure temporaire.
    • Dernier mais non le moindre, les références sont plus faciles à utiliser -> moins de risques de bugs.
    • De bons points pour les deux côtés de l'argument. Pour autant que je suis concerné, votre réponse est LA réponse. +1.
    • Passage par pointeur soulève également la " Est la propriété transférée ou non?' la question. Ce n'est pas le cas avec des références.
    • Vous devriez également ajouter qu'il est plus propre d'utiliser le pointeur lorsqu'il y a transfert de propriété, ou pour enregistrer les callbacks (élément qui doit survivre à l'actuel cadre de la pile).
    • Je suis en désaccord avec "moins de risques de bugs". Lors de l'inspection du site d'appel et le lecteur voit "foo( &s )" il est clair que s peut être modifié. Quand vous lisez "foo( s )" il n'est pas clair du tout si s peut être modifié. C'est une source importante de bugs. Il est peut-être moins de chance d'une certaine classe de bugs, mais dans l'ensemble, le passage par référence est une énorme source de bugs.
    • Qu'entendez-vous par "transparent" ?
    • si vous voyez foo(&a) à un site d'appel, vous savez foo() prend un pointeur de type. Si vous voyez foo(a), vous ne savez pas si il faut une référence.
    • qui ne semble pas être le contexte dans lequel "transparent" est utilisé dans Johannes post.
    • Pour mon bien et pour celui des Gbert90, pourriez-vous élaborer?
    • dans votre explication, vous suggérez "transparent" pour dire quelque chose le long des lignes de "évident que l'appelant est en passant un pointeur, mais pas évident que l'appelant est en train de passer d'une référence". Dans Johannes post, il dit "Passage par pointeur -- l'Appelant doit prendre l'adresse -> n'est pas transparent" et "Passer par référence -- l'Appelant transmet simplement l'objet -> transparent" -- ce qui est presque le contraire de ce que vous dites. Je pense que Gbert90 la question "Qu'entendez-vous par "transparent"," est toujours valable.
    • La transparence signifie "facile pour les autres de voir quelles actions sont réalisées" (wikipedia). Une adresse de l'opérateur sur le site d'appel rend plus transparent pour les lecteurs que cet argument peut être modifié. J'ai édité la réponse, nous allons voir si le changement est accepté.
    • D'accord, quand je lisais Adam commentaire, il fait sens concernant transparent puis, quand je suis venu à cette réponse, il me confondre, car il est à l'envers. Juste de donner un outsiders point de vue.
    • +1, super réponse. Bien que j'avoue que j'ai été momentanément confus par votre utilisation de -> dans votre réponse...nous parlons pointeurs ici après tout. 😉
    • et les autres: je suppose que Johannes parle de l'interface de transparence. Cela signifie qu'il interface masque la complexité du moteur ci-dessous. Si vous passer l'objet directement à la fonction, la fonction peut obtenir une référence ou d'obtenir la valeur, vous ne pouvez pas savoir, mais l'interface reste la même, et c'est plus simple pour l'utilisateur final. Voir en.wikipedia.org/wiki/...

    InformationsquelleAutor Johannes Schaub - litb
  3. 60

    Allen Holub est "Assez de Corde pour se Tirer dans le Pied", répertorie les 2 règles suivantes:

    120. Reference arguments should always be `const`
121. Never use references as outputs, use pointers

    Il énumère plusieurs raisons pourquoi les références ont été ajoutées à C++:

    • ils sont nécessaires à la définition de la copie des constructeurs
    • ils sont nécessaires pour la surcharge de l'opérateur
    • const références vous permettent de passer-par-valeur sémantique, tout en évitant une copie

    Son point principal est que les références ne doivent pas être utilisés en tant que "production" des paramètres, car sur le site d'appel il n'y a aucune indication à savoir si le paramètre est une référence ou une valeur de paramètre. Donc sa règle est de n'utiliser que const des références comme arguments.

    Personnellement, je pense que c'est une bonne règle de pouce comme il le rend plus clair lorsqu'un paramètre est un paramètre de sortie ou pas. Cependant, alors que j'ai personnellement d'accord avec cette en général, je ne me laisser influencer par les opinions des autres sur mon équipe si ils font valoir pour les paramètres de sortie comme des références (des développeurs comme énormément).

    • Ma position dans cette argument est que si le nom de la fonction le rend tout à fait évident, sans vérification de la documentation, que le paramètre sera modifié, puis un non-const de référence est OK. Alors, personnellement, je serais d'autoriser "getDetails(DetailStruct &resultat)". Un pointeur, il soulève le laid possibilité d'une entrée NULLE.
    • cela semble être une autre bonne règle de pouce
    • C'est trompeur. Même si certains n'aiment pas les références, ils sont une partie importante de la langue, et devraient être utilisées comme que. Cette ligne de raisonnement, c'est comme dire de ne pas utiliser des modèles, vous pouvez toujours utiliser des récipients de void* pour stocker n'importe quel type. Lire la réponse par litb.
    • Je ne vois pas comment cela est trompeur - il y a des moments lorsque des références sont nécessaires, et il ya des moments où les meilleures pratiques suggèrent de ne pas les utiliser, même si vous le pouviez. La même chose peut être dit pour n'importe quel fonction de la langue en héritage, non-membre des amis, la surcharge d'opérateur, MI, etc...
    • En passant, je suis d'accord que litb la réponse est très bon, et est certainement plus complet que ce que je vient d'être élu à se concentrer sur l'examen de la justification pour éviter l'utilisation des références comme les paramètres de sortie.
    • Cette règle est utilisée dans google c++ guide de style: google-styleguide.googlecode.com/svn/trunk/...
    • Je pense qu'il y a une exception très importante de ces règles: la swap fonction joue un rôle très important dans la copie d'échange à l'idiome, mais sans déclarer ses paramètres en tant que non-const références, il n'y a aucun moyen de faire ce qu'il a voulu faire. En utilisant les pointeurs ici sera pénible et les sauts de de son une exception sans promesse facilement.

    InformationsquelleAutor Michael Burr
  4. 59

    J'aime le raisonnement par un article du "cplusplus.com:"

    1. Passage par valeur lorsque la fonction ne souhaitez pas modifier le paramètre et la valeur est facile à copier (ints, double, char, boolean, etc... les types simples. std::string, std::vector, et tous les autres conteneurs STL ne sont PAS les types simples.)

    2. Passer par const pointeur lorsque la valeur est cher pour la copie ET la fonction ne voulez pas modifier la valeur pointée ET la valeur NULL est valide, la valeur attendue que la fonction de poignées.

    3. Passer par des non-const pointeur lorsque la valeur est cher pour de la copie ET de la fonction veut modifier la valeur pointée ET la valeur NULL est valide, la valeur attendue que la fonction de poignées.

    4. Passer par référence const lorsque la valeur est cher pour la copie ET la fonction ne voulez pas modifier la valeur visée ET NUL ne serait pas une valeur valide si un pointeur est utilisé à la place.

    5. Passer par des non-cont de référence lorsque la valeur est cher pour de la copie ET de la fonction veut modifier la valeur visée ET NUL ne serait pas une valeur valide si un pointeur est utilisé à la place.

    6. Lors de l'écriture du modèle de fonctions, il n'y a pas une réponse tranchée parce qu'il y a quelques compromis à considérer qui sont au-delà de la portée de cette discussion, mais il suffit de dire que la plupart des modèle de prise de fonctions de leurs paramètres par valeur ou (const) de référence, cependant, parce que itérateur la syntaxe est similaire à celui des pointeurs (astérisque de "déréférencer"), le modèle de fonction qui attend les itérateurs comme arguments par défaut accepter les pointeurs (et pas vérifier depuis NULL NULL itérateur concept a une syntaxe différente).

    http://www.cplusplus.com/articles/z6vU7k9E/

    Ce que je retiens, c'est que la grande différence entre le fait de choisir d'utiliser un pointeur ou une référence paramètre si la valeur NULL est une valeur acceptable. C'est tout.

    Si la valeur est entrée, de sortie, modifiable etc. devrait être dans la documentation et /ou les commentaires au sujet de la fonction, après tout.

    • Oui, pour moi, le NUL de termes connexes sont les principales préoccupations ici. Merci pour la citation..
    InformationsquelleAutor R. Navega
  5. 8

    De précisions pour les précédents posts:

    Références sont PAS une garantie d'un pointeur non null. (Si l'on a souvent les traiter comme tels.)

    Alors que terrifiant mauvais code, comme vous derrière le bûcher mauvais code, le compiler & exécuter: (Au moins sous mon compilateur.)

    bool test( int & a)
{
  return (&a) == (int *) NULL;
}

int
main()
{
  int * i = (int *)NULL;
  cout << ( test(*i) ) << endl;
};

    Le vrai problème que j'ai avec les références se trouve avec les autres programmeurs, désormais appelé IDIOTS, qui allouer, dans le constructeur, de libérer dans le destructeur, et ne parviennent pas à fournir un constructeur de copie ou de l'opérateur=().

    Soudainement il y a un monde de différence entre foo(BAR) et foo(BAR & bar). (Automatique bit à bit de l'opération de copie est appelé. Libération de la mémoire dans le destructeur est appelé deux fois.)

    Heureusement, les compilateurs modernes pour reprendre le double de désallocation de la même pointeur. Il y a 15 ans, ils n'ont pas. (Gcc/g++, l'utilisation setenv MALLOC_CHECK_ 0 de revisiter les anciennes façons de faire.) Elle résulte, en vertu de l'DÉC UNIX, dans le même espace mémoire alloué à deux objets différents. Beaucoup de débogage plaisir...

    Plus pratiquement:

    • Références cacher que vous modifiez les données stockées ailleurs.
    • Il est facile de confondre une Référence à un objet Copié.
    • Pointeurs à l'évidence!
    • ce n'est pas le problème de la fonction ou de références. vous rompre les règles de la langue. un déréférencement d'un pointeur null en lui-même est déjà un comportement indéfini. "Les références ne sont PAS une garantie d'un pointeur non null.": la norme elle-même dit qu'ils sont. d'autres moyens de constituer un comportement indéfini.
    • Je suis d'accord avec litb. Si cela est vrai, le code à nous montrer plus sabotage qu'autre chose. Il y a des façons de saboter quoi que ce soit, y compris à la fois la "référence" et "pointeur" notations.
    • Je n'ai dit que c'était "prenez-vous derrière le bûcher du mauvais code"! Dans la même veine, vous pouvez également avoir i=new FOO; supprimer i; test(*i); l'Autre (malheureusement commun) bancales pointeur ou de référence de l'événement.
    • Il n'est effectivement pas référence NULL, c'est ça le problème, mais plutôt VIA que déréférencé (null) de l'objet. En tant que tel, il n'y a vraiment pas de différence (autre que la syntaxe) entre les pointeurs et les références à partir d'un langage de mise en œuvre de la perspective. C'est les utilisateurs qui ont des attentes différentes.
    • Peu importe ce que vous faites avec la référence renvoyée, le moment de vous dire *i, votre programme a un comportement indéfini. Par exemple, le compilateur peut voir ce code et d'assumer "OK, ce code a un comportement indéfini dans tous les chemins de code, de sorte que l'ensemble de cette fonction doit être inaccessible." Ensuite, il va supposer que toutes les branches qui conduisent à cette fonction ne sont pas prises. C'est régulièrement effectuée optimisation.
    • comme Scott Meyers a dit dans son livre "Plus Effective C++" à la page 10 à l'égard de faire référence à déréférencé pointeur null "c'est bien l'eveil, de la pure et simple. Les résultats sont indéfinis et les gens qui écrivent ce genre de code devrait être évitée jusqu'à ce qu'ils acceptent de cesser et de s'abstenir"
    • Non, @DavidStone, le test(*i) d'instruction n' pas déréférencer NULL. NUL ne serait déréférencé si la fonction consulté le paramètre a sans & de l'opérateur. Peut-être que c'est supposé être impossible de passer la valeur NULL juste pour éviter le besoin d'écrire plus l'épreuve des balles code.
    • href="http://eel.is/c++projet/dcl.ref#5" >anguille.est/c++projet/dcl.ref#5 "Une référence doit être initialisée à se référer à un objet valide ou d'une fonction. [ Note: En particulier, une référence null ne peut pas exister dans un programme bien défini, parce que la seule façon de créer une telle référence serait à lier à la “objet” obtenues par l'indirection par l'intermédiaire d'un pointeur null, ce qui provoque un comportement indéfini."
    • La clause de la règle que vous avez cités, @DavidStone, semble à la limite de la bienséance de ce que le programmeur peut faire, plutôt que de spécifier ce que le compilateur doit faire. C'est la langue utilisation, pas mise donc, on se demande si c'est dans la portée. Quelle que soit, dans l'exemple donné, la valeur NULL est pas déréférencé.

    InformationsquelleAutor Mr.Ree
  6. 3

    Pas vraiment. En interne, le passage par référence est effectuée par essentiellement en passant l'adresse de l'objet référencé. Donc, il ya vraiment pas de gains d'efficacité en passant un pointeur.

    Le passage par référence a un avantage, cependant. Vous êtes assuré de disposer d'une instance d'un objet/type qui est passé en. Si vous passez un pointeur, alors vous courez le risque de recevoir un pointeur NULL. En utilisant par référence, vous poussez un implicite NULL check-up d'un niveau à l'appelant de votre fonction.

    • C'est à la fois un avantage et un inconvénient. De nombreuses Api utiliser des pointeurs NULL pour signifier quelque chose d'utile (c'est à dire NULLE timespec attendre à jamais, tandis que la valeur des moyens attendre que long).
    • Je ne veux pas être tatillon mais: je pas dire qu'on est garantie pour obtenir un exemple d'obtenir une référence. En balançant les références sont toujours possibles si l'appelant d'une fonction de références d'un bancales pointeur, ce qui le destinataire de l'appel ne peut pas savoir.
    • parfois, vous pouvez même obtenir des performances à l'aide de références, car ils n'ont pas besoin de prendre de stockage et n'ont pas les adresses attribuées pour lui-même. pas d'indirection nécessaire.
    • Les programmes qui contiennent en balançant les références ne sont pas valide en C++. Donc, oui, le code peut supposons que toutes les références sont valides.
    • Je peux certainement déréférencer un pointeur null, et le compilateur ne sera pas en mesure de dire... si le compilateur ne peut pas dire que c'est non valide "C++", est-il vraiment invalide?
    • Oui, il est invalide, même si le compilateur ne peut pas dire. Le simple fait de créer une balançant de référence est spécifié à entraîner un comportement indéterminé. Vous pouvez (eh bien, vous n'avez pas le choix en fait) écrire du code sur l'hypothèse que le programme est dans un état.
    • Donc, pour être tatillon, on pourrait dire "en supposant que le programme de l'état n'est pas déjà FUBARed, vous avez la garantie d'une instance", au lieu de "vous avez la garantie d'une instance". Une pendouille de référence est un exemple de FUBARed programme de l'état, mais il devrait aller sans dire que votre interlocuteur obéit à des règles particulières.

    InformationsquelleAutor Brian