深拷贝

class instance
{
public:
	int age;
	int* height;
instance(int a,int h)
{
	age = a;
	cout << a << endl;
	height=new int(h);
	cout << *height << endl;
}
~instance()
{
	if (height != NULL)
	{
		delete height;
		height = NULL;
		cout << "已清空" << endl;
	}
}
instance(const instance& p)
{
	age = p.age;
	//height = p.height;编译器默认实现的就是这行代码
	//深拷贝如下
	height = new int(*p.height); 
}
};


//浅拷贝使两个height指向同一内存地址，会导致将已释放的内存再次释放，引发双重释放安全问题
void test01()
{
	instance p1(18,160);
	instance p2(p1);
	cout << p2.age <<*p2.height<<endl;
}
int main()
{
	test01();
	system("pause");
}

重载赋值运算符

众所周知，运算符重载后使运算符能实现原本无法完成的工作
赋值运算符，这里我们实现类对类的赋值.


class MyClass {
private:
    char* data;

public:
    // 默认构造函数
    MyClass(const char* str = "") {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }

    // 拷贝构造函数
    MyClass(const MyClass& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }

    // 重载赋值运算符
    MyClass& operator=(const MyClass& other) {
        if (this == &other) {
            return *this;  // 处理自赋值情况
        }

        // 先释放原有资源
        delete[] data;

        // 分配新内存并拷贝数据
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);

        return *this;
    }

    // 析构函数
    ~MyClass() {
        delete[] data;
    }

    // 打印数据
    void print() const {
        std::cout << data << std::endl;
    }
};

int main() {
    MyClass a("Hello");
    MyClass b("World");

    std::cout << "Before assignment:" << std::endl;
    a.print(); // 输出 "Hello"
    b.print(); // 输出 "World"

    a = b; // 使用重载的赋值运算符

    std::cout << "After assignment:" << std::endl;
    a.print(); // 输出 "World"
    b.print(); // 输出 "World"

    return 0;
}