Question

From what I know smart pointer should be equilvalent to “raw” pointer with the difference that it is safe. Ok, but if I have regular pointer:

int* p = new int[10];
fill(p, p + 10, 0);//this will work for regular pointer but not for smart one.  

Same with hand written loop:

for(int i = 0; i < 10; ++i)
{
*p[i] = 0;
}

This is not possible (I think) for smart poiner. So the question is, how can I initialized array to which pointer I have stored in one of smart pointers (let’s assume shared_ptr)?

Answer 1

First off, it might be easier just to use std::vector<int>. If your array has an unchanging size, though, then perhaps std::vector<int> is indeed better replaced with a smart pointer.

With that out of the way, your first choice should be a std::unique_ptr, specifically the array specialization: std::unique_ptr<int[]>. (If you don’t, the smart pointer will use delete instead of delete[] on your pointer, leading to undefined behavior.) Your code would become:

std::unique_ptr<int[]> p(new int[10]);
std::fill(p.get(), p.get() + 10, 0);

As you can see, smart pointers have a get() method that returns the underlying pointer.

From here, if you need to use a std::shared_ptr, things become a big dangerous (do to unfortunate oversight, as far as I know). That oversight is that std::shared_ptr has no array specialization:

{
    std::shared_ptr<int> x(new int[10]);
} // oops! calls delete x.get(); instead of delete [] x.get(); ... UB!

However, std::shared_ptr can easily correct this like so:

{
    std::shared_ptr<int> x(new int[10], std::default_delete<int[]>());
} // correctly uses delete [] x.get()

From this point, the code is the same:

std::shared_ptr<int> p(new int[10], std::default_delete<int[]>());
std::fill(p.get(), p.get() + 10, 0);

---

Note that std::shared_ptr provides a constructor to construct from a std::unique_ptr, which properly uses the deleter. So this is safe:

std::unique_ptr<int[]> p(new int[10]);
std::shared_ptr<int> p2(std::move(p)); // okay, uses std::default_delete<int[]>()