为何模板析构函数无法被引用且被删除？Vector3模板结构体使用报错求助

你的代码触发析构函数被删除的错误，核心在于union中包含了非平凡类型（std::vector<T>），再加上构造函数对union成员的混乱初始化，具体拆解如下：

1. 默认析构函数被删除的根本原因
   C++标准明确规定：如果union中包含拥有非平凡析构函数的类型（比如std::vector，它的析构函数需要主动释放动态分配的内存，属于自定义析构），编译器会自动删除默认的析构函数。因为编译器无法确定union中当前“活跃”的是哪个成员，也就不知道该调用哪个析构逻辑——是析构xyz结构体，还是析构std::vector？

2. 隐藏的未定义行为
   你的两个构造函数分别初始化了union的不同成员：

   • 默认构造函数初始化values，此时union的活跃成员是std::vector
   • 带参数的构造函数初始化xyz，此时活跃成员是三个T组成的结构体
     如果你在一个构造好的对象中访问非活跃成员（比如用带参数构造的对象去访问values，或者默认构造的对象去访问xyz.x），这属于未定义行为，程序可能崩溃或出现无法预期的结果。

方案一：移除union，用成员函数实现双访问方式（推荐） #

这是最简洁且安全的方案，既保留了你想要的两种访问形式（下标或x/y/z分量），又完全避免了union的生命周期管理问题：

#include <vector>

template <typename T> struct Vector3 {
    std::vector<T> values;

    // 默认构造：初始化三个元素为对应类型的默认值
    Vector3() : values(3, T{}) {}

    // 带参数构造：用x/y/z初始化vector
    Vector3(T x, T y, T z) : values({x, y, z}) {}

    // 提供x/y/z的读写访问器
    T& x() { return values[0]; }
    const T& x() const { return values[0]; }
    T& y() { return values[1]; }
    const T& y() const { return values[1]; }
    T& z() { return values[2]; }
    const T& z() const { return values[2]; }
};

修改后，你既可以像之前一样用vertex.values[i]访问元素，也可以用vertex.x()、vertex.y()来访问对应分量，而且所有特殊成员函数（析构、拷贝、移动等）都会被编译器正确生成，不会出现被删除的问题。

方案二：手动管理union的生命周期（不推荐） #

如果你坚持要使用union，需要添加一个标记跟踪当前活跃的成员，然后手动实现所有特殊成员函数（析构、拷贝构造、移动构造、赋值运算符等），示例代码如下：

#include <vector>
#include <utility>

template <typename T> struct Vector3 {
    enum class ActiveMember { XYZ, VALUES };
    ActiveMember active;
    union {
        struct { T x, y, z; } xyz;
        std::vector<T> values;
    };

    Vector3() : active(ActiveMember::VALUES), values(3, T{}) {}

    Vector3(T x, T y, T z) : active(ActiveMember::XYZ) {
        // 使用placement new初始化xyz成员
        new(&xyz) decltype(xyz){x, y, z};
    }

    // 手动实现析构函数
    ~Vector3() {
        if (active == ActiveMember::VALUES) {
            // 显式调用vector的析构函数
            values.~vector();
        }
        // xyz是平凡类型，无需显式析构
    }

    // 拷贝构造函数
    Vector3(const Vector3& other) : active(other.active) {
        if (active == ActiveMember::VALUES) {
            new(&values) std::vector<T>(other.values);
        } else {
            new(&xyz) decltype(xyz)(other.xyz);
        }
    }

    // 移动构造函数
    Vector3(Vector3&& other) : active(other.active) {
        if (active == ActiveMember::VALUES) {
            new(&values) std::vector<T>(std::move(other.values));
        } else {
            new(&xyz) decltype(xyz)(std::move(other.xyz));
        }
        // 将原对象标记为VALUES，避免其析构时出错
        other.active = ActiveMember::VALUES;
    }

    // 拷贝赋值运算符
    Vector3& operator=(const Vector3& other) {
        if (this == &other) return *this;

        // 先析构当前活跃成员
        if (active == ActiveMember::VALUES) {
            values.~vector();
        }

        // 拷贝新成员
        active = other.active;
        if (active == ActiveMember::VALUES) {
            new(&values) std::vector<T>(other.values);
        } else {
            new(&xyz) decltype(xyz)(other.xyz);
        }
        return *this;
    }

    // 移动赋值运算符
    Vector3& operator=(Vector3&& other) {
        if (this == &other) return *this;

        // 先析构当前活跃成员
        if (active == ActiveMember::VALUES) {
            values.~vector();
        }

        // 移动新成员
        active = other.active;
        if (active == ActiveMember::VALUES) {
            new(&values) std::vector<T>(std::move(other.values));
        } else {
            new(&xyz) decltype(xyz)(std::move(other.xyz));
        }

        other.active = ActiveMember::VALUES;
        return *this;
    }
};

这个方案虽然能解决问题，但代码复杂度极高，需要手动处理所有生命周期细节，非常容易引入新的bug，因此仅在特殊场景下考虑使用。

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