Inheriting from std::auto_ptr to support deletion of allocated arrays in C++98/C++03

Question

[EDIT: Thanks for your opinions. I think this topic is discussed enough. Since std::auto_ptr is removed from C++17, I decided to drop the idea of inheriting from std::auto_ptr to avoid compatibility problems in the future.]

I know that std::auto_ptr is not a perfect class for automatic memory management because it doesn't support the deletion of arrays. However, I decided to create a better templated class (called owner_ptr) which supports this by inheriting from std::auto_ptr. It seems to be dangerous, but I think I've found a safe way to do this. Some advantages why I thought it was a good idea to inherit:

• I don't have to reimplement all functions of std::auto_ptr.
• I can use the std::auto_ptr_ref feature to pass temporary owner_ptr objects by value (and pass ownership to the copy).
• I know that I won't access owner_ptr objects through base class pointer, so the absence of virtual ~auto_ptr() cannot cause problem.

(Here you can find the implementation of std::auto_ptr.)

I've created some test cases (see below) and the result was promising. I want to use the new class in my own project (just a project for myself). But I'm not sure, if there are any scenarios where it can fail. I would be grateful if you could take a look at my implementation and share your ideas/opinions about it. (E.g. if there is a function which I should override too or if it is a bad practice to do this in C++98/C++03.)

#include <memory>
#include <cstddef>
#include <iostream>

template <typename T>
class owner_ptr : public std::auto_ptr<T>
{
public:
    explicit owner_ptr(T* p = NULL) : std::auto_ptr<T>(p) { std::cout << "owner_ptr<T>(T*) called." << std::endl; }
    owner_ptr(owner_ptr<T>& rhs) : std::auto_ptr<T>(rhs.release()) { std::cout << "owner_ptr<T>(owner_ptr<T>&) called." << std::endl; }
    owner_ptr(std::auto_ptr_ref<T> rhs) : std::auto_ptr<T>(rhs) { std::cout << "owner_ptr<T>(auto_ptr_ref<T>) called." << std::endl; }
};

/* "specialization" for arrays */
template <typename T>
class owner_ptr<T[]> : public std::auto_ptr<T>
{
public:
    explicit owner_ptr(T* p = NULL) : std::auto_ptr<T>(p) { std::cout << "owner_ptr<T[]>(T*) called." << std::endl; }
    owner_ptr(owner_ptr<T[]>& rhs) : std::auto_ptr<T>(rhs.release()) { std::cout << "owner_ptr<T[]>(owner_ptr<T[]>) called." << std::endl; }
    owner_ptr(std::auto_ptr_ref<T> rhs) : std::auto_ptr<T>(rhs) { std::cout << "owner_ptr<T[]>(auto_ptr_ref<T>) called." << std::endl; }

    void reset(T* ptr = NULL)
    {
        std::cout << "owner_ptr<T[]>::reset(T*) called." << std::endl;
        if (std::auto_ptr<T>::get() != ptr)
        {
            this->~owner_ptr();
            std::auto_ptr<T>::reset(ptr);
        }
    }

    ~owner_ptr()
    {
        std::cout << "owner_ptr<T[]>::~owner_ptr() called." << std::endl;
        delete[] std::auto_ptr<T>::release();
    }
};

I tried to test it as well as it was possible (sorry for the long code):

class A
{
public:
    A() { std::cout << "A() called." << std::endl; }
    virtual ~A() { std::cout << "~A() called." << std::endl; }
};

class B : public A
{
public:
    B() { std::cout << "B() called." << std::endl; }
    ~B() { std::cout << "~B() called." << std::endl; }
};

void printTest()
{
    static int test = 0;
    std::cout << std::endl << "Test " << ++test << ":" << std::endl;
}

template <typename T>
void testFunction(owner_ptr<T> param)
{
    std::cout << "testFunction<T>() called." << std::endl;
    owner_ptr<T> op = param;
}

template <typename T>
void testFunction(owner_ptr<T[]> param)
{
    std::cout << "testFunction<T[]>() called." << std::endl;
    owner_ptr<T[]> op = param;
}

