Lorsque passer par pointeur est préférable de passer par référence en C ++?

Question

Je peux imaginer un cas dans lequel le paramètre d'entrée pourrait être NULL, de sorte que le passage par pointeur est préférable, mais pas par référence?

Quelqu'un peut-il ajouter plus de cas?

Answer 1

Certains, comme le passage du pointeur de mieux dans les cas où l'objet est transmis, en réalité, va être modifié. Ils utilisent passer-par-const-référence lorsque l'objet est passé par référence, afin d'éviter une copie de l'objet, mais ne sera pas modifié dans la fonction.

Dans l'illustration, prendre les fonctions suivantes:

int foo(int x);
int foo1(int &x);
int foo2(int *x);

Maintenant dans le code, je ne les suivants:

int testInt = 0;

foo(testInt);   // can't modify testInt
foo1(testInt);  // can modify testInt

foo2(&testInt); // can modify testInt

Dans l'appel de foo vs toto1, il n'est pas apparent dans les appelants point de vue (ou un programmeur lecture du code) que la fonction peut modifier testInt sans avoir à regarder la signature de la fonction. En regardant foo2, un lecteur peut facilement voir que la fonction peut en effet modifier la valeur de testInt car la fonction est de recevoir l'adresse du paramètre. Notez que ce n'est pas une garantie de l'objet est modifiée réellement, mais d'être cohérent dans l'utilisation de références vs pointeurs aide. En général, si vous voulez suivre ces directives de manière constante que vous devez toujours passer const références lorsque vous voulez éviter les copies, et de passer par pointeur lorsque vous voulez être en mesure de modifier l'objet.

Answer 2

Le C++ FAQ Lite a une très bonne réponse à cette question:

Utiliser des références si vous le pouvez, et les pointeurs quand il le faut.

Les références sont généralement préféré plus de les pointeurs chaque fois que vous n'avez pas besoin "remettre en place". Cela signifie généralement que les références sont les plus utiles dans un la classe de l'interface publique. Références apparaissent généralement sur la peau d'un objet, et des pointeurs à l'intérieur.

La seule exception est pour le cas où un de la fonction paramètre ou la valeur de retour besoin d'une "sentinelle" de référence - un de référence qui ne se réfère pas à un objet. C'est habituellement préférable de procéder par retour/prendre un pointeur, et de donner le pointeur NULL dans cette spéciale signification (les références devraient toujours alias objets, pas un déréférencé NULL pointeur).

Remarque: Ancienne ligne de programmeurs C parfois n'aime pas les références, car ils fournir des services de référence sémantique qui n'est pas explicite en l'appelant du code. Après en C++ expérience, cependant, un se rend vite compte de ce qui est une forme de se cacher de l'information, ce qui est un atout plutôt qu'un handicap. E. g., les programmeurs doivent écrire le code de la langue du problème plutôt que de le langage de la machine.

Answer 3

Vous avez beaucoup de situations dans le monde réel de la programmation, dans lequel un paramètre n'existe pas ou n'est pas valide et ce qui peut dépendre de l'exécution de la sémantique du code. Dans de telles situations, vous pouvez utiliser la valeur NULL (0) pour indiquer cet état. En dehors de cela,

• Un pointeur peut être ré-attribuée à un nouveau état. Une référence ne peut pas. C'est souhaitable dans certaines situations.
• Un pointeur permet de transférer propriétaire du navire la sémantique. Ceci est particulièrement utile en environnement multi-thread si l' paramètre d'état est utilisée pour exécuter dans un thread séparé et vous n'avez pas généralement sondage jusqu'à ce fil de discussion a il est sorti.

Bien que si suffisamment de temps est consacré à la conception du code correctement, ces situations peuvent être évitées; dans la pratique, il n'est pas possible à chaque fois.

Answer 4

En plus d’autres réponses sur la sémantique de propriété (en particulier les fonctions d’usine).

Bien qu’il ne s’agisse pas d’une raison technique, le guide de style exige que tous les paramètres susceptibles d’être modifiés soient transmis par un pointeur. Cela rend évident sur le site d'appel que l'objet peut être modifié.

 void Operate(const int &input_arg, int *output_arg) {
  *output_arg = input_arg + 1;
}

int main() {
  int input_arg = 5;
  int output_arg;
  Foo(input_arg, &output_arg);  // Passing address, will be modified!
}
 

Answer 5

Règle numéro un pour cela: Si NULL est une valeur valide pour le paramètre de fonction dans le contexte de la fonction, transmettez-le en tant que pointeur, sinon transmettez-le en tant que référence.

Raisonnement, si cela ne peut pas (ne devrait pas!) Être NULL, alors ne vous laissez pas tenter par la vérification de NULL ou de risquer des problèmes en raison de sa valeur NULL.