std::vector重新赋值未调用析构函数的问题及解决建议

嘿，这个问题我熟！让我一步步给你拆解清楚～

首先，咱们得先搞明白为什么原位置的S(1)实例析构函数没被调用：当你直接给vector的元素赋值（比如vec[0] = S(2)）时，vector并不会先销毁原对象再构造新对象，而是直接调用原对象的赋值运算符，把新对象的值拷贝/移动过去。原对象的生命周期还在，自然不会触发析构函数。

关于手动调用析构函数的疑问 #

绝对！绝对！绝对不要手动调用析构函数！这是非常危险的操作——手动调用析构后，对象的内存仍然属于vector的管理范围，后续vector在扩容、销毁容器时，会再次对这块内存调用析构函数，导致双重析构，直接引发未定义行为（程序崩溃、内存 corruption 都是常见后果）。

正确解决方案 #

根据你的实际场景（存储二叉树节点，需要确保元素移除时触发析构），推荐两种靠谱的方案：

方案1：先删除原元素，再插入新元素

如果坚持存储对象本身，可以通过erase先移除原元素（此时会触发原对象的析构），再用emplace在原位置构造新元素。示例代码如下：

#include <iostream>
#include <vector>

class S {
public:
    int val;
    S(int v) : val(v) { std::cout << "Construct S(" << val << ")\n"; }
    ~S() { std::cout << "Destruct S(" << val << ")\n"; }
};

int main() {
    std::vector<S> vec;
    vec.emplace_back(1);
    
    std::cout << "Replacing element...\n";
    // 先删除原元素，触发析构
    vec.erase(vec.begin());
    // 在原位置构造新元素
    vec.emplace(vec.begin(), 2);
    
    std::cout << "End of main\n";
    return 0;
}

运行输出会清晰看到原对象的析构被触发：

Construct S(1)
Replacing element...
Destruct S(1)
Construct S(2)
End of main
Destruct S(2)

方案2：存储智能指针（推荐用于二叉树场景）

对于二叉树节点这种通常包含动态分配内存（子节点指针）的对象，强烈推荐用std::unique_ptr存储在vector中。当你替换vector中的智能指针时，原unique_ptr会被销毁，自动触发其所指对象的析构函数，连带着子节点的析构也能自动处理（只要你的节点析构函数里正确递归删除子节点）。示例代码：

#include <iostream>
#include <vector>
#include <memory>

class TreeNode {
public:
    int val;
    TreeNode* left;
    TreeNode* right;
    
    TreeNode(int v) : val(v), left(nullptr), right(nullptr) {
        std::cout << "Construct TreeNode(" << val << ")\n";
    }
    
    ~TreeNode() {
        std::cout << "Destruct TreeNode(" << val << ")\n";
        // 递归析构子节点
        delete left;
        delete right;
    }
};

int main() {
    std::vector<std::unique_ptr<TreeNode>> treeNodes;
    treeNodes.emplace_back(std::make_unique<TreeNode>(1));
    
    std::cout << "Replacing node...\n";
    // 替换智能指针，原指针自动销毁，触发TreeNode(1)的析构
    treeNodes[0] = std::make_unique<TreeNode>(2);
    
    std::cout << "End of main\n";
    return 0;
}

运行输出：

Construct TreeNode(1)
Replacing node...
Construct TreeNode(2)
Destruct TreeNode(1)
End of main
Destruct TreeNode(2)

这种方案不仅能确保元素移除/替换时触发析构，还能避免手动管理内存的麻烦，非常适合复杂的数据结构场景。

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