为什么拷贝构造函数的参数必须是引用传递？

class Cat {
public:
    Cat(string name) : name_(name) {
        cout << "哇！一只叫" << name_ << "的小可爱诞生啦! 🎉" << endl;
    }
    string name_;
};
1.
2.
3.
4.
5.
6.
7.

// ❌ 这样写会导致无限递归
Cat(Cat other) {  // 值传递方式
    name_ = other.name_;
}
1.
2.
3.
4.

Cat original("咪咪");
Cat copy(original);  // 想要复制original
1.
2.

// 为了将original传递给参数other,需要先调用拷贝构造函数
Cat other = original;  // 这又会触发拷贝构造!
1.
2.

// 为了完成上一步的拷贝,又需要调用拷贝构造函数
Cat other = original;  // 继续触发拷贝构造...
1.
2.

拷贝构造(c1) 
  → 需要拷贝构造(c1) 
    → 需要拷贝构造(c1)
      → 需要拷贝构造(c1)
        → ... 直到栈溢出! 💥
1.
2.
3.
4.
5.

// 假设我们这样调用:
Cat c1("咪咪");
Cat c2(c1);  // 这里开始无限递归

// 内存中实际发生的事:
1. 为c2分配栈空间
2. 调用拷贝构造函数Cat(Cat other)
3. 为参数other分配栈空间
4. 需要将c1拷贝到other
5. 再次调用拷贝构造函数
6. 再次为新的other分配栈空间
7. 继续重复步骤4-6...
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

// ✅ 正确的方式
Cat(const Cat& other) : name_(other.name_) {
    cout << "成功复制了小猫咪!" << endl;
}
1.
2.
3.
4.

// ❌ 指针也不是一个好主意哦~
Cat(const Cat* other) { 
    name_ = other->name_;
}
1.
2.
3.
4.

Cat c1("咪咪");
Cat c2(&c1);     // 好麻烦，要手动取地址 😫
Cat* pc = &c1;
Cat c3(pc);      // 直接传指针也行，但看起来怪怪的 🤪
1.
2.
3.
4.

Cat c4(nullptr); // 糟糕！空指针会导致程序崩溃 💥
Cat* pc = nullptr;
Cat c5(pc);      // 同样危险！程序可能直接说拜拜 👋
1.
2.
3.

Cat* original = new Cat("花花");
Cat copy(original);  // 这看起来更像是在创建一个"猫咪的影子" 👻
// 而不是一只真实的新猫咪！
1.
2.
3.

vector<Cat> cats;
cats.push_back(Cat("花花")); // 无法正常工作！🚫
// 因为vector内部需要使用拷贝构造函数来管理元素

// 更糟糕的是，很多标准库功能都无法使用 😱
sort(cats.begin(), cats.end());  // 排序也会出问题
auto cat_copy = cats;            // 容器复制也会失败
1.
2.
3.
4.
5.
6.
7.

Cat* original = new Cat("咪咪");
{
    Cat copy(original);    // 谁负责删除original？🤔
    // copy离开作用域时会发生什么？
} // 可能会造成内存泄漏或重复释放！💦
1.
2.
3.
4.
5.

Cat c1("咪咪");
Cat c2(c1);         // 使用引用：清晰明了 ✨
Cat c3(&c1);        // 使用指针：看着就让人困惑 😵💫
1.
2.
3.

class Cat {
public:
    Cat(const Cat& other) : name_(other.name_) {
        cout << "复制了一只叫" << name_ << "的小猫咪！" << endl;
    }
    // ... 其他成员 ...
};
1.
2.
3.
4.
5.
6.
7.