Question

我不确定为什么我的add函数会导致大量内存泄漏，无效读取和无效写入。当然，它还包含其他几个功能，因此我也将它们包括在内。我讨厌上传太多代码，但是我不确定在哪里出错。

heap.h头文件：

struct Entry {
  int key;
  char* value;
};

typedef struct Entry Entry;

struct Heap {
  int capacity;
  int size;
  Entry** elements;
};

typedef struct Heap Heap;

heap.c：

void add(Heap* h, int priority, char* val) {
  if (h->size >= h->capacity) {
    expandCapacity(h);
  }
  //insert at end of storage array and bubble up
  Entry* toAdd = calloc(1, sizeof(Entry*));
  toAdd->key = priority;
  toAdd->value = calloc(1, sizeof(char*));
  toAdd->value = val;
  h->elements[h->size]=toAdd;
  h->size += 1;
  bubbleUp(h, h->size);
}

bubbleUp和swap被赋予了功能，我要做的就是将它们适应该项目并将其转换为c，因此这样做可能存在问题，尽管它们在逻辑上对我来说很有意义。

void bubbleUp(Heap* h, int index) {
   if(index <= 0) { return; }
   Entry* e = h->elements[index];
   Entry* parent = h->elements[(index-1)/2];
   int comp = strcmp(e->value, parent->value);
   if(comp > 0) {
     swap(h, index, parent->key);
     bubbleUp(h, parent->key);
   }
   else {
     return;
   }
}

void swap(Heap* h, int index1, int index2) {
   Entry* tmp = h->elements[index1];
   h->elements[index1] = h->elements[index2];
   h->elements[index2] = tmp;
}

Answer 1

在

void add(Heap* h, int priority, char* val) {
    if (h->size >= h->capacity) {
        expandCapacity(h);
    }
    //insert at end of storage array and bubble up
    Entry* toAdd = calloc(1, sizeof(Entry*));
    toAdd->key = priority;
    toAdd->value = calloc(1, sizeof(char*));
    toAdd->value = val;
    h->elements[h->size]=toAdd;
    h->size += 1;
    bubbleUp(h, h->size);
}

您要为一个结构条目分配内存，而不是为其指针分配内存，这样就可以完成工作

Entry* toAdd = calloc(1, sizeof(Entry));

您不需要为指针toAdd->value分配内存，因为编译器已经静态为其分配了内存。

这时，如果要复制指针，只需删除此行toAdd->value = calloc(1, sizeof(char*)); 相反，如果要复制字符串的内容，则必须使用strncpy

Answer 2

这是内存泄漏。分配一个块，然后立即丢失。我只删除第一行。

category

此外，您应该在此处分配toAdd->value = calloc(1, sizeof(char*)); toAdd->value = val;，而不是指针的大小。

sizeof(Entry)

我在C中的堆实现的添加函数中正确实例化了指针吗？

2 个答案: