如何在C ++的递归函数中释放分配的内存

Question

I have a recursive method in a class that computes some stages (doesn't matter what this is). If it notice that the probability of success for a stage is to low, the stage will be delayed by storing it in a queue and the program will look for delayed stage later. It grabs a stage, copies the data for working and deletes the stage.

The program runs fine, but I got a memory problem. Since this program is randomized it could happen that it delays up to 10 million stages which results in something like 8 to 12 GB memory usage (or more but it crashes before that happens). It seems the program never frees the memory for a deleted stage before reaching the end of the call stack of the recursive function.

class StageWorker
{
private:
    queue<Stage*> delayedStages;

    void perform(Stage** start)
    {
       // [long value_from_stage = (**start).value; ]

       delete *start;

       // Do something here

       // Delay a stage if necessary like this
       this->delayedStages.push(new Stage(value));

       // Do something more here

       // Look for delayed stages like this
       Stage* front = this->delayedStages.front();
       this->delayedStages.pop();
       this->perform(&front);
    }
}

I use pointer to pointer as I thought the memory is not freed, because there is a pointer (front*) that points to the stage. So I used a pointer that point to the pointer, and so I can delete it. But it seems not to work. If I watch the memory usage on Performance monitor (on Windows) it like like this:
I marked the end of the recursive calls. This is also just a example plot. real data, but in a very small scenario.

Any ideas how to free the memory of not longer used sages before reaching the end of the call stack?

Edit
I followed some advice and removed the pointers. So now it looks like this:

class StageWorker
{
private:
    queue<Stage> delayedStages;

    void perform(Stage& start)
    {
       // [long value_from_stage = start.value; ]

       // Do something here

       // Delay a stage if necessary like this
       this->delayedStages.push(Stage(value));

       // Do something more here

       // Look for delayed stages like this          
       this->perform(this->delayedStages.front());
       this->delayedStages.pop();
    }
}

But this changed nothing, memory usage is the same as before.

As mentioned it maybe is a problem of monitoring. Is there a better way to check the exact memory usage?

Answer 1

Just to close this question as answered:

Mats Petersson (thanks a lot) mentiond in the comments that it could be a problem of monitoring the memory usage.

In fact this exactly was the problem. The code I provided in the edit (after replacing the pointers by references) frees the space correctly, but it is not given back to the OS (in this case Windows). So from the monitor it looks like the space is not freed.

But then I made some experiments and saw that freed memory is reused by the application, so it does not have to ask the OS for more memory.

So what the monitor shows is the maximum memory used bevore getting back the whole memory the recursive function required, after the first call of this function ends.