std::vector of pointers with the rule of three I have a class that has a std::vector of pointers, I'm NOT going to give any of those pointers to objects outside of it, I mean, I'm not going to share the pointers. - I was reading that isn't everywhere that we will use smart pointers and that raw pointer isn't useless as long that someone is responsible for deleting it. The problem with that class is that it can be inherited and if I don't use the rule of three all the classes that inherits from will have a copy of the vector with the pointers then the destructor of those objects will result in double delete. - Is it safe or I still need to use std::shared_ptr in this case?

class Keeper
{
public:
    Keeper() {}
    Keeper(const Keeper&amp;) = delete;
    Keeper&amp; operator=(const Keeper&amp;) = delete;

    virtual ~Keeper()
    {
        for (int i = 0; i &lt; pointers.size(); ++i)
        {
            delete pointers[i];
        }
    }

    void push_back(Pointer * pointer)
    {
        pointers.push_back(pointer);
    }

    // erase method...
protected:
    std::vector&lt;Pointer *&gt; pointers;
};
Is it safe? To a point.
Naming
I hope the name Pointer is just for illustration purposes as otherwise that is a pretty terrible name.
The changes I would make are:
Accepting pointers must indicate ownership.
Your current interface does not indicate that it is taking ownership of the pointers. So as a user of your class I need to dig inside and find out if you are taking ownership or not before I can use it.
void push_back(Pointer * pointer);

I would change the interface to specifically take a unique_ptr that way people know that you are taking ownership of the object.
void push_back(std::unqiue_ptr&lt;Pointer&gt; pointer);

No confusion here.
Storage of pointers.
I have no problem with you storing a vector of pointers or a vector of smart pointer. Either makes sense. As long as you define the Copy Constructor/ Assignment Operator and Destrtuctor if you use pointer (like you have). You could argue that keeping an array of smart pointers will save you some work in coding (tiny (probably insignificant cost1  of managing the data). Alternatively you can use a container specifically designed to hold pointers.
 std::vector&lt;Pointer*&gt;                 data;  // Add Rule of Three.
 std::vector&lt;std::unique_ptr&lt;Pointer&gt;&gt; data;  //
 boost::ptr_vector&lt;Pointer&gt;            data;  // Takes ownership of pointers.
                                              // Only exposes members as references
                                              // to actual object (not pointer) and thus
                                              // makes using it with standard algorithms
                                              // much easier and intuitive.

To Clarify because of comments: I suspect for most compilers the cost of std::unique_ptr will be zero at runtime. But it is something worth validating with your compiler before assuming.
Access from derived types.
Personally I would not give direct access to the vector from derived class like that.
protected:
      std::vector&lt;Pointer *&gt; pointers;

Even if you have a vector of unique_ptr it is still to easy for the derived class to break encapsulation and do something you don't intend. You should provide them with a safer interface. How you do that depends.
If you know none of the members will be NULL then I would provide them with a function that returns a reference.
 protected:
       // Anybody that wants to access the data gets a reference.
       Pointer&amp;    data(std::size_t index) {return *pointers[index];}

       // Note: the above code just uses the original code as a base line.
       //       If you change the storage medium I would probably still
       //       provide this as an interface layer so that I don't
       //       break encapsulation.
       //
       //       Of course there are a lot of caviats that depend on how
       //       this will be used. But without further context this is
       //       the best I can do at the moment.


 private:
       std::vector&lt;Pointer*&gt; pointers;

If you want derived classes to modify the class you may need to think of something else. But you have not provided enough context for me to go further.
Iterator
Based on comments just showing how easy it would be to throw an iterator together that can be used without exposing implementations details. Note: this one is not complete but shows enough of how it would work (and I was slightly bored at the time and wanted to write some code).
class MyIterator
{
    Keeper* parent;
    int     index
    public:
        MyIterator(Keeper&amp; parent, int index)
           : parent(&amp;parent)
           , index(index)
        {}
        MyIterator&amp; operator++()
        {
            ++index;
            return *this;
        }
        MyIterator operator++(int)
        {
            MyIterator result(*this);
            ++(*this);
            return result;
        }
        Pointer&amp; operator*()
        {
            return parent-&gt;data(index);
        }
}