C++ 如何在不丢失任何数据的情况下释放左、右和临时内存？ void将_拆分为_子项（btnode&rootNode，btnode&root）{ 长*键=&（根->键[0]）； int middle=root->capacity/2； int i； btnode left=新节点（订单）； btnode right=新节点（订单）； btnode temp=新节点（订单）； for（int i=0；i键[i]=根->键[i]； 左->值[i]=根->值[i]； 左->容量+=1； 左->节点[i]=根->节点[i]； } 左->节点[中间]=根->节点[中间]； 对于（i=0；icapacity-middle；i++）{ 右键->键[i]=根键->键[middle+1+i]； 右->值[i]=根->值[middle+1+i]； 右->容量+=1； 右->节点[i]=根->节点[middle+1+i]； } 右->节点[右->容量]=根->节点[根->容量+1]； 临时->键[0]=根->键[中间]； 临时->值[0]=根->值[中间]； 临时->节点[0]=左侧； 临时->节点[1]=右侧； 温度->容量=1； 用于（int i=0；i容量；i++）{ if（左->节点[i]！=NULL） 左->节点[i]->父节点=左； } 用于（int i=0；i容量；i++）{ 如果（右->节点[i]！=NULL） 右->节点[i]->父节点=右； } 如果（根->父==根）{ 右->父级=临时； 左->父级=临时； temp->parent=temp； rootNode->parent=temp； rootNode=temp； }否则{ 将_middle_添加到_parent（rootNode，root->parent，left，right，root->key[middle]，root->value[middle]）； } }

我使用了left和right来拆分b+树节点，并使用temp来存储指向左侧和右侧的中间节点。在从函数返回之前，如何释放内存o left、right和temp

节点类：

void split_into_children ( btnode& rootNode, btnode& root ) {
    long* key = & ( root->key[0] );
    int middle = root->capacity / 2;
    int i;
    btnode left = new node ( order );
    btnode right = new node ( order );
    btnode temp = new node ( order );
    for ( int i = 0; i < middle; i++ ) {
        left->key[i] = root->key[i];
        left->value[i] = root->value[i];
        left->capacity += 1;
        left->nodes[i] = root->nodes[i];
    }
    left->nodes[middle] = root->nodes[middle];
    for ( i = 0; i < root->capacity - middle; i++ ) {
        right->key[i] = root->key[middle + 1 + i];
        right->value[i] = root->value[middle + 1 + i];
        right->capacity += 1;
        right->nodes[i] = root->nodes[middle + 1 + i];
    }
    right->nodes[right->capacity] = root->nodes[root->capacity + 1];
    temp->key[0] = root->key[middle];
    temp->value[0] = root->value[middle];
    temp->nodes[0] = left;
    temp->nodes[1] = right;
    temp->capacity = 1;
    for ( int i = 0; i <= left->capacity; i++ ) {
        if ( left->nodes[i] != NULL )
            left->nodes[i]->parent = left;
    }
    for ( int i = 0; i <= right->capacity; i++ ) {
        if ( right->nodes[i] != NULL )
            right->nodes[i]->parent = right;
    }
    if ( root->parent == root ) {
        right->parent = temp;
        left->parent = temp;
        temp->parent = temp;
        rootNode->parent = temp;
        rootNode = temp;
    } else {
        add_middle_to_parent ( rootNode, root->parent, left, right, root->key[middle], root->value[middle] );
    }
}

类节点
{
公众：
长*键；
国际能力；
节点**节点；
节点*父节点；
长*值；
节点（整数顺序）{
键=新长[订单+1]；
值=新长[订单+1]；
节点=新节点*[订单+2]；
容量=0；
parent=NULL；
对于（int i=0；i节点[i]=NULL；
}
}
~node（）{
删除[]键；
删除[]值；
删除[]个节点；
}
};
<代码> >代码>删除左边< /代码>，代码>删除代码>代码>代码>删除临时代码>代码>，我说，我对C++很差，但是在堆栈上分配这三个变量而不是指针不是更习惯吗？也可以，在你的代码中看到“代码> ROONTeNoCT= TIMP < /代码>和类似的赋值，你可能不想去处理。完全没有内存。你可以使用智能指针，看着它们为你释放内存。为什么这些对象不能在堆栈上？不清楚你在做什么，也不清楚你的
节点
类是如何工作的。我怀疑它会自动删除它的子树，你想在删除时阻止它这样做。如果是这样的话，请准确地执行与您从根目录复制这些指针时所做的相同循环，但改为空值。@millimoose我没有使用delete left、delete right，因为数据将丢失。我无法将这三个变量存储在堆栈上，因为left、right和temp是指向B+树节点的指针，该节点包含多个指针和值。
class node
{

public:

    long* key;
    int capacity;
    node** nodes;
    node* parent;
    long* value;

    node ( int order ) {
        key = new long[order + 1];
        value = new long[order + 1];
        nodes = new node *[order + 2];
        capacity = 0;
        parent = NULL;
        for ( int i = 0; i <= order + 1; i++ ) {
            this->nodes[i] = NULL;
        }
    }
    ~node() {
        delete[] key;
        delete[] value;
        delete[] nodes;
    }

};