C++创建支持任意类型的自包含模板容器类时的编译错误问题

1. 嵌套实例化时的默认构造函数报错 #

问题原因 #

你用new T[n]分配数组时，C++会自动给每个T对象调用默认构造函数。如果你的container<T>只定义了带大小参数的构造函数，没显式添加默认构造，那container<int>就没有默认构造函数，new container<int>[n]自然编译失败。

解决方法 #

有两种可行思路：

• 给container添加默认构造函数：
  直接添加默认构造，比如container() = default;，这样new T[n]就能正常触发默认构造。但这种方法有局限：如果后续要存储的类型本身没有默认构造，还是会出问题。

  template <typename T>
  class container {
  private:
      T* data = nullptr;
      size_t size = 0;
  public:
      container() = default; // 默认构造函数
      container(size_t n) : size(n) {
          data = new T[n];
      }
      ~container() {
          delete[] data;
      }
  };
  

• 改用「裸内存分配+手动构造」方式：
  放弃new T[n]，用operator new先分配裸内存，再通过placement new手动构造每个元素。这种方式不要求T必须有默认构造，灵活性更高。

2. 手动分配裸内存导致的双释放段错误 #

问题根源 #

你只做了内存的分配和释放，但没正确处理T对象的构造与析构：

• 如果T是带析构函数的类型（比如container<int>），直接释放内存会导致T的析构函数未被调用，其内部的data指针不会被释放，轻则内存泄漏，重则引发后续错误；
• 若未实现深拷贝的拷贝构造/赋值逻辑，浅拷贝会让多个容器指向同一块内存，析构时就会重复释放，直接触发段错误。

正确实现方案 #

必须按四步处理内存：分配内存→构造元素→析构元素→释放内存，同时实现拷贝构造、拷贝赋值、移动构造、移动赋值（即C++的「五法则」），彻底解决浅拷贝问题。

完整示例代码：

#include <iostream>
#include <memory>

template <typename T>
class container {
private:
    T* data = nullptr;
    size_t size = 0;

public:
    // 带大小的构造函数：先分配裸内存，再手动构造元素
    explicit container(size_t n) : size(n) {
        // 1. 分配裸内存（仅占空间，不构造对象）
        data = static_cast<T*>(operator new(n * sizeof(T)));
        // 2. 用placement new在内存上构造每个T对象（此处用默认构造，也可传参数）
        for (size_t i = 0; i < size; ++i) {
            new (data + i) T();
        }
    }

    // 析构函数：先销毁每个元素，再释放裸内存
    ~container() {
        if (data != nullptr) {
            // 逐个调用元素的析构函数
            for (size_t i = 0; i < size; ++i) {
                std::destroy_at(data + i); // 等价于 (data + i)->~T();
            }
            // 释放裸内存
            operator delete(data);
        }
    }

    // 拷贝构造：深拷贝，避免多对象共享内存
    container(const container& other) : size(other.size) {
        data = static_cast<T*>(operator new(size * sizeof(T)));
        for (size_t i = 0; i < size; ++i) {
            new (data + i) T(other.data[i]); // 拷贝构造每个元素
        }
    }

    // 拷贝赋值：先清理自身资源，再深拷贝
    container& operator=(const container& other) {
        if (this != &other) {
            // 销毁自身元素并释放内存
            for (size_t i = 0; i < size; ++i) {
                std::destroy_at(data + i);
            }
            operator delete(data);

            // 重新分配内存并拷贝构造
            size = other.size;
            data = static_cast<T*>(operator new(size * sizeof(T)));
            for (size_t i = 0; i < size; ++i) {
                new (data + i) T(other.data[i]);
            }
        }
        return *this;
    }

    // 移动构造：直接接管对方资源，避免拷贝开销
    container(container&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }

    // 移动赋值：接管对方资源，同时清理自身旧资源
    container& operator=(container&& other) noexcept {
        if (this != &other) {
            // 清理自身资源
            for (size_t i = 0; i < size; ++i) {
                std::destroy_at(data + i);
            }
            operator delete(data);

            // 接管对方的内存与大小
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }

    // 重载[]方便访问元素
    T& operator[](size_t idx) {
        return data[idx];
    }

    const T& operator[](size_t idx) const {
        return data[idx];
    }

    size_t get_size() const {
        return size;
    }
};

// 测试嵌套容器实例化
int main() {
    container<container<int>> nested(3);
    for (size_t i = 0; i < nested.get_size(); ++i) {
        nested[i] = container<int>(5); // 用移动赋值提升效率
        for (size_t j = 0; j < nested[i].get_size(); ++j) {
            nested[i][j] = i * 10 + j;
            std::cout << nested[i][j] << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

核心注意事项 #

• operator new/operator delete仅负责内存的分配与释放，不会自动调用构造/析构函数；
• placement new用于在已分配的裸内存上构造对象，std::destroy_at用于手动销毁对象，二者必须配对使用；
• 必须实现深拷贝和移动语义，否则多个容器指向同一块内存，析构时必然触发重复释放；
• 若不需要默认构造元素，可修改构造函数，比如new (data + i) T(初始值)，传入参数构造每个元素。

内容的提问来源于stack exchange，提问作者Tejas Anand