C++自定义支持无默认构造函数对象的Vector类浅拷贝问题

首先，核心问题很明确：你的自定义Vector在拷贝构造函数和赋值运算符重载中做了浅拷贝——只是直接复制了底层指针，没有为新实例分配独立的内存并拷贝对象，导致两个实例共享同一块内存区域。当其中一个修改内存内容时，另一个自然会跟着变化。

因为你要支持无默认构造的对象，所以不能用常规的new T[capacity]来分配内存（这会要求T有默认构造），得用原始内存分配+placement new的组合来实现深拷贝。下面是具体的解决步骤和代码示例：

1. 先明确自定义Vector的核心成员 #

假设你的Vector有这些核心成员（如果不一样可以对应调整）：

template<typename T>
class MyVector {
private:
    T* data_;          // 指向底层原始内存的指针
    size_t size_;      // 当前元素个数
    size_t capacity_;  // 已分配的内存容量
public:
    // 成员函数声明...
};

2. 实现正确的拷贝构造函数 #

拷贝构造需要：

• 分配足够的原始内存（用operator new[]，不会调用T的构造函数）
• 用placement new把原Vector的每个对象构造到新内存中
• 复制size和capacity的值

// 拷贝构造函数
MyVector(const MyVector& other) : size_(other.size_), capacity_(other.capacity_) {
    // 分配原始内存，不调用T的构造函数
    data_ = static_cast<T*>(operator new[](capacity_ * sizeof(T)));
    
    // 逐个拷贝构造对象（用placement new）
    for (size_t i = 0; i < size_; ++i) {
        new (data_ + i) T(other.data_[i]);  // 调用T的拷贝构造函数
    }
}

3. 实现安全的赋值运算符重载 #

推荐用拷贝交换 idiom，既简单又能保证异常安全：

// 赋值运算符重载
MyVector& operator=(MyVector other) {  // 传值，触发拷贝构造
    swap(*this, other);                // 交换当前对象和临时对象的资源
    return *this;
}

// 友元swap函数（或者成员swap，这里用友元更符合标准）
friend void swap(MyVector& lhs, MyVector& rhs) noexcept {
    using std::swap;
    swap(lhs.data_, rhs.data_);
    swap(lhs.size_, rhs.size_);
    swap(lhs.capacity_, rhs.capacity_);
}

4. 实现正确的析构函数 #

析构需要先逐个销毁对象（调用T的析构函数），再释放原始内存：

~MyVector() {
    // 销毁每个对象
    for (size_t i = 0; i < size_; ++i) {
        data_[i].~T();  // 手动调用析构函数
    }
    // 释放原始内存
    operator delete[](data_);
}

5. 支持无默认构造对象的push_back/emplace_back #

为了正确添加无默认构造的对象，你需要实现emplace_back（直接在内存中构造对象）或者带参数的push_back：

// emplace_back：直接在Vector内存中构造对象，支持任意参数
template<typename... Args>
void emplace_back(Args&&... args) {
    if (size_ >= capacity_) {
        // 扩容逻辑（同样用原始内存分配+placement new）
        size_t new_capacity = (capacity_ == 0) ? 1 : capacity_ * 2;
        T* new_data = static_cast<T*>(operator new[](new_capacity * sizeof(T)));
        
        // 移动旧对象到新内存（如果T支持移动，否则拷贝）
        for (size_t i = 0; i < size_; ++i) {
            new (new_data + i) T(std::move(data_[i]));
            data_[i].~T();
        }
        
        operator delete[](data_);
        data_ = new_data;
        capacity_ = new_capacity;
    }
    
    // 在新位置构造对象
    new (data_ + size_) T(std::forward<Args>(args)...);
    ++size_;
}

// 带拷贝的push_back（基于emplace_back实现）
void push_back(const T& value) {
    emplace_back(value);
}

// 带移动的push_back
void push_back(T&& value) {
    emplace_back(std::move(value));
}

6. 补充移动构造和移动赋值（可选但推荐） #

为了避免不必要的拷贝，提升性能，实现移动语义：

// 移动构造函数
MyVector(MyVector&& other) noexcept : data_(other.data_), size_(other.size_), capacity_(other.capacity_) {
    // 把原对象置为有效但空的状态
    other.data_ = nullptr;
    other.size_ = 0;
    other.capacity_ = 0;
}

// 移动赋值运算符（可以复用swap）
MyVector& operator=(MyVector&& other) noexcept {
    if (this != &other) {
        // 先销毁当前对象的资源
        for (size_t i = 0; i < size_; ++i) {
            data_[i].~T();
        }
        operator delete[](data_);
        
        // 接管原对象的资源
        data_ = other.data_;
        size_ = other.size_;
        capacity_ = other.capacity_;
        
        // 置空原对象
        other.data_ = nullptr;
        other.size_ = 0;
        other.capacity_ = 0;
    }
    return *this;
}

为什么你的原代码会出问题？ #

你原来的拷贝构造/赋值运算符大概率是直接复制了指针，比如：

// 错误的浅拷贝版本
MyVector(const MyVector& other) : data_(other.data_), size_(other.size_), capacity_(other.capacity_) {}

这种情况下，两个实例的data_指向同一块内存，所以当实例1插入新元素（可能扩容或修改内存）时，实例2的data_还是指向这块内存，自然会看到变化——甚至当其中一个实例析构后，另一个会变成悬垂指针，导致未定义行为。

内容的提问来源于stack exchange，提问作者Robert Hergenroder II