这是Item28中“更有效的C ++”中的错误吗？

Question

I encountered a question when I was reading the item28 in More Effective C++ . In this item, the author shows to us that we can use member template in SmartPtr such that the SmartPtr<Cassette> can be converted to SmartPtr<MusicProduct> .
The following code is not the same as in the book, but has the same effect.

#include <iostream>

class Base {};
class Derived : public Base {};

template<typename T>
class smart {
public:
    smart(T* ptr)
        : ptr(ptr)
    {}

    template<typename U>
    operator smart<U>()
    {
        return smart<U>(ptr);
    }

    ~smart()
    {
        delete ptr;
    }
private:
    T* ptr;
};

void test(const smart<Base>& ) {}

int main()
{
    smart<Derived> sd(new Derived);
    test(sd);
    return 0;
}

It indeed can be compiled without compilation error. But when I ran the executable file, I got a core dump. I think that's because the member function of the conversion operator makes a temporary smart, which has a pointer to the same ptr in sd (its type is smart<Derived> ). So the delete directive operates twice. What's more, after calling test, we can never use sd any more, since ptr in sd has already been delete.
Now my questions are :

• Is my thought right? Or my code is not the same as the original code in the book?
• If my thought is right, is there any method to do this?

Thanks very much for your help.

Answer 1

Yes, you've described the problem with your code fairly accurately.

As far as how to make it work: just about like the usual when you run into problems from a shallow copy: do a deep copy instead. That is, instead of just creating another pointer to the same data, you'd need to clone the data, and have the second object point to the clone of the data instead of the original data.

Alternatively, use a reference counted pointer, and increment the reference count when you do a copy, and decrement it when a copy is destroyed. When the count reaches zero (and not before) delete the pointee data.

Generally speaking: avoid doing all of this. Assuming you're using a relatively up-to-date compiler, the standard library should already contain a shared_ptr and a unique_ptr that can handle a lot of your smart pointer needs.

Answer 2

Your interpretation is correct, the conversion operator will create a different object that holds a pointer to the same underlying object. Once it goes out of scope it will be destroyed, and it will in turn call delete .

Not sure I understand the last question, if what you ask is whether this can be useful or not, it can be useful if implemented correctly. For example, if instead of a raw pointer and manually allocating/deleting the memory you were using a std::shared_ptr then it would work just fine. In other cases there might not even be a dynamically allocated object... This is just a tool, use it where it makes sense.