能写一个更详细的例子吗

当然可以，这里以一个更复杂的类`Person`为例，这个类包含了两个指针（分别指向姓名和地址）、一个数组以及一个动态分配的结构体。我们来展示如何编写深拷贝构造函数和相应的析构函数：

#include <iostream>
#include <string>

class Address {
public:
    Address(const std::string& street, const std::string& city) : street(street), city(city) {}

    std::string getStreet() { return street; }
    std::string getCity() { return city; }

private:
    std::string street;
    std::string city;
};

struct PersonalData {
    int id;
    float score;
    PersonalData(int id_, float score_) : id(id_), score(score_) {}
};

class Person {
public:
    std::string name;
    Address* address;  // 指针类型
    PersonalData* personalData;  // 动态分配的结构体
    int array[10];  // 数组

    // 深拷贝构造函数
    Person(const Person& other)
        : name(other.name),
          address(new Address(*other.address)),  // 深拷贝地址
          personalData(new PersonalData(*other.personalData)),  // 深拷贝PersonalData
          std::copy(other.array, other.array + sizeof(array), array) {} 

    ~Person() {
        delete address;
        delete personalData;
    }

private:
    // 禁止复制操作
    Person& operator=(const Person&) = delete;
};

int main() {
    Person original("Alice", new Address("123 Main St.", "New York"), new PersonalData(1, 95.5), {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});

    Person copied(original);
    return 0;
}

在这个例子中，当我们创建`copied`时，不仅复制了`name`这样的基本类型，还复制了`Address`和`PersonalData`的实例，并进行了数组元素的逐个复制。同时，为了避免内存泄漏，在`~Person()`的析构函数中删除了原本属于`original`的资源。