0

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

#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;

但是在启动后它会因 sigmentation fault 的错误而崩溃 11. 我的错误在哪里？先感谢您。

4

1 回答 1

5

（第一个？）问题出在您的构造函数中

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;
}
于 2013-10-18T16:32:25.687 回答