引用

1. 拷貝構造函數的參數
   必須是當前類的引用
   （通常是 const 引用）
   否則會導致無限遞歸調用

   • 如果拷貝構造函數的參數
     是 “值傳遞”（而非引用）

   • 那么在調用拷貝構造函數時，
     需要先將實參（一個對象）復制給形參（函數參數）
     而復制對象又會觸發拷貝構造函數的調用

   • 形成無限循環：
     調用拷貝構造函數
     →需要復制參數
     →再調用拷貝構造函數
     →……

2. 非const引用 綁定到右值（編譯錯誤）

   void func(int& x) {} 
   
   int main() {
       func(10); 
       return 0;
   }
   

   // 方案1：const引用 可綁定右值
   void func(const int& x) {} 
   func(10);
   
   // 方案2：左值可綁定到 非const引用
   int a = 10;
   func(a);
   

3. 引用綁定到 “即將銷毀的臨時對象”（運行時未定義行為）

   const int& getRef() {
       int x = 10; 
       return x;
   }
   
   int main() {
       const int& ref = getRef(); 
       cout << ref << endl;
       return 0;
   }
   

   // 解決方案：返回值（復制x的值）
   int getValue() {
       int x = 10;
       return x; 
   }
   

4. 引用捕獲局部變量后，lambda 生命周期超過變量生命周期（懸垂引用）

   function<int()> get_func() {
       int x = 10;
       return [&x]() {
           return x;
       };
   }
   
   int main() {
       auto func = get_func();
       func();  // 未定義行為（訪問已銷毀的內存）
   }
   // 解決方案：使用值捕獲[x]
   

5. 函數返回引用

   1. 賦值運算符重載，用于連續賦值

   2. 容器的元素訪問函數

   3. 返回類的成員變量的引用

   4. 返回全局 / 靜態變量的引用

   5. 部分迭代器的解引用操作（如 operator*）返回引用

6. 在構造函數體內初始化引用（錯誤）

   class MyClass {
       int& ref; // 引用成員
   public:
       MyClass(int x) {
           ref = x; 
       }
   };
   

   // 解決方案：初始化列表中綁定引用
   class MyClass {
       int& ref;
   public:
       MyClass(int& x) : ref(x) {}
   };
   

拷貝

1. 禁用拷貝

   class NonCopyable {
       NonCopyable(const NonCopyable&) = delete;
       NonCopyable& operator=(const NonCopyable&) = delete;
   };
   

堆（內存）

1. 分配1個int，值初始化為10

   int* p1 = new int(10);
   delete p1;
   

2. 分配包含5個int的數組

   int* p2 = new int[5];
   delete[] p2;
   

   // 數組元素全部初始化為0（零初始化）
   int* p3 = new int[5]();
   int* p4 = new int[5]{1,2,3};
    // 前3個元素初始化為1,2,3，剩余元素為0