DYNAMIC OBJECTS: New and Delete operators

Dynamic Memory Allocation in C++ with OOP: new and delete Operators

Understanding the Need for Dynamic Memory:

• In C++, static memory allocation (on the stack) is suitable for objects whose size is known at compile time and lifespan is limited to the function scope.
• For objects whose size or lifetime cannot be determined until runtime, dynamic memory allocation (on the heap) using new and delete operators is crucial.
• Dynamic memory enables flexible object creation and destruction, often employed in data structures, linked lists, trees, etc.

The new Operator:

• Allocates memory for an object of a specific type on the heap.
• Returns a pointer to the newly allocated memory.
• Can be used to create single objects (new ObjectType) or arrays (new ObjectType[size]).
• Syntax:

C++

pointer_variable = new ObjectType(arguments); // Single object
pointer_variable = new ObjectType[size](arguments); // Array

Use code with caution.

Example:

C++

#include <iostream>

class Point {
public:
    int x, y;
    Point(int x, int y) : x(x), y(y) {}
    ~Point() { std::cout << "Point destroyed" << std::endl; } // Destructor
};

int main() {
    Point* p1 = new Point(10, 20);
    std::cout << p1->x << ", " << p1->y << std::endl; // Access object members

    Point* p2 = new Point[3]; // Array of 3 Points
    p2[0] = Point(5, 15);
    p2[1] = Point(2, 8);
    p2[2] = Point(7, 12);

    // ... use p1 and p2 ...

    delete p1; // Deallocate single object
    delete[] p2; // Deallocate array

    return 0;
}

Use code with caution.

The delete Operator:

• Deallocates memory previously allocated using new.
• Must be used with the same pointer that was returned by new to avoid memory leaks.
• Syntax:

C++

delete pointer_variable; // Single object
delete[] pointer_variable; // Array

Use code with caution.

Important Considerations:

• Mismatches between new and delete types lead to memory leaks or undefined behavior.
• Always deallocate memory using delete when it's no longer needed to prevent leaks.
• Consider using smart pointers (e.g., unique_ptr, shared_ptr) to manage memory automatically and reduce the risk of leaks.
• For arrays, use delete[] to free the entire block of memory allocated with new[].
• Be mindful of memory management practices for larger, complex applications to avoid memory issues.

Additional Tips:

• Use new with parentheses to avoid potential ambiguities with function calls.
• Understand the differences between new and malloc (C function) for safer memory management.
• Employ smart pointers where appropriate to improve memory safety and reduce the burden of manual deallocation.
• Follow best practices for memory management to ensure efficient and reliable C++ programs.