Memory leak on the stack

Question

Is it possible to create memory leak in C++ without heap allocation, through very bad design ?

One example I had in mind, please correct me if it does not do what I think it does:

#include <iostream>
#include <string>

void WhatIsYourName()
{
  std::string name;
  std::cout << "What is your name? ";
  getline (std::cin, name);
  std::cout << "Hello, " << name << "!\n";

  WhatIsYourName();
}

int main()
{
  WhatIsYourName();
}

To me it looks like WhatIsYourName() is initializing a new std::string name on every call, but the function never really goes out of scope so the memory is never released. Is that right ? Or is the compiler smart enough to see that the variable will not be used in the future, so it deletes it without the function going out of scope ?

What kind of other bad design would create a memory leak using only stack allocation ?

This is not a memory leak. This is infinite recursion. It would still crash if you had no variables. — NathanOliver, Dec 13 '16 at 14:35
How and why would it crash ? It runs fine when I compile it, the `getline` pauses the function on every recursion. — Jean-Emmanuel, Dec 13 '16 at 14:36
It depends on what you call a memory leak. In the C++ world, this is not a memory leak. — Ionel POP, Dec 13 '16 at 14:37
See the answer. It will run forever and with recursion that means a stack overflow. — NathanOliver, Dec 13 '16 at 14:37
Got it. So, is it possible to create a memory leak without heap allocation ? Or is it not ? — Jean-Emmanuel, Dec 13 '16 at 14:38

vsoftco · Accepted Answer · 2016-12-13T14:42:14.133

7

You have a recursive call that doesn't stop (there's no exit condition), so a new stack page is created for every function invocation, until of course the program crashes due to stack overflow. The compiler cannot optimize that away.

Regarding your last question, whether is possible to create a memory leak without heap allocation (and without this kind of infinite recursion), I believe it is not, the local variables are automatically released, that's why this type of storage duration is called automatic storage duration.

edited Dec 13 '16 at 14:42

answered Dec 13 '16 at 14:35

vsoftco

55,410
12
139
252

1

Note that the example used `std::string` which performs heap allocation. Since indirect heap allocation appears to be in play, there's `std::make_unique(1).release();` – Raymond Chen Dec 14 '16 at 03:07
1

@RaymondChen That's a good point, although I believe `std::string` will use the [small string optimization (SSO)](http://stackoverflow.com/questions/10315041/meaning-of-acronym-sso-in-the-context-of-stdstring) in this case (which places the content on the stack). – vsoftco Dec 14 '16 at 03:11

score 6 · Answer 2 · answered Dec 13 '16 at 14:43

No it is not possible to create a memory leak with objects that have automatic storage duration (some people call this stack). When you have a variable with automatic storage duration it is cleaned up by the program automatically. Once the scope ends that it was declared in it gets destroyed and any resources it had are freed (as long as it was designed properly). In your example even though you never exit the scope due to infinite recursion it is not a memory leak. If the infinite recursion was removed and instead it ended at some condition then all the variables you declared would be cleaned up.

To get a memory leak you need to create a object with dynamic storage duration (what some people call heap) and never clean it up. When you have a object with dynamic storage duration the compiler does not clean it up for you. You need to make sure you clean it up yourself. It is this forgetting or leaving out of the clean up code that causes a memory leak.

SergeyA · Answer 3 · 2016-12-13T14:45:32.217

The question is more interesting than you probably thought. There is no memory leak by definition, since memory leak can only be happening if a) a pointer to the allocated memory is lost (not the case here) or b) the pointer is never freed until program exits normally. The second is not the case either, since this program will never exit normally.

However, there is an interesting question of what actually happens to the string variable. Since the recursive call happens in the end of the function, from the glance it might seem that the code will be a candidate for tail-call optimization. However, if you check the assembly, it does not happen, because compiler needs to call string destructor after the return from the tail-call. I personally see this is a flaw in the optimization, since potentially compiler should be able to see that string variable is not used after the call and destruct it in advance.

Hmm, I would have thought the same, but GCC and Clang [don't do TCO](https://godbolt.org/g/PCz8wW) even if you put the `std::string` in a local scope. — TartanLlama, Dec 13 '16 at 14:45

score 1 · Answer 4 · answered Dec 13 '16 at 14:45

I think you have misunderstood what a memory leak is in C and C++ worlds. Given your condition "without heap allocation", it's not possible to leak memory.

A memory leak is typically associated with dynamic memory allocation(s) and then losing the ability to deallocate it. For example:

// Memory leak
int x;
int *q = new int;
q = &x; // memory leak because the "allocated" q is lost.

With RAII and not using new + delete for memory management, it's easily avoidable in C++.

score 1 · Answer 5 · answered Sep 30 '19 at 20:51

1

If the compiler has a bug, you could have a stack memory leak. For some obscure reason it "forgets" to call the destructor of a local variable. Check GCC bug 66139.

answered Sep 30 '19 at 20:51

Gralha

11
1

Memory leak on the stack

5 Answers5

Linked