What replaced std::auto_ptr in C++?

In C++, std::auto_ptr has been replaced by:

• std::unique_ptr
• std::shared_ptr
• std::weak_ptr

Reasons for replacing std::auto_ptr:

• Non-standard behavior during copying: copying std::auto_ptr transferred ownership, leaving the original pointer null. This led to unpredictable behavior and errors.
• Incompatibility with standard library containers (e.g., std::vector) due to its ownership semantics during copying.
• Lack of support for arrays.

Characteristics of new smart pointers:

Smart Pointer	Ownership	Copy/Move	Purpose
std::unique_ptr	Exclusive	Move only	Unique ownership of a resource.
std::shared_ptr	Shared (divided)	Copy allowed	Sharing ownership of a resource among multiple pointers.
std::weak_ptr	Does not own	Copy allowed	Preventing cyclic references when using std::shared_ptr.

Example of using std::unique_ptr (replacement for std::auto_ptr):

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created\n"; }
    ~MyClass() { std::cout << "MyClass destroyed\n"; }
};

int main() {
    // Instead of: std::auto_ptr<MyClass> ptr1(new MyClass);
    std::unique_ptr<MyClass> ptr1(new MyClass);

    // Transfer ownership
    std::unique_ptr<MyClass> ptr2 = std::move(ptr1);

    if (!ptr1) {
        std::cout << "ptr1 is now empty after move\n";
    }

    return 0;
}

Example of using std::shared_ptr:

#include <memory>
#include <iostream>

class AnotherClass {
public:
    AnotherClass() { std::cout << "AnotherClass created\n"; }
    ~AnotherClass() { std::cout << "AnotherClass destroyed\n"; }
};

int main() {
    std::shared_ptr<AnotherClass> shared_ptr1(new AnotherClass);
    std::cout << "Use count: " << shared_ptr1.use_count() << std::endl;

    std::shared_ptr<AnotherClass> shared_ptr2 = shared_ptr1; // Shared ownership
    std::cout << "Use count: " << shared_ptr1.use_count() << std::endl;

    // The object AnotherClass will be destroyed when shared_ptr1 and shared_ptr2 go out of scope.
    return 0;
}

Using these smart pointers makes memory management in C++ safer and more predictable, avoiding issues inherent in std::auto_ptr.