【C++类和数据抽象】复制构造函数

void processObject(MyClass obj);  // 值传递触发拷贝
MyClass createObject();          // 返回对象触发拷贝int main() {MyClass a;MyClass b = a;              // 初始化拷贝vector<MyClass> vec;vec.push_back(a);           // 容器存储拷贝
}

class ShallowArray {int* data;size_t size;
public:ShallowArray(size_t n) : size(n), data(new int[n]) {}~ShallowArray() { delete[] data; }
};int main() {ShallowArray arr1(5);ShallowArray arr2 = arr1;  // 双重释放崩溃！
}

class ClassName {
public:ClassName(const ClassName& obj); // 复制构造函数声明
};// 定义示例
ClassName::ClassName(const ClassName& obj) {// 实现对象复制逻辑
}

ClassName obj1;          // 调用默认构造函数
ClassName obj2(obj1);    // 调用复制构造函数（对象创建）
obj2 = obj1;             // 调用拷贝赋值运算符（对象已存在）

#include <iostream> // 包含输入输出流头文件
using namespace std; // 使用标准命名空间class Point {
public:int x, y;Point(int a, int b) : x(a), y(b) {}Point(const Point& p) : x(p.x), y(p.y) { // 复制构造函数cout << "Copy constructor called" << endl;}
};int main() {Point p1(1, 2);Point p2 = p1; // 等价于Point p2(p1)，触发复制构造函数return 0;
}

#include <iostream> 
using namespace std;// 定义Point类
class Point {
public:int x, y; // 公有数据成员// 构造函数Point(int a, int b) : x(a), y(b) {}// 复制构造函数Point(const Point& p) : x(p.x), y(p.y) {cout << "Copy constructor called: (" << x << "," << y << ")" << endl;}
};// 值传递函数，触发复制构造函数
void printPoint(Point p) {cout << "Point value: " << p.x << "," << p.y << endl;
}int main() {Point p(3, 4); // 创建Point对象pprintPoint(p); // 调用printPoint，触发复制构造函数return 0;
}

#include <iostream>
using namespace std;class Point {
public:int x, y;// 构造函数Point(int a = 0, int b = 0) : x(a), y(b) {cout << "Constructor called: (" << x << "," << y << ")" << endl;}// 复制构造函数Point(const Point& p) : x(p.x), y(p.y) {cout << "Copy constructor called: (" << x << "," << y << ")" << endl;}// 移动构造函数（C++11，用于验证RVO与移动语义）Point(Point&& p) noexcept : x(p.x), y(p.y) {cout << "Move constructor called: (" << x << "," << y << ")" << endl;p.x = p.y = 0; // 标记原对象已移动}
};Point getPoint() {Point temp(5, 6); // 调用构造函数创建tempcout << "Returning temp from getPoint" << endl;return temp; // 返回对象，触发复制/移动构造或RVO
}int main() {cout << "Creating point p..." << endl;Point p = getPoint(); // 接收返回值，观察构造函数调用cout << "p.x = " << p.x << ", p.y = " << p.y << endl;return 0;
}

#include <iostream>
#include <vector> // 引入vector容器头文件
using namespace std;// 定义Point类
class Point {
public:int x, y;// 构造函数Point(int a = 0, int b = 0) : x(a), y(b) {cout << "Constructor called: (" << x << "," << y << ")" << endl;}// 复制构造函数（关键：确保容器复制元素时正确调用）Point(const Point& p) : x(p.x), y(p.y) {cout << "Copy constructor called: (" << x << "," << y << ")" << endl;}
};int main() {vector<Point> vec; // 创建空vectorPoint p(1, 2); // 调用构造函数创建对象pcout << "Pushing p into vector..." << endl;vec.push_back(p); // 向vector添加元素，触发复制构造函数cout << "Vector size: " << vec.size() << endl;return 0;
}

