Detect that std::shared_ptr is holding a raw array (and obtaining its size)

Question

I'm working on (yet another) C++ serialization library that supports standard types such as containers. In particular I want to support smart pointers.

C++17 introduced support for std::shared_ptr holding raw arrays (it knows to invoke delete [] in such cases). I need to detect that the shared_ptr is holding a raw array so that I can serialize it accordingly:

template <typename T>
void serialize(Writer& writer, const std::shared_ptr<T> ptr)
{
    // Writer has overloaded operator()

    if (ptr)
    {
        if (holdsRawArray(ptr)) // How to implement this???
        {
            auto arrayWriter = writer.array(); // RAII
            auto size = rawArraySize(ptr); // How to get this???
            for (std::size_t i=0; i<size; ++i) 
                arrayWriter(ptr[i]);
        }
        else
            writer(*ptr);
    }
    else
        writer(null);
}

How do I determine that a C++17 smart pointer contains a raw array? This information is erased in the element_type member typedef (via std::remove_extent_t). I also can't find anything in the smart pointer API that would reveal the size of the raw array.

I thought about using the detector idiom on operator[] and operator*, but it appears implementations are not required to undefine them if T is or isn't a raw array.

Is what I'm attempting even possible? I'm hoping I missed something, or that there's some trick I could use.

I know I can force users to use std::shared_ptr<std::array<N,T>> or std::shared_ptr<std::vector<T>> instead, but I just want to check if it's even possible for me to support smart pointers holding raw arrays.

Answer 1

You can determine if shared_ptr holds an array type by checking if T is an array type using compile-time type traits. It is even implemented in std.

if constexpr (std::is_array_v<T>)

But there is no way to get the size because it is allocated dynamically and not stored anywhere.

Answer 2

As commented by Jarod42, I can have access to the raw array size if std::shared_ptr<T[N]> is used (but not std::shared_ptr<T[]>).

I can therefore add a serialize overload to obtain the size N via template parameters, and at the same time know that the shared_ptr is holding an array.

#include <iostream>
#include <memory>
#include <string>
#include <type_traits>

struct Writer // Toy example
{
    template <typename T>
    void operator()(const T& v) {std::cout << v << ", ";}
};

struct ArrayWriter  // Toy example
{
    ArrayWriter() {std::cout << "[";}
    ~ArrayWriter() noexcept {std::cout << "], ";}

    template <typename T>
    void operator()(const T& v) {std::cout << v << ", ";}
};

// "Regular" shared_ptr
template <typename T>
void serialize(Writer& writer, const std::shared_ptr<T> ptr)
{
    static_assert(!std::is_array_v<T>,
                  "shared_ptr<T[]> not supported: size unknowable");
    if (ptr)
        writer(*ptr);
    else
        writer("null");
}

// shared_ptr holding an array of known size
template <typename T, std::size_t N>
void serialize(Writer& writer, const std::shared_ptr<T[N]> ptr)
{
    if (ptr)
    {
        ArrayWriter arrayWriter;
        static constexpr auto size = N;
        for (std::size_t i=0; i<size; ++i) 
            arrayWriter(ptr[i]);
    }
    else
        writer("null");
}

int main()
{
    Writer writer;
    std::shared_ptr<std::string> s{new std::string{"Hello"}};
    std::shared_ptr<int[3]> n{new int[3]}; // Error prone!
    std::shared_ptr<float[]> x{new float[5]}; // Size lost
    n[0] = 1; n[1] = 2; n[2] = 3;
    serialize(writer, s); // Outputs Hello,
    serialize(writer, n); // Outputs [1, 2, 3, ],
    // serialize(writer, x); // static assertion failure

    return 0;
}

Working example: https://onlinegdb.com/r1R5jv0wI

sparik is still correct in his answer about not being able to know the size when given a shared_ptr<T> out of the blue (I should have worded my question better).

David Schwartz has pointed out in comments that the user may fail to initialize the array elements correctly (or use the wrong dynamic size) and my serializer would have no way of knowing. Even if smart pointers containing raw dynamic arrays can work in my case, it might not be a good idea to support them.

Thanks everyone for your comments and answers!

---

Addendum

According to this answer, unique_ptr<T[N]> is ill-formed, and indeed doesn't work for me in GCC.

I found P0674R1 (Extending make_shared to Support Arrays) and it provides several examples of shared_ptr<T[N]>, so it appears to be legal assuming that the committee didn't disallow it when it was adopted.

It's a bit annoying that unique_ptr and shared_ptr don't behave the same way in that respect.