Make_shared in C++

Writing effective and reliable code in C++ requires careful consideration of memory management issues. One of the most helpful tools for memory management provided by the standard library is the make_shared function. In this blog post, we will examine the make_shared function, its syntax, and how it can simplify memory allocation and deallocation in C++ programs. In order to demonstrate its application and advantages, we will also provide code samples and results.

The <memory> header of the C++ standard library contains the make_shared function. This useful factory method combines creating an object and allocating memory into one simple process. You can generate shared pointers to objects while avoiding explicit dynamic memory management by using make_shared.

Syntax

Use of make_shared has the following syntax:

#include <memory>
std::shared_ptr<T>ptr = std::make_shared<T>(args);

Here, T stands for the type of object that wants to create, &args are, if any, any constructor parameters. The make_shared function creates the object of type T in the memory that was dynamically allocated for it.

Benefits of Make_shared function

There are various benefits to using make_shared over conventional dynamic memory allocation & explicit construction:

Efficiency: make_shared allocates memory for the shared pointer management control block and the object in the same memory block. Compared to individual allocations made by new and shared_ptr generation, this lowers memory overhead and enhances performance.
Strong exception safety is provided by make_shared by providing proper cleanup in the event that an exception is thrown when creating the object. Memory leaks are avoided via the automated release of the object's allocated memory in the event of an exception.
Increased readability: make_shared produces simpler, easier-to-read code by integrating allocation and construction. Resource leaks are less likely since separate new and shared_ptr statements are no longer necessary.
Reduced overhead and memory fragmentation: By creating a single block for the object and the control block, make_shared optimizes memory use. As opposed to individual memory allocations, it minimizes memory fragmentation. Make_shared boosts efficiency and enables more effective memory usage by reducing overhead, especially when working with a lot of little objects.
Shared ownership and circular references: In situations where circular references are present, utilizing make_shared is even more advantageous. When two or more objects share pointers with one another, it is referred to as a circular reference. All connected shared pointers have the same control block since make_shared allocates memory for the object and the control block in the same block. Circular references no longer pose a memory leak risk, and correct deallocation is ensured when all shared pointers are deleted.

Example:

Let's look at a straightforward example to show how to use and output of make_shared:

#include <iostream>
#include <memory>

class MyClass {
public:
MyClass(int value): data(value) {
std::cout<< "Constructor called with value: " << data <<std::endl;
}

~MyClass() {
std::cout<< "Destructor called with value: " << data <<std::endl;
}

private:
int data;
};

int main () {
std::shared_ptr<MyClass>ptr = std::make_shared<MyClass>(42);
std::cout<< "Shared pointer created!" <<std::endl;

return 0;
}

Output:

Constructor called with value: 42
Shared pointer created!
Destructor called with value: 42

Explanation:

This code creates a straightforward class called MyClass with a constructor and destructor. We use make_shared to establish a shared pointer ptr in the main function and give its constructor the number 42. The result shows that when an object is formed, the constructor is called, the shared pointer is successfully constructed, and the destructor is called when the shared pointer is no longer used.

Conclusion:

In C++, the make_shared function is a potent memory management technique. The process of allocating memory for an object and building it is made simpler, and the code is cleaner and easier to read. It also offers efficiency and a strong exception against memory leaks.

In this blog, we talked about the C++ make_shared function. We discussed its merits, usage, and syntax. Make_shared boosts productivity, exception safety, and code readability by integrating memory allocation and object construction into a single operation.

Whenever you need to generate shared pointers to objects, use make_shared. Your memory management responsibilities can be substantially streamlined by using it, improving the sturdiness and maintainability of your code.

Next TopicRethrowing an Exception in C++

← prev next →