class BadExample {
public:int* data;BadExample(int size) {data = new int[size]; // 分配内存}// 未定义复制构造函数，使用默认浅拷贝
};int main() {BadExample obj1(5);BadExample obj2 = obj1; // 默认复制构造函数，浅拷贝data指针obj1.data[0] = 10;      // obj2.data[0]也会变为10（共享内存）delete[] obj1.data;     // 释放内存后，obj2.data成为悬挂指针delete[] obj2.data;     // 二次释放，程序崩溃return 0;
}

#include <iostream>       
#include <algorithm>      // 包含copy算法
using namespace std;      class GoodExample {
public:int* data;int size;GoodExample(int s) : size(s) {data = new int[size]; // 分配动态内存fill(data, data + size, 0); // 使用fill初始化数组为0（替代手动循环）}// 自定义复制构造函数（深拷贝）GoodExample(const GoodExample& obj) : size(obj.size) {data = new int[size]; // 为新对象分配独立内存copy(obj.data, obj.data + size, data); // 复制数据cout << "Deep copy constructor called" << endl;}~GoodExample() {delete[] data; // 释放动态内存}
};int main() {GoodExample obj1(3); // 创建包含3个元素的对象obj1.data[0] = 1;    // 修改obj1的第一个元素为1GoodExample obj2 = obj1; // 调用深拷贝构造函数，创建obj2obj1.data[0] = 100;  // 修改obj1的第一个元素为100// 输出obj2的第一个元素（深拷贝后应保持原值0，因fill初始化时设为0，且未被obj2修改）cout << "obj2.data[0] = " << obj2.data[0] << endl; return 0;
}

class NonCopyable {
public:NonCopyable() = default;NonCopyable(const NonCopyable&) = delete; // 禁止复制构造NonCopyable& operator=(const NonCopyable&) = delete; // 禁止拷贝赋值
};int main() {NonCopyable obj1;NonCopyable obj2 = obj1; // 编译错误：复制构造函数被删除return 0;
}

#include <iostream>// 定义 Resource 类
class Resource {
public:int* data;// 构造函数，分配指定大小的内存Resource(int size) : data(new int[size]) {std::cout << "Constructor: " << data << std::endl;}// 复制构造函数（深拷贝）Resource(const Resource& rhs) : data(new int[rhs.data[0]]) {std::cout << "Copy Constructor: " << data << " from " << rhs.data << std::endl;}// 移动构造函数（资源转移）Resource(Resource&& rhs) noexcept : data(rhs.data) {rhs.data = nullptr; // 原对象置空，避免双重释放std::cout << "Move Constructor: " << data << " from " << rhs.data << std::endl;}// 析构函数，释放动态分配的内存~Resource() {delete[] data;std::cout << "Destructor: " << data << std::endl;}
};// 返回一个 Resource 对象
Resource getResource() {return Resource(10); // 返回右值，触发移动构造函数
}int main() {Resource obj = getResource(); // 优先调用移动构造函数return 0;
}    

ClassName::ClassName(ClassName& obj) { // 错误：非const引用无法接收临时对象// 编译错误：无法从const ClassName转换为ClassName&
}

class FileHandler {
public:FILE* file;FileHandler(const char* path) {file = fopen(path, "r"); // 打开文件}~FileHandler() {fclose(file); // 关闭文件}
};int main() {FileHandler f1("data.txt");FileHandler f2 = f1; // 默认浅拷贝，f1和f2的file指针相同// f1和f2析构时会两次关闭同一文件，导致程序崩溃return 0;
}

class Vector {
public:int* elements;int length;Vector(int len) : length(len) {elements = new int[len];}Vector(const Vector& vec) { // 错误：未初始化lengthcopy(vec.elements, vec.elements + vec.length, elements);}
};

Vector(const Vector& vec) : length(vec.length) { // 先初始化lengthelements = new int[length];copy(vec.elements, vec.elements + length, elements);
}

#include <iostream>
#include <algorithm>class ResourceManager {
public:// 构造函数ResourceManager(int size) : data(new int[size]), length(size) {std::cout << "Constructor called with size: " << length << std::endl;}// 析构函数~ResourceManager() {std::cout << "Destructor called for size: " << length << std::endl;delete[] data;}// 复制构造函数ResourceManager(const ResourceManager& rhs) : data(new int[rhs.length]), length(rhs.length) {std::cout << "Copy constructor called for size: " << length << std::endl;std::copy(rhs.data, rhs.data + length, data);}// 拷贝赋值运算符ResourceManager& operator=(const ResourceManager& rhs) {std::cout << "Copy assignment operator called for size: " << length << std::endl;if (this != &rhs) {delete[] data;data = new int[rhs.length];length = rhs.length;std::copy(rhs.data, rhs.data + length, data);}return *this;}// 移动构造函数ResourceManager(ResourceManager&& rhs) noexcept :data(rhs.data), length(rhs.length) {std::cout << "Move constructor called for size: " << length << std::endl;rhs.data = nullptr;rhs.length = 0;}// 移动赋值运算符ResourceManager& operator=(ResourceManager&& rhs) noexcept {std::cout << "Move assignment operator called for size: " << length << std::endl;if (this != &rhs) {delete[] data;data = rhs.data;length = rhs.length;rhs.data = nullptr;rhs.length = 0;}return *this;}private:int* data;int length;
};int main() {// 测试构造函数ResourceManager rm1(5);// 测试复制构造函数ResourceManager rm2(rm1);// 测试拷贝赋值运算符ResourceManager rm3(3);rm3 = rm1;// 测试移动构造函数ResourceManager rm4(std::move(ResourceManager(7)));// 测试移动赋值运算符ResourceManager rm5(2);rm5 = std::move(ResourceManager(9));return 0;
}