DYNAMIC OBJECTS: Creating and Deleting

 Key Points:

• Dynamic Objects: Objects created during program execution using the new operator. They reside on the heap (free store) and have separate lifetimes from the code that manages them.
• new Operator: Allocates memory on the heap, returns a pointer to the newly allocated block, and initializes the object (if a constructor exists).
• delete Operator: Deallocates memory pointed to by a pointer, reclaiming it for future use. It's crucial to use delete on dynamic objects to avoid memory leaks.
• Pointers: Essential for managing dynamic objects, as they store the memory addresses of these objects.

Example:

C++

#include <iostream>

class Point {
public:
    int x, y;

    Point() : x(0), y(0) {} // Default constructor

    void setValues(int x, int y) {
        this->x = x;
        this->y = y;
    }

    void print() const {
        std::cout << "(" << x << ", " << y << ")" << std::endl;
    }

    ~Point() { // Destructor, called automatically when a Point object goes out of scope
        std::cout << "Point at (" << x << ", " << y << ") destroyed." << std::endl;
    }
};

int main() {
    // Create a dynamic Point object on the heap
    Point* p = new Point();

    // Access and modify its members
    p->setValues(3, 5);
    p->print();  // Output: (3, 5)

    // Call a member function
    p->doSomething(); // Assuming Point has a doSomething() method

    // Delete the object, freeing the allocated memory
    delete p;

    return 0;
}

Use code with caution.

Explanation:

1. Class Point: Encapsulates data (x, y) and behaviors (constructor, setValues, print, and potentially doSomething).
2. new Point(): Allocates memory for a Point object on the heap, initializes it using the default constructor (or a user-provided one), and returns a pointer (p) to it.
3. Pointer Access: Use -> to access members of dynamic objects pointed to by the pointer.
4. delete p;: Frees the memory pointed to by p, preventing memory leaks.
5. Destructor: Automatically called when a dynamic object goes out of scope, cleaning up resources (usually virtual destructors in inheritance hierarchies).

Best Practices:

• Initialize Dynamic Objects: Use constructors to ensure a well-defined state.
• Delete All Dynamic Objects: Ensure delete is called for each new to avoid leaks.
• Smart Pointers: Consider using smart pointers (like std::unique_ptr, std::shared_ptr) to manage pointer lifecycles automatically.
• Rule of Three/Five: Follow the Rule of Three/Five for destructors, copy constructors, and copy assignment operators when managing resources in classes.