准大二学内存，引用，生命周期，作用域，拷贝，左值右值

引用

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