How can I delete variables in C++

Question

I want to free ram in my program.

Even though I'm a novice, I really care about performance.

string i_want_to_delete_this = "I don't want this cleared, but            
completely gone";
/* I figured out */ i_want_to_delete_this.clear() /* simply sets the
string value to "". I want to be able to do this with every
datatype! I want it completely gone, not even declared anymore. */

That's not the way C++ works... Variables vashish when they go out of scope, full stop. After all, C++ is a compiled language, not an interpreted one... — Serge Ballesta, Jan 11 '17 at 18:26
Presumably you've declared this string in a function somewhere. When the function returns, the string no longer exists. Limit the scope of your objects and you limit resource usage. Don't explicitly worry about it. — GManNickG, Jan 11 '17 at 18:27
As the other comment correctly says, this is not how c++ works. Refer to a [good c++ book](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list) — Jason, Sep 01 '22 at 13:51

score 9 · Answer 1 · answered Jan 11 '17 at 18:26

I don't see why you want to do this, and in any case you cannot delete or otherwise remove named variables, except in so far as they are conceptually removed for you by the compiler when they go out of scope, and actually removed when the function that contains them exits. For example:

{
   {
       string i_want_to_delete_this = "I don't want this cleared, but            
completely gone";
   }     // it's gone
}

CygnusX1 · Accepted Answer · 2022-09-01T13:45:51.793

There are 3 kinds of variables. Depending on the kind you manage the memory differently.

Global Variables

These reside in a special section of your program. They appear when the program starts and disappear when the program ends. You cannot do anything to reclaim the memory occupied by global variables. Some more complex constants may fall into that category as well. Your character string literal "I don't want this cleared, but completely gone" is most likely going to reside there, no matter if you copy it to i_want_to_delete_this variable or not.

Stack Variables

Local variables and function arguments. They appear within your code. The memory is allocated when you enter the scope of that variable, and are removed automatically when you leave the scope:

{ //beginning of the scope
    int foo = 42; // sizeof(int) bytes allocated for foo
    ...
} //end of the scope. sizeof(int) bytes relaimed and may be used for other local variables

Note that when optimizations are on, local variables may be promoted to registers and consume no RAM memory at all.

Heap Variables

Heap is the only kind of memory you manage yourself. In plain C you allocate memory on the heap using malloc and free it with free, e.g.

int* foo = (int*)malloc(sizeof(int)); //allocate sizeof(int) bytes on the heap
...
free(foo); //reclaim the memory

Note that the foo itself is a local variable, but it points to a portion of heap memory where you can store an integer.

Same thing in C++ would look as:

int* foo = new int; //allocate sizeof(int) bytes on the heap
...
delete foo; //reclaim the memory

Heap is usually used when the variable must exist much longer than the scope, usually depending on some more complex program logic.

"The memory is allocated when you enter the scope of that variable" - no, it is always (for all compilers I'm aware of) allocated on entry to the function that contains the variable. — , Jan 11 '17 at 18:40
The maximum amount of memory needed by a function is allocated at the function entry, but how that memory is assigned to variables in different scopes - that is a different matter. If you have two scopes one after another `{ int x; ... } { int y; ... }` you are going to consume only `sizeof(int)` of stack memory, not `2*sizeof(int)`. The compiler knows that at the first `}` the memory can be reclaimed. This reclaim is 'free' though - there is no machine instruction needed. — CygnusX1, Jan 11 '17 at 18:44
Why present `plain C` dynamic allocation when the question is about `C++`? — Galik, Jan 11 '17 at 19:18

score 2 · Answer 3 · answered Jan 11 '17 at 18:30

Automatic variables, those not using malloc or the new operator, are deleted when execution leaves a function or substatement.

Variables declared outside a function will remain in memory until the program terminates.

Also, I would focus on program correctness and robustness. Only worry about RAM or Memory usage if program doesn't fit in the memory of your platform.

In the real world, the workplace, most data that is processed by a program and doesn't fit into memory can be split into pieces and each piece processed separately (there are a few exceptions though).

How can I delete variables in C++

3 Answers3