size() of std::array pointer in constexpr context

Question

Let's say I have a function like:

int test(std::array<char, 8>* data) {
  char buffer[data->size() * 2];

  [... some code ...]
}

clearly the size of the buffer can be evaluated at compile time: data has a constexpr size of 8 elements, 8 * 2 = 16 bytes.

However, when compiling with -Wall, -pedantic and -std=c++11 I get the infamous error:

warning: variable length arrays are a C99 feature [-Wvla-extension]

which I believe makes sense: array::size() is constexpr, but it is still a method, and in the function above we still have to dereference a pointer, which is not constexpr.

If I try something like:

int test(std::array<char, 8>& data) {
  char buffer[data.size() * 2];
  [...]
}

gcc (tried version 5.2.0) seems happy: there is no warning.

But with clang++ (3.5.1) I still get a warning complaining about variable length arrays.

In my case, I can't easily change the signature of test, it has to take a pointer. So... a few questions:

1. What is the best / most standard way to get the size of a std::array pointer in constexpr context?

2. Is the difference in behavior with pointers vs references expected? Which compiler is right about the warning, gcc or clang?

Answer 1

I do not know about 2.

But for 1, we can do this:

template<class T, size_t N>
constexpr std::integral_constant<size_t, N> array_size( std::array<T, N> const& ) {
  return {};
}

then:

void test(std::array<char, 8>* data) {
  using size=decltype(array_size(*data));
  char buffer[size{}];
  (void)buffer;
  // [... some code ...]
}

alternatively:

template<class T, class U, size_t N>
std::array<T,N> same_sized_array( std::array< U, N > const& ) {
  return {};
}

void test(std::array<char, 8>* data) {
  auto buffer = same_sized_array<char>(*data);
  (void)buffer;
  // [... some code ...]
}

finally, a C++14 cleanup:

template<class A>
constexpr const decltype(array_size( std::declval<A>() )) array_size_v = {};

void test3(std::array<char, 8>* data) {
  char buffer[array_size_v<decltype(*data)>];
  (void)buffer;
  // [... some code ...]
}

Live example.

Answer 2

The good old C way would be a define, but C++ has const int or for C++11 constexpr. So if you want the compiler to be aware that the size of the array is a compile time constant, the most portable(*) way would be to make it a const or constexpr:

#include <iostream>
#include <array>

const size_t sz = 8;  // constexpr size_t sz for c++11

int test(std::array<char, sz>* data) {
  char buffer[sz * 2];

  buffer[0] = 0;
  return 0;
}
int main()
{
    std::array<char, sz> arr = { { 48,49,50,51,52,53,54,55 } };
    int cr = test(&arr);
    std::cout << cr << std::endl;
    return 0;
}

It compiles without a warning, even with -Wall -pedantic under Clang 3.4.1

For the second question, I cannot imagine why gcc make that difference between pointers and refs here. Either it can determine that size() method on an std::array whose size is a constant is a constant expression - and it should allow both - or it cannot - and it should emit same warning on both. But it does not only concern the compiler, but also the standard library implementation.

The real problem is that pre-C++11 std::array was not part of the standard library, and constexpr is also defined only from C++11 on. So in pre-C++11 mode, both compiler process std::array as an extension, but there is no way for the size method to declare its return value to be a constant expr. This explains why Clang (and gcc facing a pointer) emits the warning.

But if you compile original code in c++11 mode (-std=c++11) you should have no warning, because the standard requires size() method on a std::array to be a constexpr.

(*) The question is about best / most standard ; I cannot say what is best way, and I cannot define most standard either, so I stick to what I would use if I wanted to avoid portability problems on non C++11 compilers.

Answer 3

What about using std::tuple_size on the decltype of your parameter ?

void test(std::array<char, 8>* data) {
    using data_type = std::remove_pointer<decltype(data)>::type;
    char buffer[std::tuple_size<data_type>::value * 2];
    static_assert(sizeof buffer == 16, "Ouch");
    // [... some code ...]
}