int main()
{
    std::cout << "Testing owner_ptr<A>" << std::endl;
    /* Test 1 */
    /* Constructing with NULL-pointer */
    printTest();
    owner_ptr<A>();

    /* Test 2 */
    /* Constructing with valid pointer */
    printTest();
    owner_ptr<A>(new A);

    /* Test 3 */
    /* Testing "copy"-constructor */
    printTest();
    {
        owner_ptr<A> op1(new A);
        owner_ptr<A> op2(op1);
        std::cout << "op1.get() result : " << op1.get() << std::endl;
    }

    /* Test 4 */
    /* Testing owner_ptr<T>::operator= */
    printTest();
    {
        owner_ptr<A> op1(new A);
        owner_ptr<A> op2;
        op2 = op1;
        std::cout << "op1.get() result : " << op1.get() << std::endl;
    }

    /* Test 5 */
    /* Passing owner_ptr<A> object by value */
    printTest();
    {
        owner_ptr<A> op(new A);
        testFunction(op);
    }

    /* Test 6 */
    /* Constructing owner_ptr<A> with a temporary owner_ptr<A> object. */
    /* = passing temporary object by non-const reference */
    printTest();
    {
        owner_ptr<A>(owner_ptr<A>(new A));
    }
    /* Explicit constructor : owner_ptr<A>::owner_ptr<A>(A*) */
    /* Implicit conversion : owner_ptr<A>::operator std::auto_ptr_ref<A>() (inherited from std::auto_ptr<A>) */
    /* (Explicit) constructor : auto_ptr_ref<A>::auto_ptr_ref<A>(A*) */
    /* Implicit constructor : owner_ptr<A>::owner_ptr<A>(std::auto_ptr_ref<A>) */

    /* Test 7 */
    /* Passing a temporary owner_ptr<A> object by value */
    printTest();
    {
        testFunction(owner_ptr<A>(new A));
    }


    std::cout << std::endl << "Testing owner_ptr<A[]>" << std::endl;
    /* Test 8 */
    /* Constructing with NULL-pointer */
    printTest();
    owner_ptr<A[]>();

    /* Test 9 */
    /* Constructing with valid pointer */
    printTest();
    owner_ptr<A[]>(new A[3]);

    /* Test 10 */
    /* Testing "copy"-constructor */
    printTest();
    {
        owner_ptr<A[]> op1(new A[3]);
        owner_ptr<A[]> op2(op1);
        std::cout << "op1.get() result : " << op1.get() << std::endl;
    }

    /* Test 11 */
    /* Testing owner_ptr<A[]>::operator= */
    printTest();
    {
        owner_ptr<A[]> op1(new A[3]);
        owner_ptr<A[]> op2;
        op2 = op1;
        std::cout << "op1.get() result : " << op1.get() << std::endl;
    }

    /* Test 12 */
    /* Passing owner_ptr<A[]> object by value */
    printTest();
    {
        owner_ptr<A[]> op(new A[3]);
        testFunction(op);
    }

    /* Test 13 */
    /* Constructing owner_ptr<A[]> with a temporary owner_ptr<A[]> object */
    /* = passing temporary object by non-const reference */
    printTest();
    {
        owner_ptr<A[]>(owner_ptr<A[]>(new A[3]));
    }

    /* Test 14 */
    /* Passing a temporary owner_ptr<A[]> by value */
    printTest();
    {
        testFunction(owner_ptr<A[]>(new A[3]));
    }

    /* Test 15 */
    /* Testing owner_ptr<A[]>::reset */
    printTest();
    {
        owner_ptr<A[]>(new A[3]).reset(new A[2]);
    }

    /* Test 16 */
    printTest();
    {
        owner_ptr<A> op(new B);
    }

    /* Testing compilation of owner_ptr<A> = owner_ptr<A[]> */
    /* Result: compilation error */
    /*
    {
        owner_ptr<A> op1;
        owner_ptr<A[]> op2(new A[3]);
        op1 = op2;
        Result: compiler error.
    }
    */

    /* std::vector< owner_ptr<A> > container;
       container.push_back(owner_ptr<A>(new B));
       Won't compile due to missing
       owner_ptr<A>(const owner_ptr<A>&) constructor.
       R.I.P. */

    return 0;
}

