Quelles sont les différences entre un pointeur de variable et une variable de référence en C++?

1. Un pointeur peut être ré-attribuée:

   int x = 5;
   int y = 6;
   int *p;
   p =  &x;
   p = &y;
   *p = 10;
   assert(x == 5);
   assert(y == 10);

   Une référence ne peut, et doit être attribuée à l'initialisation:

   int x = 5;
   int y = 6;
   int &r = x;

2. Un pointeur a sa propre adresse de la mémoire et de la taille de la pile (4 octets sur x86), alors que les actions de référence de la même adresse mémoire (avec la variable d'origine), mais aussi prend de la place sur la pile. Depuis une référence a la même adresse que la variable elle-même, il est sûr de penser à une référence comme un autre nom pour la même variable. Note: Ce qu'est un pointeur peut être sur la pile ou le tas. Idem une référence. Ma demande dans cette déclaration n'est pas qu'un pointeur doit pointer vers la pile. Un pointeur est une variable qui contient une adresse mémoire. Cette variable est sur la pile. Depuis une référence a son propre espace sur la pile, et depuis l'adresse est la même que la variable de référence. Plus sur pile vs tas. Cela implique qu'il y est une vraie adresse de référence que le compilateur ne vais pas vous dire.

   int x = 0;
   int &r = x;
   int *p = &x;
   int *p2 = &r;
   assert(p == p2);

3. Vous pouvez avoir des pointeurs de pointeurs de pointeurs offrant plus de niveaux d'indirection. Alors que les références seulement offrir un niveau d'indirection.

   int x = 0;
   int y = 0;
   int *p = &x;
   int *q = &y;
   int **pp = &p;
   pp = &q;//*pp = q
   **pp = 4;
   assert(y == 4);
   assert(x == 0);

4. Pointeur peut être attribué nullptr directement, tandis que la référence ne peut pas. Si vous essayez assez dur, et vous savez comment, vous pouvez faire de l'adresse de référence nullptr. De même, si vous essayez assez dur, vous pouvez disposer d'une référence à un pointeur, et alors que la référence peut contenir nullptr.

   int *p = nullptr;
   int &r = nullptr; <--- compiling error
   int &r = *p;  <--- likely no compiling error, especially if the nullptr is hidden behind a function call, yet it refers to a non-existent int at address 0

5. Pointeurs pouvez effectuer une itération sur un tableau, vous pouvez utiliser ++ pour aller à l'élément suivant qu'un pointeur pointant vers, et + 4 pour aller à la 5ème élément. Ce n'est pas une question de ce que la taille de l'objet, c'est que le pointeur pointe.

6. Un pointeur doit être déréférencés avec * pour accéder à l'emplacement de mémoire c'points, alors qu'une référence peut être utilisé directement. Un pointeur vers un class/struct utilise -> pour accéder à ses membres alors que, d'une référence utilise un ..

7. Un pointeur est une variable qui contient une adresse mémoire. Indépendamment de la façon dont une référence est mis en œuvre, une référence a la même adresse mémoire comme élément de référence.

8. Les références ne peuvent pas être placés dans un tableau, alors que les pointeurs peuvent être Mentionnées par l'utilisateur @litb)

9. Const références peuvent être liées à des temporaires. Les pointeurs ne peut pas (non sans une certaine indirection):

   const int &x = int(12); //legal C++
   int *y = &int(12); //illegal to dereference a temporary.

   Ce fait const& plus sûr pour une utilisation dans les listes d'arguments et ainsi de suite.

Si vous voulez être vraiment pointilleux, il y a une chose que vous pouvez faire avec une référence que vous ne pouvez pas faire avec un pointeur: prolonger la durée de vie d'un objet temporaire. En C++, si vous liez un const référence à un objet temporaire, la durée de vie de l'objet est la durée de vie de la référence.

std::string s1 = "123";
std::string s2 = "456";

std::string s3_copy = s1 + s2;
const std::string& s3_reference = s1 + s2;

Dans cet exemple s3_copy des copies de l'objet temporaire qui est un résultat de la concaténation. Alors que s3_reference en essence devient l'objet temporaire. C'est vraiment une référence à un objet temporaire qui a maintenant la même durée de vie que de la référence.

Si vous essayez cela, sans const il n'arrive pas à compiler. Vous ne pouvez pas lier un non-const référence à un objet temporaire, et vous ne pouvez pas prendre son adresse aux fins de cette question.

En dehors de sucre syntaxique, une référence est un const pointeur (pas pointeur vers un const). Vous devez établir ce que l'on fait référence lorsque vous déclarez une variable de référence, et vous ne pouvez pas le changer plus tard.

Mise à jour: maintenant que j'y pense un peu plus, il existe une différence importante.

Const pointeur de cible peut être remplacée par la prise de son adresse et à l'aide d'un const exprimés.

Une référence de la cible ne peut pas être remplacé en quelque sorte court de l'AC.

Cela devrait permettre au compilateur de ne plus l'optimisation d'une référence.

Les références sont très similaires à des pointeurs, mais ils sont spécifiquement conçus pour être utiles à l'optimisation des compilateurs.

• Références sont conçus de telle sorte qu'il est beaucoup plus facile pour le compilateur à garder une trace de référence alias variables. Deux principales caractéristiques sont très importantes: pas de référence de "l'arithmétique" et pas de la réaffectation de références. Ceux-ci permettent au compilateur de déterminer lequel des références alias les variables au moment de la compilation.
• Références sont autorisés à faire référence à des variables qui n'ont pas d'adresses de la mémoire, tels que ceux qui le compilateur choisit de mettre dans des registres. Si vous prenez l'adresse d'une variable locale, c'est très dur pour le compilateur de le mettre dans un registre.

Comme un exemple:

void maybeModify(int& x); //may modify x in some way

void hurtTheCompilersOptimizer(short size, int array[])
{
    //This function is designed to do something particularly troublesome
    //for optimizers. It will constantly call maybeModify on array[0] while
    //adding array[1] to array[2]..array[size-1]. There's no real reason to
    //do this, other than to demonstrate the power of references.
    for (int i = 2; i < (int)size; i++) {
        maybeModify(array[0]);
        array[i] += array[1];
    }
}

Un compilateur optimisant peut se rendre compte que nous sommes accéder à un[0] et[1] tout un groupe. Il serait l'amour pour optimiser l'algorithme de:

void hurtTheCompilersOptimizer(short size, int array[])
{
    //Do the same thing as above, but instead of accessing array[1]
    //all the time, access it once and store the result in a register,
    //which is much faster to do arithmetic with.
    register int a0 = a[0];
    register int a1 = a[1]; //access a[1] once
    for (int i = 2; i < (int)size; i++) {
        maybeModify(a0); //Give maybeModify a reference to a register
        array[i] += a1;  //Use the saved register value over and over
    }
    a[0] = a0; //Store the modified a[0] back into the array
}

De faire une telle optimisation, il faut prouver que rien ne peut changer de tableau[1] lors de l'appel. C'est assez facile à faire. je n'est jamais inférieur à 2, tableau[i] ne peut jamais se référer à tableau[1]. maybeModify() est donnée a0 comme référence (aliasing tableau[0]). Parce qu'il n'y a pas de "référence" de l'arithmétique, le compilateur vient de prouver qu'maybeModify n'est jamais l'adresse de x, et il a prouvé que rien ne change: tableau[1].

Il doit également prouver qu'il n'existe aucun moyen d'un futur appel pouvait lire/écrire un[0], alors que nous avons un registre temporaire copie dans a0. C'est souvent triviale à prouver, parce que dans de nombreux cas, il est évident que la référence n'est jamais stocké dans une structure permanente comme une instance de classe.

Maintenant faire la même chose avec des pointeurs

void maybeModify(int* x); //May modify x in some way

void hurtTheCompilersOptimizer(short size, int array[])
{
    //Same operation, only now with pointers, making the
    //optimization trickier.
    for (int i = 2; i < (int)size; i++) {
        maybeModify(&(array[0]));
        array[i] += array[1];
    }
}

Le comportement est le même; seulement, maintenant, il est beaucoup plus difficile à prouver que maybeModify ne jamais modifier array[1], parce que nous avons déjà donné un pointeur; le chat est sorti du sac. Maintenant, il y a à faire, ce qui est beaucoup plus difficile la preuve: une analyse statique de maybeModify pour prouver qu'il n'écrit jamais &x + 1. Il doit également prouver qu'il n'a jamais enregistre un pointeur qui peut se référer à tableau[0], qui est tout aussi délicate.

Les compilateurs modernes sont de mieux en mieux à l'analyse statique, mais il est toujours agréable de les aider et à utiliser des références.

Bien sûr, sauf intelligente telles optimisations, des compilateurs en effet tour de références dans des pointeurs en cas de besoin.

EDIT: Cinq ans après la publication de cette réponse, j'ai trouvé une réelle différence technique où les références sont différentes que juste une façon différente de regarder la même aborder le concept. Les références peuvent modifier la durée de vie des objets temporaires dans une manière que les pointeurs ne peut pas.

F createF(int argument);

void extending()
{
    const F& ref = createF(5);
    std::cout << ref.getArgument() << std::endl;
};

Normalement temporaire des objets tels que celui créé par l'appel à createF(5) sont détruits à la fin de l'expression. Cependant, par la liaison de l'objet de référence, ref, C++ permettra de prolonger la durée de vie de l'objet temporaire jusqu'à ce que ref est hors de portée.

Une référence ne peut jamais être NULL.

Il y a une différence sémantique qui peut paraître ésotérique, si vous n'êtes pas familier avec l'étude des langages de programmation en un résumé ou même universitaire de la mode.

Au plus haut niveau, l'idée de références, c'est qu'ils sont transparents "alias". Votre ordinateur peut utiliser une adresse pour les faire travailler, mais vous n'êtes pas censé vous inquiétez à ce sujet: vous êtes censés penser à eux comme "juste un autre nom" d'un objet existant et de la syntaxe en est le reflet. Ils sont plus stricts que les pointeurs de sorte que votre compilateur ne peut plus fiable de vous avertir lorsque vous vous apprêtez à créer une balançant de référence, que lorsque vous êtes sur le point de créer une balançant pointeur.

Au-delà de ça, il y a bien sûr quelques différences concrètes entre les pointeurs et les références. La syntaxe à utiliser est évidemment différente, et vous ne pouvez pas "re-siège" des références, des références à néant, ou ont des pointeurs vers des références.

Il n'a pas d'importance combien d'espace qu'il occupe, car vous ne pouvez pas voir n'importe quel effet secondaire (sans l'exécution de code) de tout l'espace qu'il faudrait jusqu'à.

