std :: array与C-Style数组的连续内存

Question

This is an experimentation for interest only...

I'm trying to make a container which holds a fixed number of bytes (eg header) and a dynamic block of data (eg body) all in one contiguous memory block. In traditional C programming I would have char[0] as the last instance variable and I would over allocate sizeof(struct) + data_length .

This works in C++ but I want something nicer. So my question is does a std::array start with a pointer or can it be used in the same way as a native C-style array?

Here's some example code...

struct pkg_base
{
    virtual std::size_t get_body_size() = 0;
    virtual void *get_body_ptr() = 0;
};

template<typename _T, std::size_t _N>
struct pkg
    : public pkg_base
{
    std::uint16_t a;
    std::uint16_t b;
    std::uint16_t c;

    std::array<_T, _N> body{};

    std::size_t get_body_size() override
    {
        return ( body.size() );
    }

    virtual void *get_body_ptr() override
    {
        return ( body.data() );
    }
};

void _test_package()
{
    auto vec = std::vector<std::unique_ptr<pkg_base>>{};
    vec.push_back(std::make_unique<pkg<char, 1024>>());
    vec.push_back(std::make_unique<pkg<float, 1024>>());
    vec.push_back( std::make_unique<pkg<std::string, 1024>>() );

    auto const size = vec.front()->get_body_size();
    auto const *ptr = static_cast<char *>( vec.front()->get_body_ptr() );
}

Answer 1

So my question is does a std::array start with a pointer or can it be used in the same way as a native C-style array?

From the documentation

This container is an aggregate type with the same semantics as a struct holding a C-style array T[N] as its only non-static data member.

So there's no other data member in there, just the T[N] array you wanted.

You can trivially confirm this for yourself using sizeof or looking at the code.

As an aside, names beginning _[AZ] are reserved for the implementation, so you probably shouldn't be calling your template type parameters _T and _N .

Answer 2

A std::array doesn't contain any pointer to data somewhere else, a std::array directly holds the data internally, there's no anything dynamic in there.

It has been designed to provide semantics similar to a standard array but with some characteristics of standard STL containers.

It's an aggregate class which is mostly implemented as

namespace std
{
  template<typename T, size_t S>
  class array
  {
    T __elems_[S];
  }
}

You have array.data() which already returns a C array so I don't get your requirement.

Answer 3

For the reference, the technique you are referring to is called flexible array member , and unfortunately, it is not supported in C++ as either core feature or standard library function. I find this disappointing.

std::array is a dressed-up C-style array (with some members which allow it's using as an STL container, like iteration, sizing, type introspection, etc).

The only way I know to achieve a functionality which would be similar to flexible array member would be to create an std::vector<char> , with size set to the sizeof(header) + <extra bytes for payload> , and than placement new header in the vector.data() . You can wrap all this in a helper class to save yourself some typing for multiple scenarios.

Answer 4

I can suggest type erasure as a general solution to your problem. In modern C++ there is a tendency to stay away from direct manipulation of raw pointers, unless inevitable:

struct common_part{
    //declare common data and ctor
protected:
    virtual elem* end(){return begin()+size();};
    virtual elem *begin()=0 ;
    virtual ~common_part()=default;
    virtual std::size_t size()=0;
};

template<std::size_t N>
struct instance_type:
    common_part{
protected:
    void elem* begin() override{return arr;};
    void elem* end() override{return arr+N;};
    void std::size_t size() override{return N;};
private:
    elem arr[N];
};

std::unique_ptr<common_part> ptr {new instance_type<N>{}};