用堆类分割故障11

Question

我有这段代码，它只是堆的类。现在尝试将动态数组转换为类堆，然后打印出来，为此我使用了指针，因为它是不允许的。

#include <assert.h>
#include <iostream>
using namespace std;



class heap
{
public:
    heap(int size);
    ~heap();
    int add_element(int element);
    int get_min();
    void arr_to_q(int *arr, int len);
    void show();
    /* data */

private:
    void down(int i, int len);
    int* Buffer;
    int mysize;
    int currentsize;
    void up(int i, int len);
    void reallocate();
};

heap::heap(int size){
    int* Buffer=new int[size];
    currentsize=size;
    mysize=size;
    cout<<mysize;

}
heap::~heap(){

}

void heap::arr_to_q(int *arr, int len){
    cout<<currentsize;
    currentsize+=len;
    if (len>mysize){
        reallocate();
    }
    for (int i=len-1; i>=0; i--){
        up(i, len);
    }
}

void heap::reallocate(){
    int *sbuffer=Buffer;
    int *Buffer = new int[mysize*2];
    mysize*=2;
    for (int i=0; i<mysize; i++){
        Buffer[i]=sbuffer[i];

    }
    delete [] sbuffer;
}


void heap::up(int i, int len){
    int par, sosed, min;
    if (i%2==0){
        par=i/2-1;
        sosed=i-1;
    }
    else{
        par=i/2;
        sosed=sosed+1;
    }
    if (Buffer[i]<Buffer[sosed]){
        min=i;
    }
    else{
        min=sosed;
    }
    if (Buffer[min]<Buffer[par]){
        int c = Buffer[min];
        Buffer[min]=Buffer[par];
        Buffer[par]=c;
        up(min, len);
    }
}

void heap::show(){
    for(int i=0; i<currentsize; i++){
        cout<<"You queue is"<<Buffer[i];
    // cout<<"currentsize: "<<currentsize;
    }
}

int main(){
    int len;
    printf("Vvedite dlinu massiva");
    scanf("%d", &len);
    int *arr=new int[len];
    for(int i=0; i<len;i++){
        printf("Vvedite %d element\n", i);
        scanf("%d", &arr[i]);
    }

    heap heaps(5);
    heaps.arr_to_q(arr, len);
    // heaps.show();
    delete [] arr;

但是，在它起飞后，由于印字错误11而崩溃了。我的错误在哪里？提前谢谢你。

Answer 1

(第一个？)问题在构造函数中。

heap::heap(int size){
    int* Buffer=new int[size];
    ....

声明一个局部变量Buffer，为此分配内存，然后在函数完成时泄漏它。成员变量Buffer从来没有初始化过，所以当第一次访问它时可能会导致分段错误。

修复方法是简单地初始化成员变量。

heap::heap(int size){
    Buffer=new int[size];
    ....

请注意，reallocate中也存在问题。释放类成员Buffer，但不指向本地分配的Buffer。在复制旧内容时，您还可以在旧缓冲区的末尾进行读取。访问不属于自己的内存会调用未定义的行为，这可能是导致分段错误的另一个原因。

如下所示应该可以解决这些问题：

void heap::reallocate(){
    int newSize = mysize*2;
    int *newBuffer = new int[newSize];
    for (int i=0; i<mysize; i++){
        newBuffer[i] = Buffer[i];
    }
    mysize = newSize
    delete [] Buffer;
    Buffer = newBuffer;
}