D'autre part, une différence majeure entre les références et les pointeurs, c'est que temporaires affectés à const références vivre jusqu'à ce que la const de référence est hors de portée.

Par exemple:

class scope_test
{
public:
    ~scope_test() { printf("scope_test done!\n"); }
};

...

{
    const scope_test &test= scope_test();
    printf("in scope\n");
}

sera d'impression:

in scope
scope_test done!

C'est la langue mécanisme qui permet ScopeGuard de travail.

Une référence n'est pas un autre nom donné à la mémoire. C'est un immuable pointeur qui est automatiquement dé-référencé sur l'utilisation. En gros, ça revient à:

int& j = i;

En interne devient

int* const j = &i;

Une référence à un pointeur est possible en C++, mais l'inverse n'est pas possible signifie un pointeur vers une référence n'est pas possible. Une référence à un pointeur fournit un nettoyeur de syntaxe pour modifier le pointeur.
Regardez cet exemple:

#include<iostream>
using namespace std;

void swap(char * &str1, char * &str2)
{
  char *temp = str1;
  str1 = str2;
  str2 = temp;
}

int main()
{
  char *str1 = "Hi";
  char *str2 = "Hello";
  swap(str1, str2);
  cout<<"str1 is "<<str1<<endl;
  cout<<"str2 is "<<str2<<endl;
  return 0;
}

Et de considérer la version C du programme ci-dessus. En C, vous devez utiliser pointeur de pointeur (plusieurs indirection), et il conduit à la confusion et le programme peut sembler compliqué.

#include<stdio.h>
/* Swaps strings by swapping pointers */
void swap1(char **str1_ptr, char **str2_ptr)
{
  char *temp = *str1_ptr;
  *str1_ptr = *str2_ptr;
  *str2_ptr = temp;
}

int main()
{
  char *str1 = "Hi";
  char *str2 = "Hello";
  swap1(&str1, &str2);
  printf("str1 is %s, str2 is %s", str1, str2);
  return 0;
}

Visitez la page suivante pour plus d'informations sur la référence de pointeur:

• C++: Référence à un Pointeur
• Pointeur de Pointeur et Référence de Pointeur

Comme je l'ai dit, un pointeur vers une référence n'est pas possible. Essayez le programme suivant:

#include <iostream>
using namespace std;

int main()
{
   int x = 10;
   int *ptr = &x;
   int &*ptr1 = ptr;
}

Au risque d'ajouter à la confusion, je tiens à jeter un peu de l'entrée, je suis sûr que ça dépend de la façon dont le compilateur met en œuvre les références, mais dans le cas de la gcc à l'idée qu'une référence ne peut pointer que vers une variable sur la pile n'est pas correcte, prenez cet exemple:

