Rujukan dalam C++ sebenarnya hanyalah penunjuk terhad, tetapi terdapat sekatan semantik pada penunjuk terhad yang tidak boleh digunakan untuk melaksanakan beberapa operasi yang boleh dilakukan oleh penunjuk: penugasan semula, salin, ++, -- (saya tidak terfikir untuk itu lagi. Lain-lain), dan menyekat bahawa null tidak dibenarkan untuk meningkatkan keselamatan, yang boleh difahami sebagai mod perlindungan pengkompil untuk petunjuk.

Jadi, pertimbangkan bila anda harus menggunakan rujukan dan bilakah anda harus menggunakan penunjuk? Saya rasa ada beberapa perkara:

1. Petikan dahulu

   Gunakan rujukan di mana-mana sahaja rujukan boleh digunakan dan bukannya penunjuk.

2. Penunjuk dibenarkan menjadi batal, tetapi rujukan tidak.

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

   Sudah tentu, dalam kes ini anda masih boleh menggunakan rujukan, dan dalam kes objek kosong, anda boleh menyatakannya dengan membuang pengecualian:

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

3. Semantik penggunaan saksama membayangkan, penunjuk membayangkan pemilikan (mempunyai), rujukan membayangkan perkaitan (penggunaan):

   car mempunyai wheel

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

   trip gunakan car:

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

   Sudah tentu, terdapat pengecualian Jika _kereta yang berkaitan dikehendaki berubah-ubah sepanjang hayat perjalanan, maka anda hanya boleh menggunakan penunjuk (kerana rujukan tidak boleh ditetapkan semula):

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

   Jika tidak, jika anda berkeras untuk menggunakan rujukan dan ingin menukar penunjuk _car, anda hanya boleh membina semula perjalanan baharu.

4. Rujukan tidak boleh disimpan dalam bekas, hanya penunjuk boleh digunakan (saya rasa ia adalah terutamanya kerana rujukan dihadkan dalam tugasan semula dan operasi salinan):

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

5. Akhir sekali, anda boleh menukar rujukan kepada penunjuk pada bila-bila masa:

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

   Tetapi anda mesti memberi perhatian kepada keadaan di sini kereta hanya diluluskan untuk digunakan dengan kaedah penyelenggaraan (rujukan menunjukkan hubungan penggunaan Walaupun operasi penunjuk tidak elegan, ia masih boleh diterima, tetapi anda mesti memberi perhatian). untuk menyimpan penunjuk untuk digunakan:

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

   Selepas keluar daripada kaedah penyelenggaraan, objek yang ditunjuk oleh _last_car berkemungkinan besar akan dilepaskan.

Const adalah jurang maut apabila bercakap mengenainya
Beri saya contoh

#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;
}

Pulangan NULL dibenarkan untuk penunjuk, tetapi bukan untuk rujukan.