Why did you remove the use of auto_ptr?

auto_ptr was removed from C++11 for several reasons:

Non-copyable, but with copy semantics: When assigning or copying auto_ptr, ownership was transferred. The original auto_ptr became invalid (set to nullptr). This violated the expected copy semantics in C++.
```
// Example of incorrect auto_ptr behavior
std::auto_ptr<int> ptr1(new int(10));
std::auto_ptr<int> ptr2 = ptr1; // ptr1 becomes nullptr
// Now ptr1 cannot be used!
```
Incompatible with STL containers: STL containers require elements to be copy-assignable, which was violated by the unique semantics of auto_ptr. Adding auto_ptr to a container could lead to unpredictable behavior.
Lack of support for arrays: auto_ptr could not correctly manage memory allocated for arrays (new T[]), which required delete[], not delete.
Unsafe to use in function parameters by value: Passing auto_ptr by value also transferred ownership, which could be unexpected and lead to memory leaks or double deletions.

In C++11 and later standards, safer and more flexible alternatives were introduced:

std::unique_ptr for exclusive ownership of a resource.
std::shared_ptr for shared ownership with reference counting.
std::weak_ptr for non-intrusive access to a resource managed by shared_ptr without increasing the reference count.

These new smart pointers address the issues of auto_ptr and provide safer and more idiomatic memory management in modern C++. auto_ptr was marked as deprecated in C++11 and removed in C++17.