Benefits of Using Smart Pointers and References

There are several benefits of using smart pointers and references in C++. Let’s look at a few in this chapter, before we segue into the more practical side of this course.

Smart pointer benefits

Smart pointers enable developers to write more expressive, cleaner, and maintainable code. This significantly reduces the potential for technical debt or human errors.

By offering automatic deallocation, smart pointers not only decrease the chances of invalid memory access and memory leaks, but also enable developers to utilize their time more productively.

Smart pointers also enhance exception safety. When an exception is thrown, they ensure that resources are automatically cleaned up without the need for manual intervention.

main


              12345678910111213141516171819202122232425
            
#include <iostream>
#include <memory>

void processResource() {
    // simulate resource allocation with a smart pointer
    std::shared_ptr<int> smartPtr(new int(42));
    // suppose an exception occurs during processing
    throw std::runtime_error("An exception occurred during resource processing");
}

int main() 
{
    try {
        processResource();
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }

    // at this point, you don't need to manually release the resource that the smart pointer held.
    // the smart pointer will automatically clean up the resource when it goes out of scope.

    std::cout << "Program still continues after exception handling" << std::endl;

    // the smart pointer ensures that the resource is safely deallocated, even in the presence of exceptions.
}

In the above code, we encounter an exception while processing a resource that was allocated using a shared pointer. Since a shared pointer is exception-safe, it automatically deallocates the resource, despite the exception. Read the code comments for more clarity.

Remember

Smart pointers can optimize performance by offering a more efficient mode of memory allocation and deallocation.

References benefits

References can also improve the readability and expressiveness of your code. When used with clear naming conventions, they make your code self-documenting. Consider the following function:

Example


              12345678
            
void calculateTotalPrice(const std::vector<double>& prices, double& total)
{
    // calculate the total price of items
    total = 0.0; //initialize the total
    for (double price : prices) { // iterate over the vector 
        total += price;  // calculate the total price
    }
}

Just by looking at the function definition, it’s immediately evident that the variable “total” will be modified and used to communicate the total price to the caller.

References are also relatively safer to use than pointers, because they can’t be set to null at initialization. When used judiciously, references can help developers write prevent runtime errors and crashes.
References allow you to modify the values of the original variable, which leads to more compact and efficient code. For example, when iterating over the elements of a collection, you can use a reference to directly update elements instead of working with indices.

In the above code, we use references to iterate over a vector, instead of indices.

Everything was clear?

Thanks for your feedback!

Section 1. Chapter 5