I think one very underused feature in C++ today is simply storing objects on the stack. Many developers who have started writing C# or Java are used to always using new to declare a variable and do the same thing when they are writing C++. And when they later learn that you should never write a naked new, they instead start using unique_ptr or shared_ptr to manage the lifetime of their objects. What they are forgetting is that many times is it sufficient to simply store the instance that you are creating on the stack as a solid object, either as a member of a class or in the local function scope.
The standard library does this all the time, you write
std::string* myString = new std::string("text"); // oh no! My eyes!
If you are certain what type of object you need and when you need it, then simply put it on the local stack!
void function(int size)
std::vector<int> integerVector(size); // vector of 'size' values
foo localObject(size); // passing 'size' as parameter to the constructor of foo
} // the local object are automatically destroyed here, no worries about memory leaks!
For often called methods you will get a performance increase by doing this since the allocation of an object on the free store takes some time (new has to locate a free portion of memory to allocate).
The exceptions where you don’t want to allocate the object on the local stack include cases where you may want polymorphic behavior, or the class contains large amounts of data making the object too large for the stack.
There is much confusion regarding the usage of the words stack, heap and free store. Most developers are using the stack and heap wrongly for C++.
The stack (actually the call stack) is the memory where all your local variables in a function will be located. The stack is a memory structure where all the function calls, from the start of the current thread, up to the currently executed function are stored together with the memory that they use. The variables which reside on the stack are stored there until the function where they reside returns. Once the method returns then all local (stack) variables will be cleaned up.
The heap is a legacy from C which should not be used in C++. Objects on the heap are allocated using malloc or calloc and released again using free. You should never use malloc or calloc to allocate an object in C++. This since these calls does not call the constructor of the object, leaving you with allocated memory for an invalid object.
The free store is in C++ what the heap was in C. Objects on the free store are allocated using new or new and released again using delete or delete. Objects allocated using new or new are allocated and their constructor is being called once the memory is allocated. Objects destroyed using delete or delete have their destructor called before the memory is released again.
Stack unwinding refers to the handling of exceptions in C++. When an exception occurs then the call stack is searched for the next matching catch statement and the execution of the program is continued at the beginning of the catch clause. No other code in between is ever evaluated.
This is to say that for the functions
cout << "end f1()" << endl;
cout << "end f2()" << endl;
cout << "end f3()" << endl;
Then the program will never output any of the output statements!
However, and this is important, if the function f3() above did instead look like this:
Date christmasDay(2015, 12, 25);
cout << "end f3()" << endl;
then the cout statement would not be called, but the destructor of Date would be called. All local objects will be destructed when an exception happens, in the reverse order they were constructed.