函数正确执行后如何修复 Core Dumped 错误？

Question

我写了C++代码：

#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <unordered_map>
#include <algorithm>

using namespace std;

template <class T>
class TreeNode {
public:
    T data;
    TreeNode<T> *left, *right;

    TreeNode() {
        data = {};
        left = right = NULL;
    }

    TreeNode(T data) {
        this->data = data;
    }
};

template <class T>
class BinaryTree {
public:
    TreeNode<T> *root;

    vector<T> _largestIndependentSet(TreeNode<T> *root) {
        static unordered_map< TreeNode<T>*, vector<T> > table;

        if(!root)
            return {};

        if(table.find(root) != table.end()) 
            return table[root];

        vector<T> lis = {}, lis_left = {}, lis_right = {},
            lis_nrl_left = {}, lis_nrl_right = {}, lis_nrr_left = {}, lis_nrr_right = {};

        // Leaf
        if(!root->left && !root->right) {
            lis.push_back(root->data);
        }else{
            if(root->left){
                lis_left = _largestIndependentSet(root->left);
                lis_nrl_left = _largestIndependentSet(root->left->left);
                lis_nrl_right = _largestIndependentSet(root->left->right);
            }

            if(root->right){
                lis_right = _largestIndependentSet(root->right);
                lis_nrr_left = _largestIndependentSet(root->right->left);
                lis_nrr_right = _largestIndependentSet(root->right->right);
            }
            if(     lis_left.size() + lis_right.size() > 
                    lis_nrl_left.size() + lis_nrl_right.size() +
                    lis_nrr_left.size() + lis_nrr_right.size() + 1      ){ // don't keep root
                lis.insert(lis.end(), lis_left.begin(), lis_left.end());
                lis.insert(lis.end(), lis_right.begin(), lis_right.end());
            }
            else {
                lis.insert(lis.end(), lis_nrl_left.begin(), lis_nrl_left.end());
                lis.insert(lis.end(), lis_nrl_right.begin(), lis_nrl_right.end());
                lis.insert(lis.end(), lis_nrr_left.begin(), lis_nrr_left.end());
                lis.insert(lis.end(), lis_nrr_right.begin(), lis_nrr_right.end());
                lis.push_back(root->data);
            }
        }
        cout<<"Calculated Results for: "<<root->data<<": ";
        for_each(lis.begin(), lis.end(), [](T data) {
            cout<<data<<" ";
        });
        cout<<"\n";
        table[root] = lis;
        return table[root];
    }

    void largestIndependentSet() {
        vector<T> lis = _largestIndependentSet(this->root);
        for_each(lis.begin(), lis.end(), [](T data) {
            cout<<data<<" ";
        });
    }
};

int main() {

    BinaryTree<int> bt;
    TreeNode<int> *root = new TreeNode<int>(10);
    root->left =  new TreeNode<int>(7);
    root->right =  new TreeNode<int>(15);
    root->left->left =  new TreeNode<int>(9);
    root->left->right =  new TreeNode<int>(12);
    root->right->left =  new TreeNode<int>(6);
    root->right->right =  new TreeNode<int>(11);
    root->left->left->left = new TreeNode<int>(20);
    root->right->left->right = new TreeNode<int>(5);
    root->left->left->left->left = new TreeNode<int>(22);
    root->left->left->left->right = new TreeNode<int>(21);
    root->right->left->right->left = new TreeNode<int>(4);
    root->right->left->right->right = new TreeNode<int>(3);
    bt.root = root;

    bt.largestIndependentSet();
    return 0;
}

我在 Cygwin 上使用 g++ 5.4.0 编译了它：

g++ binary_tree.cpp -std=c++11

问题是在递归函数_largestIndependentSet()完成后，最后的打印给了我正确的答案。但在那之后我得到这个错误：Aborted (core dumped)，largestIndependentSet() 中的打印不执行。

这很莫名其妙，因为我的逻辑似乎是正确的。这是什么原因造成的？

PS：如果我用 c++14 标志编译它，它运行良好 o_O:

g++ binary_tree.cpp -std=c++14

Answer 1

不会在发布的代码中讨论两个以上的主要问题。

T-值构造函数的子指针值不确定。
largestIndependentSet()

前者很常见，尤其是对于 C++ 初学者。确保留下 nothing 不确定的值。在这种情况下，TreeNode(T value) 构造函数中的 left 和 right 是不确定的。

后者非常重要。函数 largestIndependentSet() 声称它是 return 向量，但实际上根本没有 return。同样，这会调用 未定义的行为 。从那里我可以推测，但请注意仅此而已：推测：

推测：编译器愉快地生成了代码，该代码最终将恰好驻留在激活堆栈上的任何内容（由您取消设置）视为 std::vector<T>。当然，这是不确定的胡言乱语，因为您从未 return 编辑过实际对象。但是 std::vector<> 的非虚拟析构函数的调用当然不知道这一点，并且在这样做时，将碰巧占据它认为是其成员变量的任何东西视为有效数据，而实际上它是任何东西但。简而言之：获取随机内存，将 std::vector<> 析构函数代码指向它，对代码说谎并说内存持有有效的 std::vector<> 对象，然后释放析构函数。

至于为什么编译器没有错误。好吧，通常在 C 或 C++ 中，做一些不明智的事情并不是错误。编译器希望您对自己正在做的事情有足够的了解，并且在这种情况下，不存在语言违规，因此它给了您怀疑的好处。然而...在大多数现代编译器（icc、gcc、clang 和 msvc）上，将你的编译器警告级别调高到迂腐的高度 warn 你丢失了 return 价值。这些警告是有原因的，我强烈支持将它们打开和将它们视为错误（也是编译器选项）。

函数正确执行后如何修复 Core Dumped 错误？

How to fix a Core Dumped error when it's after the function correctly executes?

c++

memory-leaks

stl

core

c++11