Quelles sont les différences entre une variable de type pointeur et une variable de type référence ?

Question

Quelle est la différence entre une variable de type pointeur et une variable de type référence ?

Answer 1

1. Un pointeur peut être réaffecté :

   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 pas être reliée à nouveau et doit être reliée lors de l'initialisation :

   int x = 5;
   int y = 6;
   int &q; // error
   int &r = x;

2. Une variable de type pointeur possède sa propre identité : une adresse mémoire distincte et visible qui peut être prise avec la fonction unaire & et une certaine quantité d'espace qui peut être mesurée à l'aide de l'instrument de mesure. sizeof de l'opérateur. L'utilisation de ces opérateurs sur une référence renvoie une valeur correspondant à la variable à laquelle la référence est liée ; l'adresse et la taille de la référence sont invisibles. Étant donné que la référence assume l'identité de la variable originale de cette manière, il est pratique de considérer une référence comme un autre nom pour la même variable.

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

3. Il est possible d'imbriquer arbitrairement les pointeurs dans les pointeurs, ce qui offre des niveaux d'indirection supplémentaires. Les références n'offrent qu'un seul niveau d'indirection.

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

4. Un pointeur peut être attribué nullptr alors qu'une référence doit être liée à un objet existant. Si vous vous efforcez de le faire, vous pouvez lier une référence à nullptr mais il s'agit d'une indéfini et ne se comporteront pas de manière cohérente.

   /* the code below is undefined; your compiler may optimise it
    * differently, emit warnings, or outright refuse to compile it */
   
   int &r = *static_cast<int *>(nullptr);
   
   // prints "null" under GCC 10
   std::cout
       << (&r != nullptr
           ? "not null" : "null")
       << std::endl;
   
   bool f(int &r) { return &r != nullptr; }
   
   // prints "not null" under GCC 10
   std::cout
       << (f(*static_cast<int *>(nullptr))
           ? "not null" : "null")
       << std::endl;

   Vous pouvez cependant avoir une référence à un pointeur dont la valeur est nullptr .

5. Les pointeurs peuvent itérer sur un tableau ; vous pouvez utiliser ++ pour passer à l'élément suivant sur lequel pointe un pointeur, et + 4 pour passer au 5ème élément. Et ce, quelle que soit la taille de l'objet sur lequel pointe le pointeur.

6. Un pointeur doit être déréférencé à l'aide de la fonction * pour accéder à l'emplacement mémoire qu'il pointe, alors qu'une référence peut être utilisée directement. Un pointeur sur une classe/struct utilise -> pour accéder à ses membres, alors qu'une référence utilise un . .

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

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

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

   Ce qui fait que const & plus pratique à utiliser dans les listes d'arguments, etc.

Answer 2

Qu'est-ce qu'une référence C++ ( pour les programmeurs C )

A référence peut être considéré comme un pointeur constant (à ne pas confondre avec un pointeur sur une valeur constante !) avec une indirection automatique, c'est-à-dire que le compilateur appliquera le code * pour vous.

Toutes les références doivent être initialisées avec une valeur non nulle, sinon la compilation échouera. Il n'est pas possible d'obtenir l'adresse d'une référence - l'opérateur d'adresse renvoie l'adresse de la valeur référencée - ni d'effectuer des opérations arithmétiques sur les références.

Les programmeurs C pourraient ne pas aimer les références C++, car il ne sera plus évident de savoir s'il y a indirection ou si un argument est transmis par une valeur ou par un pointeur sans regarder les signatures de fonction.

Les programmeurs C++ peuvent ne pas aimer utiliser les pointeurs car ils sont considérés comme peu sûrs - bien que les références ne soient pas vraiment plus sûres que les pointeurs constants, sauf dans les cas les plus triviaux -, ils n'ont pas la commodité de l'indirection automatique et ont une connotation sémantique différente.

Examinez la déclaration suivante tirée de la FAQ C++ :

Même si une référence est souvent mise en œuvre langage d'assemblage sous-jacent, veuillez ne pas pas penser à une référence un pointeur à l'aspect étrange vers un objet. Une référence est l'objet. Il ne s'agit pas d'un pas un pointeur sur l'objet, ni une copie de l'objet. Il n'est pas non plus une copie de l'objet. est t l'objet.

Mais si une référence vraiment était l'objet, comment pourrait-il y avoir des références pendantes ? Dans les langages non gérés, il est impossible que les références soient plus "sûres" que les pointeurs - il n'y a généralement aucun moyen d'aliaser des valeurs de manière fiable au-delà des limites du champ d'application !

Pourquoi je considère que les références C++ sont utiles

