内存泄漏？ 怎么修？

Question

I have my own classes which implements queue and stack using LL, the source code compiles fine on my machine but after throwing it in valgrind it shows me some memory leaks

class S{
private:
struct Node{

int value;
Node* next; 

Node(int v, Node* n):value(v), next(n){}
};

Node* head;

S(const S& other) {}
S& operator=(const S& other) {}

public:
S():head(NULL){}


void push(unsigned int data){
    head = new Node(data, head);
}


class Q{
private:
struct Node{

int value;
Node* next;
Node(int v, Node* n):value(v), next(n){}
};

Node* head;
Node* tail;
int size;

Q(const Q& other) {}
Q& operator=(const Q& other) {}

public:
Q():head(NULL), tail(NULL), size(0){}

void push(int data){
    if (head == NULL) head = tail = new Node(data, tail);
    else{
        tail -> next = new Node(data, tail);
        tail = new Node(data, tail);
    }
    size++;
}

What am i doing wrong? Much help would be appreciated :) cheers

Answer 1

In your class constructor:

PQ(int cap){
capacity = cap;
arr = new int [capacity++];
for (int i= 0; i < capacity; i++)       arr[i] = {0};}

this:

capacity++

will first return the capacity and then increase its value by one. Because of this, when you are filling your array in a for loop, you are going out of array range, because your array size is 1 less than the capacity value.

Answer 2

This is not a "memory leak".

This is memory corruption. You can start fixing it by making a mental effort to understand that arrays in C++ are 0-based, not 1-based. The first element of an array is array[0] and not array[1] , and everything else is based on that. The following is based on the notion that array elements start with array element #1:

int top(){
    return arr[1];
}
void pop(){
    arr[1] = arr[size];

The first element of an array is element #0, not element #1, but this is structured based on the concept that the first element in the array is element #1.

It might seem like adding 1 to the array size before allocating it is an easy way to avoid having to make this adjustment, but it only leads to more grief, confusion, and bugs, later down the line. This is why, apparently, the constructor attempts to increment the size of the array before allocating it:

PQ(int cap){
    capacity = cap;
    arr = new int [capacity++];
    for (int i= 0; i < capacity; i++)       arr[i] = {0};
}

Except that it increments it incorrectly. It's a post-increment, so if, for example, cap was 4, new int[4] gets allocated, before capacity gets incremented. The next line attempts to clear array elements #0 through #4, except that array element #4 doesn't exist, the code tries to initialize it, runs off the end of the array, and valgrind throws a red flag.

Although this is fixable simply by using pre-increment instead of post-increment, the correct solution is not to increment at all, but restructure the code so that it follows the natural properties of C++ arrays being 0-based, instead of 1-based.