#include <iostream>
int main(int argc, char** argv) {
    //Create a string on the heap
    std::string *str_ptr = new std::string("THIS IS A STRING");
    //Dereference the string on the heap, and assign it to the reference
    std::string &str_ref = *str_ptr;
    //Not even a compiler warning! At least with gcc
    //Now lets try to print it's value!
    std::cout << str_ref << std::endl;
    //It works! Now lets print and compare actual memory addresses
    std::cout << str_ptr << " : " << &str_ref << std::endl;
    //Exactly the same, now remember to free the memory on the heap
    delete str_ptr;
}

Qui sort ce:

THIS IS A STRING
0xbb2070 : 0xbb2070

Si vous remarquez même les adresses mémoire sont exactement les mêmes, ce qui signifie la référence est correctement pointant vers une variable sur le tas! Maintenant, si vous voulez vraiment obtenir bizarre, cela fonctionne aussi:

int main(int argc, char** argv) {
    //In the actual new declaration let immediately de-reference and assign it to the reference
    std::string &str_ref = *(new std::string("THIS IS A STRING"));
    //Once again, it works! (at least in gcc)
    std::cout << str_ref;
    //Once again it prints fine, however we have no pointer to the heap allocation, right? So how do we free the space we just ignorantly created?
    delete &str_ref;
    /*And, it works, because we are taking the memory address that the reference is
    storing, and deleting it, which is all a pointer is doing, just we have to specify
    the address with '&' whereas a pointer does that implicitly, this is sort of like
    calling delete &(*str_ptr); (which also compiles and runs fine).*/
}

Qui sort ce:

THIS IS A STRING

Par conséquent, une référence EST un pointeur sous le capot, ils sont tous deux à seulement stocker une adresse de mémoire, où l'adresse est orientée à l'est hors de propos, que pensez-vous qui se passerait si j'ai appelé std::cout << str_ref; APRÈS l'appel de supprimer &str_ref? Bon, évidemment, ça compile bien, mais provoque une erreur de segmentation lors de l'exécution, car il n'est plus pointant vers une variable valide, nous avons essentiellement d'une rupture de la référence qui existe toujours (jusqu'à ce qu'il tombe hors de la portée), mais il est inutile.

En d'autres termes, une référence est rien, mais un pointeur le pointeur de la mécanique disparaît, le rendant plus sûr et plus facile à utiliser (pas accidentelle pointeur de maths, pas de mélange jusqu' '.' et '->', etc.), en supposant que vous n'essayez pas de bêtises comme mes exemples ci-dessus 😉