The result was the following:

Testing owner_ptr<A>

Test 1:
owner_ptr<T>(T*) called.

Test 2:
A() called.
owner_ptr<T>(T*) called.
~A() called.

Test 3:
A() called.
owner_ptr<T>(T*) called.
owner_ptr<T>(owner_ptr<T>&) called.
op1.get() result : 0
~A() called.

Test 4:
A() called.
owner_ptr<T>(T*) called.
owner_ptr<T>(T*) called.
op1.get() result : 0
~A() called.

Test 5:
A() called.
owner_ptr<T>(T*) called.
owner_ptr<T>(owner_ptr<T>&) called.
testFunction<T>() called.
owner_ptr<T>(owner_ptr<T>&) called.
~A() called.

Test 6:
A() called.
owner_ptr<T>(T*) called.
owner_ptr<T>(auto_ptr_ref<T>) called.
~A() called.

Test 7:
A() called.
owner_ptr<T>(T*) called.
owner_ptr<T>(auto_ptr_ref<T>) called.
testFunction<T>() called.
owner_ptr<T>(owner_ptr<T>&) called.
~A() called.

Testing owner_ptr<A[]>

Test 8:
owner_ptr<T[]>(T*) called.
owner_ptr<T[]>::~owner_ptr() called.

Test 9:
A() called.
A() called.
A() called.
owner_ptr<T[]>(T*) called.
owner_ptr<T[]>::~owner_ptr() called.
~A() called.
~A() called.
~A() called.

Test 10:
A() called.
A() called.
A() called.
owner_ptr<T[]>(T*) called.
owner_ptr<T[]>(owner_ptr<T[]>) called.
op1.get() result : 0
owner_ptr<T[]>::~owner_ptr() called.
~A() called.
~A() called.
~A() called.
owner_ptr<T[]>::~owner_ptr() called.

Test 11:
A() called.
A() called.
A() called.
owner_ptr<T[]>(T*) called.
owner_ptr<T[]>(T*) called.
op1.get() result : 0
owner_ptr<T[]>::~owner_ptr() called.
~A() called.
~A() called.
~A() called.
owner_ptr<T[]>::~owner_ptr() called.

Test 12:
A() called.
A() called.
A() called.
owner_ptr<T[]>(T*) called.
owner_ptr<T[]>(owner_ptr<T[]>) called.
testFunction<T[]>() called.
owner_ptr<T[]>(owner_ptr<T[]>) called.
owner_ptr<T[]>::~owner_ptr() called.
~A() called.
~A() called.
~A() called.
owner_ptr<T[]>::~owner_ptr() called.
owner_ptr<T[]>::~owner_ptr() called.

Test 13:
A() called.
A() called.
A() called.
owner_ptr<T[]>(T*) called.
owner_ptr<T[]>(auto_ptr_ref<T>) called.
owner_ptr<T[]>::~owner_ptr() called.
~A() called.
~A() called.
~A() called.
owner_ptr<T[]>::~owner_ptr() called.

Test 14:
A() called.
A() called.
A() called.
owner_ptr<T[]>(T*) called.
owner_ptr<T[]>(auto_ptr_ref<T>) called.
testFunction<T[]>() called.
owner_ptr<T[]>(owner_ptr<T[]>) called.
owner_ptr<T[]>::~owner_ptr() called.
~A() called.
~A() called.
~A() called.
owner_ptr<T[]>::~owner_ptr() called.
owner_ptr<T[]>::~owner_ptr() called.

Test 15:
A() called.
A() called.
A() called.
A() called.
A() called.
owner_ptr<T[]>(T*) called.
owner_ptr<T[]>::reset(T*) called.
owner_ptr<T[]>::~owner_ptr() called.
~A() called.
~A() called.
~A() called.
owner_ptr<T[]>::~owner_ptr() called.
~A() called.
~A() called.

