C++ slicing and virtual destructors

Question

I get a vector of raw pointers, which I copy. The ownership of the objects pointed by these pointers belong to some other module. I have to replace some of the pointers with new ones which point to newly created objects. So in the end I will have a vector with pointers on which I need to call delete and others on which I do not. My idea was to introduce new classes which make this automatic.

template <typename T, class = std::enable_if_t<std::is_pointer<T>::value>>
class Pointer {
public:
    Pointer(T p) : pointer_(p) {}
    virtual ~Pointer() = default;

    T operator->()  { return pointer_; }

protected:
    T pointer_;
};

template <typename T>
class NotOwnedPointer : public Pointer<T> {
public:
    NotOwnedPointer(T p) : Pointer<T>(p) {}
    ~NotOwnedPointer() { std::cout << "not owned\n"; }
};

template <typename T>
class OwnedPointer : public Pointer<T> {
public:
    OwnedPointer(T p) : Pointer<T>(p) {}
    ~OwnedPointer() { std::cout << "owned\n"; delete this->pointer_; this->pointer_ = nullptr; }
    OwnedPointer(const OwnedPointer&) = delete;
    OwnedPointer& operator=(const OwnedPointer& other) = delete;
};

struct Foo {
    int i;
};

int main() {
    Foo* foo = new Foo{42};
    std::vector<Pointer<Foo*>> v;
    v.push_back(NotOwnedPointer(foo));
    v.push_back(OwnedPointer(foo));
}

Note that I use Pointer for the vector type instead of Pointer*. This way slicing will happen when I add a derived class instance to the vector.

Which destructors will be called when the vector is destructed? Since the type of the vector is Pointer I would say that the virtual table for class Pointer will be used and ~Pointer() will be called, but when I run the program it prints the text from ~NotOwnedPointer() and ~OwnedPointer().

Answer 1

v.push_back(NotOwnedPointer(foo));
v.push_back(OwnedPointer(foo));

These two lines create temporary objects (of type NotOwnedPointer and OwnedPointer, respectively), which are then sliced and copied into the vector.

When the temporary objects are destroyed, their destructors are called (~NotOwnedPointer() and ~OwnedPointer(), respectively). This has nothing to do with v, which is destroyed later.