Venant d'un milieu C, les références C++ peuvent sembler un concept quelque peu stupide, mais on devrait quand même les utiliser à la place des pointeurs lorsque c'est possible : indirection automatique est pratique, et les références deviennent particulièrement utiles lorsqu'il s'agit de RAII - mais pas en raison d'un avantage perçu en termes de sécurité, mais plutôt parce qu'ils rendent l'écriture de code idiomatique moins gênante.

Le RAII est l'un des concepts centraux du C++, mais il interagit de manière non triviale avec la sémantique de la copie. Le passage d'objets par référence permet d'éviter ces problèmes puisqu'il n'y a pas de copie. Si les références n'étaient pas présentes dans le langage, vous devriez utiliser des pointeurs à la place, qui sont plus difficiles à utiliser, violant ainsi le principe de conception du langage selon lequel la meilleure solution doit être plus facile que les autres.

Answer 3

Si vous voulez être vraiment pédant, il y a une chose que vous pouvez faire avec une référence et que vous ne pouvez pas faire avec un pointeur : prolonger la durée de vie d'un objet temporaire. En C++, si vous liez une référence constante à un objet temporaire, la durée de vie de cet objet devient 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 copie l'objet temporaire résultant de la concaténation. Alors que s3_reference devient essentiellement l'objet temporaire. Il s'agit en fait d'une référence à un objet temporaire qui a maintenant la même durée de vie que la référence.

Si vous essayez de le faire sans le const la compilation devrait échouer. Vous ne pouvez pas lier une référence non-const à un objet temporaire, pas plus que vous ne pouvez prendre son adresse d'ailleurs.

Answer 4

Contrairement à ce que l'on pense, il est possible d'avoir une référence NULLE.

int * p = NULL;
int & r = *p;
r = 1;  // crash! (if you're lucky)

Certes, c'est beaucoup plus difficile à faire avec une référence, mais si vous y parvenez, vous vous arracherez les cheveux pour la trouver. Les références sont pas intrinsèquement sûr en C++ !

Techniquement, il s'agit d'une référence non valide et non une référence nulle. Le C++ ne prend pas en charge les références nulles en tant que concept, comme c'est le cas dans d'autres langages. Il existe également d'autres types de références non valides. Tous La référence non valide soulève le spectre d'une comportement non défini comme le ferait l'utilisation d'un pointeur non valide.

L'erreur réelle se situe au niveau du déréférencement du pointeur NULL, avant l'affectation à une référence. Mais je ne connais aucun compilateur qui génère des erreurs à cette condition - l'erreur se propage à un point plus éloigné dans le code. C'est ce qui rend ce problème si insidieux. La plupart du temps, si vous déréférencez un pointeur NULL, vous vous plantez directement à cet endroit et il ne faut pas beaucoup de débogage pour le découvrir.

Mon exemple ci-dessus est court et artificiel. Voici un exemple plus concret.

class MyClass
{
    ...
    virtual void DoSomething(int,int,int,int,int);
};

void Foo(const MyClass & bar)
{
    ...
    bar.DoSomething(i1,i2,i3,i4,i5);  // crash occurs here due to memory access violation - obvious why?
}

MyClass * GetInstance()
{
    if (somecondition)
        return NULL;
    ...
}

MyClass * p = GetInstance();
Foo(*p);

Je tiens à rappeler que le seul moyen d'obtenir une référence nulle est d'utiliser un code malformé, et qu'une fois que vous l'avez, vous obtenez un comportement indéfini. Il nunca il est logique de vérifier si la référence est nulle ; par exemple, vous pouvez essayer if(&bar==NULL)... mais le compilateur risque d'optimiser la déclaration pour qu'elle n'existe plus ! Une référence valide ne peut jamais être NULL, donc du point de vue du compilateur, la comparaison est toujours fausse, et il est libre d'éliminer l'élément if comme du code mort - c'est l'essence même d'un comportement non défini.

Pour éviter les problèmes, il faut éviter de déréférencer un pointeur NULL pour créer une référence. Voici une méthode automatisée pour y parvenir.

template<typename T>
T& deref(T* p)
{
    if (p == NULL)
        throw std::invalid_argument(std::string("NULL reference"));
    return *p;
}

MyClass * p = GetInstance();
Foo(deref(p));

Pour un examen plus ancien de ce problème par quelqu'un qui a de meilleures compétences en matière d'écriture, voir Références nulles de Jim Hyslop et Herb Sutter.

Pour un autre exemple des dangers du déréférencement d'un pointeur nul, voir Exposition d'un comportement indéfini lors du portage du code sur une autre plate-forme par Raymond Chen.

Answer 5

Vous avez oublié le plus important :

L'accès aux membres avec des pointeurs utilise ->
accès des membres avec références utilisations .

foo.bar est clairement supérieur à foo->bar de la même manière que vi est clairement supérieur à Emacs :-)