Maintenant indépendamment de la façon dont un compilateur traite les références, il toujours avoir une sorte de pointeur sous le capot, car une référence doit se référer à une variable spécifique à une adresse de mémoire pour qu'il fonctionne comme prévu, il n'y a pas moyen de contourner cela (d'où le terme de "référence").

La seule grande règle importante à retenir avec des références, c'est qu'ils doivent être définis au moment de la déclaration (à l'exception d'une référence dans un en-tête, dans ce cas, il doit être définie dans le constructeur, après que l'objet c'est contenue dans le construit, il est trop tard pour le définir).

Rappelez-vous, mes exemples ci-dessus ne sont que des exemples démontrant ce qu'est une référence est, vous ne voulez pas utiliser une référence dans ces manières! Pour une utilisation correcte d'une référence il y a beaucoup de réponses ici déjà qui a frappé le clou sur la tête

La réponse directe

Ce qui est une référence en C++? Certains instance spécifique de type n'est pas un objet de type.

Ce qu'est un pointeur en C++? Certains instance spécifique de type est un type d'objet.

De l'ISO C++ définition de type d'objet:

Un objet type est une (peut-être cv-qualifié) de type qui n'est pas un type de fonction, pas un type de référence, et pas cv vide.

Il peut être important de savoir, le type d'objet est un haut-niveau de la catégorie de l'univers de type en C++. Référence est également un haut niveau de la catégorie. Mais le pointeur ne l'est pas.

Les pointeurs et les références sont mentionnés ensemble dans le contexte de composé de type. Cela est essentiellement dû à la nature de la déclaration de syntaxe héritée de (et) C, qui n'a pas de références. (D'ailleurs, il y a plus d'un type de demande de déclaration de références depuis C++ 11, tandis que les pointeurs sont encore "unityped": &+&& vs *.) Si la rédaction d'un langage spécifique par "extension", avec le même style de C dans ce contexte, c'est assez raisonnable. (Je vais encore affirmer que la syntaxe de declarators déchets syntaxiques expressivité beaucoup, rend à la fois les utilisateurs et les implémentations de la frustration. Ainsi, tous d'entre eux ne sont pas qualifiés pour être intégré dans un nouveau langage de conception. C'est un tout autre sujet sur les PL conception, cependant).

Sinon, il est significatif que les pointeurs peut être qualifié comme l'une des sortes de types avec les références de l'ensemble. Ils partagent tout simplement trop peu de propriétés communes en plus de la syntaxe de la similitude, il n'ya donc pas besoin de les mettre ensemble dans la plupart des cas.

Note les déclarations ci-dessus ne mentionne que les "pointeurs" et "références" comme des types. Il y a quelques intéressés à des questions sur leur cas (comme les variables). Il y a aussi venir aussi beaucoup d'idées fausses.

Les différences de haut-niveau des catégories peut déjà révéler de nombreux de béton les différences ne sont pas liées à des pointeurs directement:

• Types d'objets peuvent avoir des cv qualificatifs. Les références ne peuvent pas.
• Variable de types d'objets occupent de stockage comme par la machine abstraite sémantique. De référence ne sont pas nécessaires occuper de stockage (voir la section sur les idées fausses ci-dessous pour plus de détails).
• ...

Un peu plus de règles spéciales sur les références:

• Composé declarators sont plus restrictives sur les références.
• Les références peuvent l'effondrement.
  • Règles spéciales sur && paramètres (comme le "transfert des références") sur la base de référence de l'effondrement des cours de paramètre de modèle déduction permettre "le transfert parfait" de paramètres.
• Références ont des règles spéciales lors de l'initialisation. La durée de vie de la variable déclarée comme un type de référence peut être différente pour les objets ordinaires par extension.
  • BTW, quelques autres contextes comme l'initialisation impliquant std::initializer_list suit certaines règles similaires de référence durée de vie de l'extension. C'est une autre boîte de pandore.
• ...

Les idées fausses

Sucre syntaxique

Je sais références sont sucre syntaxique, donc le code est plus facile à lire et à écrire.

Techniquement, c'est simplement faux. Les références ne sont pas sucre syntaxique de toutes les autres fonctions en C++, parce qu'ils ne peuvent pas être exactement remplacé par d'autres fonctions, sans différences sémantiques.

(De la même manière, lambda-expressions sont pas sucre syntaxique de toutes les autres fonctionnalités en C++ car il ne peut pas être précisément simulée avec le "non spécifié" propriétés comme l'ordre de déclaration de la capture de variables, qui peut être important, car l'ordre d'initialisation de ces variables peuvent être importantes.)

C++ a seulement quelques types de sucres syntaxiques dans ce sens strict. Un exemple est (hérité de C) intégré (non surchargé) opérateur [], qui est défini exactement les mêmes propriétés sémantiques des formes spécifiques de la combinaison de plus de opérateur unaire * et binaire +.

De stockage

Donc, un pointeur et une référence à la fois utiliser la même quantité de mémoire.

La déclaration ci-dessus est tout simplement faux. Pour éviter de tels malentendus, regardez la norme ISO C++ règles:

De [intro.objet]/1:

... Un objet occupe une région de stockage dans sa période de construction, tout au long de sa durée de vie, et dans sa période de destruction. ...

De [dcl.ref]/4:

Il n'est pas précisé si oui ou non une référence nécessite de stockage.

Noter que ce sont sémantique propriétés.

Pragmatique

Même que les pointeurs ne sont pas suffisamment qualifiés pour être mis ensemble avec des références dans le sens de la langue de la conception, il ya encore quelques arguments rendant discutable de faire de choix entre eux dans d'autres contextes, par exemple, lorsqu'ils font des choix sur les types de paramètre.

Mais ce n'est pas toute l'histoire. Je veux dire, il ya plus de choses que des pointeurs vs les références que vous avez à considérer.

Si vous n'avez pas à tenir sur ces over-choix précis, dans la plupart des cas, la réponse est courte: vous n'avez pas la nécessité d'utiliser des pointeurs, donc vous n'avez pas. Les pointeurs sont généralement assez mauvais, car elles impliquent beaucoup trop de choses que vous n'avez pas à attendre et ils vont s'appuyer sur trop d'hypothèses implicites de saper la maintenabilité et de la (même) la portabilité du code. Inutilement en s'appuyant sur les pointeurs est certainement un mauvais style, et il devrait être évité dans le sens de C++ moderne. Reconsidérer votre but et vous trouverez enfin que pointeur est à la une de la dernière sortes dans la plupart des cas.

• Parfois les règles de la langue explicitement prescrivent des types spécifiques d'être utilisé. Si vous souhaitez utiliser ces fonctions, de respecter les règles.
  • Copie constructeurs prescrivent des types spécifiques de cv-& type de référence que le 1er type de paramètre. (Et habituellement, il devrait être const qualifié.)
  • Constructeurs de déplacement prescrivent des types spécifiques de cv-&& type de référence que le 1er type de paramètre. (Et normalement il devrait y avoir pas de qualificatifs.)
  • Spécifiques des surcharges des opérateurs exiger ou non des types référence. Par exemple:
    • Surchargé operator= spéciale les fonctions de membre exige que les types de référence similaire pour le 1er paramètre de copier/déplacer des constructeurs.
    • Postfix ++ nécessite mannequin int.
    • ...
• Si vous savez passer par valeur (c'est à dire à l'aide de non-types de référence) est suffisante, l'utiliser directement, en particulier lors de l'utilisation d'une mise en œuvre à l'appui C++17 mandaté copie élision. (Avertissement: Cependant, à de manière exhaustive raison sur la nécessité peut être très compliqué.)
• Si vous souhaitez utiliser certaines poignées de propriété, l'utilisation des pointeurs intelligents comme unique_ptr et shared_ptr (ou même avec homebrew par vous-même si vous en avez besoin pour être opaque), plutôt que brut de pointeurs.
• Si vous faites des itérations sur une plage, utiliser des itérateurs (ou certaines plages qui ne sont pas fournis par la bibliothèque standard encore), plutôt que brut pointeurs, sauf si vous êtes convaincu raw pointeurs faire mieux (par exemple, pour moins d'en-tête de dépendances) dans des cas très spécifiques.
• Si vous savez passer-par-valeur est suffisant et que vous souhaitez explicites, nullable sémantique, l'utilisation wrapper comme std::optional, plutôt que brut de pointeurs.
• Si vous savez passer-par-valeur n'est pas idéale pour les raisons ci-dessus, et vous ne voulez pas accepter les valeurs null sémantique, utiliser {lvalue, rvalue, transfert}-références.
• Même lorsque vous ne voulez sémantique classique, pointeur, il y a souvent quelque chose de plus approprié, comme observer_ptr dans la Bibliothèque Fondamentale TS.

Les seules exceptions à cette règle ne peut pas être contourné dans le langage courant:

• Lorsque vous êtes à la mise en œuvre des pointeurs intelligents ci-dessus, vous pourriez avoir à traiter avec des pointeurs.
• Spécifiques à la langue de l'interopérabilité des routines d'exiger des pointeurs, comme operator new. (Cependant, cv-void* est encore tout à fait différente et plus sûr par rapport à l'ordinaire de pointeurs d'objet, car elle exclut inattendu pointeur de l'arithmétique, sauf si vous êtes en s'appuyant sur certains non-conforme extension sur void* comme GNU.)
• Pointeurs de fonction peuvent être convertis à partir des expressions lambda sans capture, tandis que les références de fonction ne peut pas. Vous devez utiliser des pointeurs de fonction dans le code non générique pour de tels cas, même si vous délibérément ne souhaitez pas accepter les valeurs null valeurs.

Donc, dans la pratique, la réponse est tellement évidente: en cas de doute, évitez les pointeurs. Vous devez utiliser des pointeurs seulement lorsqu'il y a très explicite raisons que rien d'autre n'est plus appropriée. Sauf quelques cas exceptionnels mentionnés ci-dessus, de tels choix sont presque toujours pas purement C++spécifiques (mais susceptible d'être la langue spécifique à l'implémentation). Ces instances peuvent être:

• Vous avez à servir à l'ancienne (C) Api.
• Vous avez à répondre à l'ABI exigences spécifiques C++ implémentations.
• Vous devez interagir au moment de l'exécution avec les différentes implémentations de langue (y compris les divers assemblages, language runtime et les FFI de haut-niveau de langue du client) basées sur des hypothèses, des implémentations spécifiques.
• Vous avez à améliorer l'efficacité de la traduction (compilation & liaison) dans certains cas extrêmes.
• Vous devez éviter symbole de ballonnement dans certains cas extrêmes.

Langue neutralité mises en garde

Si vous venez de voir la question via certains résultat de recherche de Google (pas spécifique au C++), c'est très probablement au mauvais endroit.

Les références en C++ est assez "bizarre", car il n'est pas essentiellement de première classe: ils seront traités comme des objets ou des fonctions visées à donc ils n'ont aucune chance à l'appui de certaines premières opérations de classe comme étant l'opérande de gauche de l'accès des membres de l'opérateur indépendamment du type de l'objet. D'autres langues peuvent ou peuvent ne pas avoir les mêmes restrictions sur leurs références.

Les références en C++ ne sera probablement pas préserver le sens à travers les différentes langues. Par exemple, les références en général n'implique pas non null propriétés sur des valeurs comme ils l'ont dans le C++, donc, ces hypothèses peuvent ne pas fonctionner dans certaines autres langues (et vous allez trouver des contre-exemples assez facilement, par exemple, Java, C#, ...).

Il peut encore y avoir quelques propriétés communes entre les références dans différents langages de programmation en général, mais laissons cela pour certains d'autres questions dans la.

(Une note de côté: la question peut être important, plus tôt que les "C", semblables à des langues sont en cause, comme ALGOL 68 vs PL/I.)

Aussi, une référence qui est un paramètre à une fonction inline peuvent être traités différemment d'un pointeur.

void increment(int *ptrint) { (*ptrint)++; }
void increment(int &refint) { refint++; }
void incptrtest()
{
    int testptr=0;
    increment(&testptr);
}
void increftest()
{
    int testref=0;
    increment(testref);
}

De nombreux compilateurs lors de l'inlining le pointeur de la première version sera en fait la force d'une écriture de la mémoire (nous sommes à l'adresse explicitement). Cependant, ils quittent la référence dans un registre qui est plus optimal.

Bien sûr, pour les fonctions qui ne sont pas inline le pointeur et référence de générer le même code et c'est toujours mieux de passer intrinsèques par la valeur que par référence si elles ne sont pas modifiés et retourné par la fonction.

Je me sens comme il est encore un autre point qui n'a pas été abordé ici.

Contrairement aux pointeurs, références sont syntaxiquement équivalent à l'objet auquel ils se réfèrent, c'est à dire une opération qui peut être appliquée à un objet de travaux de référence, et avec exactement la même syntaxe (l'exception est bien sûr l'initialisation).

Alors que cela peut sembler superficiel, je crois que cette propriété est cruciale pour un certain nombre de fonctionnalités C++, par exemple:

• Modèles. Depuis les paramètres du modèle sont de canard tapé, propriétés syntaxiques d'un type est tout ce qui compte, ce sont souvent les même modèle peut être utilisé à la fois avec T et T&.
  
  (ou std::reference_wrapper<T> qui repose toujours sur un cast implicite
  pour T&)
  
  Des modèles qui couvrent à la fois T& et T&& sont encore plus fréquents.

• Lvalues. Considérons la déclaration str[0] = 'X'; Sans références, il ne fonctionne que pour le c-cordes (char* str). Le retour du personnage par référence permet à des classes définies par l'utilisateur pour avoir la même notation.

• Copie constructeurs. Du point de vue syntaxique il est logique de passer des objets à copier les constructeurs, et pas des pointeurs vers des objets. Mais il n'y a tout simplement aucun moyen pour un constructeur de copie pour prendre un objet par valeur d'un appel récursif de la même constructeur de copie. Cela laisse des références comme la seule option ici.

• La surcharge de l'opérateur. Avec des références, il est possible d'introduire une indirection à un opérateur call - dire, operator+(const T& a, const T& b) tout en conservant la même notation infixe. Cela fonctionne aussi pour les régulièrement les fonctions surchargées.

Ces points de conférer à une partie considérable de C++ et la bibliothèque standard, c'est donc tout à fait un grand bien de références.

Il est très important de non-différence technique entre les pointeurs et les références: Un argument passé à une fonction par pointeur est beaucoup plus visible qu'un argument transmis à une fonction par des non-const de référence. Par exemple:

void fn1(std::string s);
void fn2(const std::string& s);
void fn3(std::string& s);
void fn4(std::string* s);

void bar() {
    std::string x;
    fn1(x);  //Cannot modify x
    fn2(x);  //Cannot modify x (without const_cast)
    fn3(x);  //CAN modify x!
    fn4(&x); //Can modify x (but is obvious about it)
}

De retour dans C, un appel qui ressemble à fn(x) ne peut être passé par valeur, de sorte qu'il ne peut absolument pas modifier x; pour modifier un argument que vous auriez besoin pour passer un pointeur fn(&x). Donc, si un argument n'est pas précédée par une & tu savais qu'il ne serait pas modifiée. (Les converse, & signifie modifié, n'était pas vrai parce que vous aurais parfois à passer de grands en lecture seule structures par const pointeur.)

Certains prétendent que c'est une telle fonctionnalité utile lors de la lecture du code, que les paramètres de pointeur doit toujours être utilisé pour les paramètres modifiables plutôt que les non-const des références, même si la fonction ne demande jamais à un nullptr. Qui est, ceux qui disent que les signatures de la fonction comme fn3() ci-dessus ne devraient pas être autorisés. Google C++ lignes directrices de style en sont un exemple.

La différence est que les non-constante pointeur de variable(à ne pas confondre avec un pointeur constant) peut être changé à un certain moment pendant l'exécution du programme, nécessite pointeur de la sémantique à être utilisé(&,*) les opérateurs, alors que les références peuvent être définies lors de l'initialisation seulement(c'est pourquoi vous pouvez les mettre dans le constructeur de l'initialiseur liste seulement, mais d'une certaine manière pas d'autre) et l'utilisation ordinaire de la valeur accéder à la sémantique. Fondamentalement, les références ont été introduites pour permettre le soutien à la surcharge d'opérateurs comme je l'avais lu dans un très vieux livre. Comme quelqu'un l'a dit dans ce fil - pointeur peut prendre la valeur 0 ou la valeur que vous souhaitez. 0(NULL, nullptr) signifie que le pointeur est initialisé avec rien. C'est une erreur de déréférencement de pointeur null. Mais en fait, le pointeur peut contenir une valeur qui ne pointent pas vers une bonne mémoire. Les références à leur tour essayer de ne pas permettre à un utilisateur d'initialiser une référence à quelque chose qui ne peut pas être référencée en raison du fait que vous avez toujours fournir rvalue de type approprié pour elle. Bien qu'il existe beaucoup de manières de faire référence variable sera initialisée à un mauvais emplacement de la mémoire -, il est préférable pour vous de ne pas creuser ce profond dans les détails. Sur la machine à la fois pointeur et référence de travail uniformément via des pointeurs. Disons que, pour l'essentiel, les références sont à sucre syntaxique. références rvalue sont différents de ce qu'ils sont naturellement pile/tas d'objets.

J'ai une analogie pour les références et les pointeurs, penser à des références comme un autre nom pour un objet et des pointeurs comme l'adresse d'un objet.

//receives an alias of an int, an address of an int and an int value
public void my_function(int& a,int* b,int c){
    int d = 1; //declares an integer named d
    int &e = d; //declares that e is an alias of d
    //using either d or e will yield the same result as d and e name the same object
    int *f = e; //invalid, you are trying to place an object in an address
    //imagine writting your name in an address field 
    int *g = f; //writes an address to an address
    g = &d; //&d means get me the address of the object named d you could also
    //use &e as it is an alias of d and write it on g, which is an address so it's ok
}

Taryn♦ dit:

Vous ne pouvez pas prendre l'adresse d'une référence comme vous le pouvez avec des pointeurs.

En fait, vous pouvez.

Je suis citant une réponse à une autre question:

Le C++ FAQ l'exprime le mieux:

Contrairement à un pointeur, une fois qu'une référence est liée à un objet, il ne peut pas être "réinstaller" à un autre objet. La référence elle-même n'est pas un objet (il n'a pas d'identité; en prenant l'adresse de référence vous donne l'adresse du référent; rappelez-vous: la référence est son référent).