Test 16:
A() called.
B() called.
owner_ptr<T>(T*) called.
~B() called.
~A() called.

It seems to be working properly. I think, the only problem is that I cannot create a heterogeneous collection like std::vector< owner_ptr<A> > to store derived class instances. But it's not a real problem, because it can be easily solved by creating a similar class to std::shared_ptr which has a real copy constructor.

If you have any idea how can I make this templated class better, before I use it in my own project, please share it. I'm using C++03.

If you think, it is a totally bad idea to inherit from std::auto_ptr, please explain why.

Answer 1

Do not inherit c++ standard classes (unless these are designed for it¹)

If you think, it is a totally bad idea to inherit from std::auto_ptr, please explain why.

They (standard classes) usually aren't designed for inheritance in first place.

Here are some references why this is considered a bad idea:

• Subclass/inherit standard containers?
• Thou shalt not inherit from std::vector

The main problem is you cannot really change/extend the behavior of the originally exposed interface.

---

The better way to go is to encapsulate std::auto_ptr as a member, and override the behavior where it doesn't meet your needs (that's lacking of copy/move capabilities it seems).
I know that it's a bit tedious to just provide delegate functions where you don't want to change the original behavior, and tempting to achieve that via inheritance, but in the long term that's usually not what you want.

Beyond that you are able now to introduce copy/move semantics:

 template<typename T>
 class owner_ptr {
     std::auto_ptr<T> pointee;
 public:
     // Will behave like moving
     owner_ptr(const owner_ptr<T>& other) {
         // Brute force:
         T* p = const_cast<owner_ptr<T>&>(other).pointee.release();            
         pointee.reset(p);
     }
 };

Alexei Andrescou's Loki library provides you with a good set of policies you can choose for implementing the various variants of smart pointers. I found that an extremely useful resource for either understanding, and also realize production ready code with help of the library.

---

¹⁾ There are abstract classes in the C++ standard library like std::basic_ostream<T> or std::basic_streambuf. But these are rare cases.

Answer 2

Unexpected Consequences

The main issue I see with this is:

// Here is another unit test.
// The destructor should be called 15 times But it will only be
// called once on the first element.
void func(std::auto_ptr<int> a)
{
}

int main()
{
    owner_ptr<int[]>  data(new int[15]);
    func(data);
}

Because of the inheritance. This is going to copy the auto pointer to the parameter a and strip all vestiges of owner_ptr. Since it is a copy when a goes out of scope you will again leak.

Undefined Behavior

Here you have undefined behavior:

    if (std::auto_ptr<T>::get() != ptr)
    {
        this->~owner_ptr();              // If you call the destructor
                                         // The object no longer exists.
                                         // So any accesses to members is
                                         // UB.
        std::auto_ptr<T>::reset(ptr);
    }

If you call the destructor on an object you want to keep, you must call the constructor to make the object live again. You can do this with placement new.

         this->~owner_ptr();
         new (this) owner_ptr<T[]>(ptr);

BUT. This looks so ugly. Why not just add a method for deleting the data that is called by this method and the destructor.

Does not Provide Strong Exception Guarantee

Another problem here is if the type T is not trivial.

        this->~owner_ptr();
        std::auto_ptr<T>::reset(ptr);

What happens if an exception is throw (it can happen) during the destructor. They you are left with an object this that has a pointer to invalid data. Note: if a destructor throws during delete then reset() is never called.

To do this in an exception safe manor you must update the state of the current object to be consistent before doing any dangerous operations.

        T* tmp = release();    // get a copy locally (this is nothrow())
        auto_ptr::reset(ptr);  // put the new data into the object
                               // this is also safe as we just released
                               // the held pointer so no destructor will
                               // happen.

        // Your object is now safe (i.e. it is in a consistent good state).
        // It is safe to call the destructor on this object.

        delete [] tmp;

Answer 3

If you need automatic memory management for arrays, use std::vector.

Edit: I disagree with the vote-down. This is a code review. If someone in my department offered up the poster's approach combining arrays with smart pointers, I'd tell him/her to use std::unique_ptr<std::vector<T> >.