C ++ 17：unique_ptr之间的指针存储差异 <char[]> 和shared_ptr <char[]>

Question

I am getting confused with:

unique_ptr<char[]> u_ptr = make_unique<char[]>(10);
sprint(u_ptr.get(), 10, "milos"); // get returns char*
cout << u_ptr.get(); // get returns char*

And:

shared_ptr<char[]> s_ptr = make_shared<char[]>(10);
sprint(*s_ptr.get(), 10, "milos"); // get here returns char** ?
cout << *s_ptr.get(); // get here returns char** ?

So, while unique_ptr<char[]> returns char* for the underlying array, shared_ptr<char[]> seems to return char(*)[] pointer to array pointer? I made few tests and I could use shared_ptr<char> with default delete:

shared_ptr<char> s_ptr(new char[10], default_delete<char[]>());
sprint(s_ptr.get(), 10, "milos"); // get here returns char*, fine
cout << s_ptr.get(); // same here

But I'm guessing the idea behind C++17 is not the approach with shared_ptr<char> and custom specified deleter: default_delete<char[]> cause this was possible prior to C++17.

Can someone clarify correct usage, and why does following occurs:

unique_ptr<int> u = make_unique<int>(5);
auto iu = u.get(); // iu is typeof int*

at the same time

unique_ptr<int[]> ua = make_unique<int[]>(5);
auto iua = ua.get(); // iua is still typeof int* ?

While for shared_ptr:

shared_ptr<int> s = make_shared<int>(5);
auto is = s.get(); // is is typeof int*

but

shared_ptr<int[]> sa = make_shared<int[]>(5);
auto isa = sa.get(); // isa is typeof int** ???

.

Answer 1

std::unique_ptr has a specific specialisation for when T is an array type. This causes the correct default deleter to be selected.

For better or worse, std::shared_ptr does not (while std::make_shared does as of c++20).

The behaviour you see in shared_ptr , returning a T** as a result of calling get() is an anomaly which has been fixed in c++17 (it will now return T*).

This is because until c++17, std::shared_ptr::element_type was T and std::shared_ptr::get returned a T* .

As of c++17 element_type is defined to be std::remove_extent_t<T> and get() returns element_type* ;

so given using SAI = std::shared_ptr<int[]>

in c++14:

SAI::element_type = int[]

SAI::get() -> (int[])* which decays to int**

in c++17:

SAI::element_type = int

SAI::get() -> int*

Documentation links for reference:

https://en.cppreference.com/w/cpp/memory/unique_ptr https://en.cppreference.com/w/cpp/memory/shared_ptr

As far as I am aware, the way to create a shared array prior to c++17 would be something like this:

#include <memory>

int main()
{
    auto uai = std::make_unique<int[]>(10);
    std::shared_ptr<int> sai { uai.release(), uai.get_deleter() };
}

and after c++17:

#include <memory>

int main()
{
    std::shared_ptr<int[]> sai = std::make_unique<int[]>(10);
}