具有堆类的分段错误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;
}