<h4>
Basic Concepts
</h4>
<p>
The primary operators for dynamic memory allocation are <b>new</b> and <b>delete</b>.  The new operator allocates memory from the heap:
</p>
<pre>
<code class="language-cpp line-numbers normalize-whitespace">
pointer_variable = new data_type;
</code>
</pre>
<p>
The delete operator deallocates memory previously allocated with new:
</p>
<pre>
<code class="language-cpp line-numbers normalize-whitespace">
delete pointer_variable;
</code>
</pre>
<p>
Example:
</p>
<pre>
  <code class="language-cpp line-numbers normalize-whitespace">
     // Allocate memory for an integer
     int* ptr = new int; 
     // Assign value to allocated memory
     *ptr = 42; 
     // Output the value
     std::cout &lt;&lt; *ptr &lt;&lt; std::endl; 
     // Deallocate memory
     delete ptr; 
     // Avoid dangling pointer
     ptr = nullptr; 
</code>
</pre>
<h4>
Dynamic Arrays
</h4>
<p>
When you need arrays with sizes that are not determined until runtime, you use dynamic memory allocation.
</p>
<pre>
  <code class="language-cpp line-numbers normalize-whitespace">
int size;
std::cout &lt;&lt; "Enter the size of the array: ";
std::cin >> size;

// Allocate memory for an array of integers
int* arr = new int[size]; 
for(int i = 0; i &lt; size; ++i) {
    // Assign values to array elements
    arr[i] = i * 10; 
}

for(int i = 0; i &lt; size; ++i) {
    // Output the values
    std::cout &lt;&lt; arr[i] &lt;&lt; " "; 
}
std::cout &lt;&lt; std::endl;

// Deallocate memory for the array
delete[] arr;
// Avoid dangling pointer 
arr = nullptr; 
</code>
</pre>

<h4>
Using std::unique_ptr
</h4>
<p>
Smart pointers provide a way to manage dynamically allocated memory automatically, reducing the risk of memory leaks. The std::unique_ptr is a smart pointer that owns an object exclusively and deallocates it when the std::unique_ptr goes out of scope.
</p>

<pre>
  <code class="language-cpp line-numbers normalize-whitespace">
#include &lt;iostream>
#include &lt;memory>

int main() {
    // Allocate memory and initialize
    std::unique_ptr&lt;int> ptr = std::make_unique&lt;int>(42); 
    // Output the value
    std::cout &lt;&lt; *ptr &lt;&lt; std::endl; 

    // Allocate memory for an array
    std::unique_ptr&lt;int[]> arr = std::make_unique&lt;int[]>(5); 
    for(int i = 0; i &lt; 5; ++i) {
        arr[i] = i * 10;
    }

    for(int i = 0; i &lt; 5; ++i) {
        std::cout &lt;&lt; arr[i] &lt;&lt; " ";
    }
    std::cout &lt;&lt; std::endl;

    // No need to explicitly delete; 
    // memory is automatically deallocated
    return 0;
}
</code>
</pre>
<h4>
Using std::shared_ptr
</h4>
<p>
The std::shared_ptr is a smart pointer that maintains reference counting to manage the lifetime of the object. It allows multiple std::shared_ptr instances to own the same object, and the object is deleted when the last std::shared_ptr goes out of scope.
</p>
<pre>
  <code class="language-cpp line-numbers normalize-whitespace">
#include &lt;iostream>
#include &lt;memory>

int main() {
    // Allocate memory and initialize
    std::shared_ptr<int> ptr1 = std::make_shared<int>(42); 
    {
        // Share ownership
        std::shared_ptr&lt;int> ptr2 = ptr1; 
        // Output the value
        std::cout &lt;&lt; *ptr2 &lt;&lt; std::endl; 
    } // ptr2 goes out of scope, 
      //but memory is not deallocated

    // ptr1 still owns the memory
    std::cout &lt;&lt; *ptr1 &lt;&lt; std::endl; 

    // Memory is deallocated when ptr1 goes out of scope
    return 0;
}
</code>
</pre>


Dynamic Memory Allocation in C++