size() указателя std::array в контексте constexpr

про 2 не знаю.

Но для 1 мы можем сделать это:

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

потом:

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

альтернативно:

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 ...]
}

наконец, очистка C++14:

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 ...]
}

Живой пример.

Старый добрый способ C был бы определением, но C++ имеет const int или для C++11 constexpr. Поэтому, если вы хотите, чтобы компилятор знал, что размер массива является константой времени компиляции, наиболее переносимым (*) способом было бы сделать его const или 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;
}

Компилируется без предупреждения, даже с -Wall -pedantic под Clang 3.4.1

Что касается второго вопроса, я не могу себе представить, почему gcc делает эту разницу между указателями и ссылками здесь. Либо он может определить, что метод size() для std::array, размер которого является константой, является константным выражением, и он должен разрешать оба, либо не может, и он должен выдавать одно и то же предупреждение для обоих. Но это касается не только компилятора, но и реализации стандартной библиотеки.

Настоящая проблема заключается в том, что std::array до C++11 не был частью стандартной библиотеки, а constexpr также определяется только начиная с C++11. Таким образом, в режиме до C++11 оба компилятора обрабатывают std::array как расширение, но метод size не может объявить возвращаемое значение постоянным expr. Это объясняет, почему Clang (и gcc, обращенный к указателю) выдает предупреждение.

Но если вы компилируете исходный код в режиме С++ 11 (-std=c++11), у вас не должно быть предупреждений, потому что стандарт требует, чтобы метод size() для std::array был constexpr.

(*) Вопрос касается лучшего/наиболее стандартного ; Я не могу сказать, что является наилучшим способом, и я также не могу определить наиболее стандартный, поэтому я придерживаюсь того, что использовал бы, если бы хотел избежать проблем с переносимостью на других языках, отличных от C++. 11 компиляторов.

Как насчет использования std::tuple_size в decltype вашего параметра?

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 ...]
}