How Can I Tell If An Object Is Created With ‘New’ In C++?

In C++, it can be useful to determine whether an object was created with the new operator, indicating that it is dynamically allocated on the heap, or if it was created as a stack-allocated object. This information can help you manage memory and avoid issues like double-deletion or memory leaks. However, C++ itself doesn’t provide a built-in mechanism to directly check whether an object was created with new. Nevertheless, you can adopt some strategies to track object creation.

Here are a few methods to determine how an object was created:

1. Use a Wrapper Class or Smart Pointer: Instead of using raw pointers for dynamically allocated objects, consider using smart pointers like std::shared_ptr or std::unique_ptr. These smart pointers store the ownership information and allow you to differentiate between stack and heap objects. You can use std::shared_ptr‘s reference counting or create a wrapper class that stores this information.
2. Add a Member Variable: In your class, you can add a member variable that indicates whether the object was created with new or not. This approach requires you to set this flag explicitly in the constructor, and it may not be foolproof if you forget to set it correctly.
3. Custom Memory Management: You can create your own memory management functions that wrap new and delete. In these functions, you can log or track the object’s creation and destruction. This approach gives you more control over object creation and destruction, but it can be complex.

Here’s an example of adding a member variable to track object creation:

cppCopy codeclass MyObject {
public:
    MyObject(bool isDynamic) : isDynamic(isDynamic) {}

    void printCreationType() {
        if (isDynamic) {
            std::cout << "Created with 'new' (dynamically allocated)" << std::endl;
        } else {
            std::cout << "Created on the stack" << std::endl;
        }
    }

private:
    bool isDynamic;
};

int main() {
    MyObject stackObj(false);
    MyObject* dynamicObj = new MyObject(true);

    stackObj.printCreationType();    // Outputs: Created on the stack
    dynamicObj->printCreationType(); // Outputs: Created with 'new' (dynamically allocated)

    delete dynamicObj; // Don't forget to delete dynamically allocated objects

    return 0;
}

Remember that explicitly tracking how objects are created can be error-prone and may introduce additional maintenance overhead. Using smart pointers and proper memory management practices are generally safer and more efficient ways to handle object creation and memory management.