Les références en C++ ne sont en fait que des pointeurs restreints, mais il existe des restrictions sémantiques sur le pointeur restreint qui ne peuvent pas être utilisées pour effectuer certaines opérations que les pointeurs peuvent effectuer : réaffectation, copie, ++, -- (je n'y ai pas pensé encore. Autres), et restreindre que null n'est pas autorisé à améliorer la sécurité, ce qui peut être compris comme un mode de protection du compilateur pour les pointeurs.

Alors, réfléchissez à quand devez-vous utiliser des références et quand devez-vous utiliser des pointeurs ? Je pense qu'il y a quelques points :

1. Citation en premier

   Utilisez des références partout où des références peuvent être utilisées à la place des pointeurs.

2. Les pointeurs peuvent être nuls, mais pas les références.

   const stock* top(...)
   {
       return NULL;
   }

   Bien sûr, dans ce cas, vous pouvez toujours vous en tenir à l'utilisation de références, et dans le cas d'objets vides, vous pouvez l'exprimer en lançant une exception :

   const stock& top(...)
   {
       throw null_top_stock_exception();
   }

3. La sémantique de l'usage équitable implique, les pointeurs impliquent la possession (has), les références impliquent l'association (utilisation) :

   car a un wheel

   class wheel {};
   class car
   {
       wheel* _wheel;
   public:
       car() : _wheel(NULL) {};
       void set_wheel(wheel* wheel) { _wheel = wheel; };
   };

   trip utiliser un car :

   class trip
   {
       const car& _car
   public:
       trip(const car& car) : _car(car) {};
   };

   Bien sûr, il y a des exceptions. Si la _car associée doit être variable pendant la durée du voyage, alors vous ne pouvez utiliser que des pointeurs (car les références ne peuvent pas être réaffectées) :

   class trip
   {
       const car* _car
   public:
       trip(const car* car) : _car(car) {};
       void set_car(const car* car) : _car(car) { _car = car; };
   };

   Sinon, si vous insistez pour utiliser des références et souhaitez changer le pointeur de _car, vous ne pourrez reconstruire qu'un nouveau trajet.

4. Les références ne peuvent pas être enregistrées dans des conteneurs, seuls les pointeurs peuvent être utilisés (je suppose que c'est principalement parce que les références sont limitées dans les opérations de réaffectation et de copie) :

   std::vector<car> cars;  // OK 
   std::vector<car*> cars; // OK
   std::vector<car&> cars; // ERROR

5. Enfin, vous pouvez à tout moment convertir la référence en pointeur :

   class maintainer
   {
   public:
       void maintain(car& car)
       {
           car* p = &car;
           // play with pointer 'p'
       }
   };

   Mais vous devez faire attention à la situation. Ici, la voiture n'est transmise que pour être utilisée par la méthode de maintenance (la référence implique la relation d'utilisation). Bien que l'opération du pointeur ne soit pas élégante, elle est toujours acceptable, mais vous devez payer. attention à sauvegarder le pointeur pour l'utiliser :

   class maintainer
   {
       car* _last_car;
   public:
       void maintain(car& car)
       {
           car* _last_car = &car;
           // ...
       }
       void review_last_maintain()
       {
           // play with "_last_car"
       }
   };

   Après avoir quitté la méthode maintenir, l'objet pointé par _last_car est susceptible d'être libéré.

Const est un gouffre sans fond quand on en parle
Donnez-moi un exemple

#include <iostream>
#include<string>
using namespace std;

class Stu
{
public:
    Stu(string name, int age) // :name(name),age(age)
    {
        this->name = name;
        this->age = age;
    }
    Stu & Add()
        //Stu * const & Add()
    {
        this->age++;
        return *this; 
        // return this;//this 指针是const类型
    }
    void display()
    {
        cout << name << " : " << age << endl;
    }
private:
    string name;
    int age;
};
int main()
{
    Stu s("xiaoming", 20);
    s.display();
    s.Add().Add().Add().Add().Add()；
    //Add函数返回引用的好处是，你可以进行连加或者比如运算符重载返回引用类型进行连等于运算 
    //s.Add()->Add()->Add()->Add();
    s.display();
    return 0;
}

Le retour NULL est autorisé pour les pointeurs, mais pas pour les références.