Estaba tratando de escribir un valarray en tiempo de compilación que podría usarse de esta manera:

constexpr array<double> a = { 1.0, 2.1, 3.2, 4.3, 5.4, 6.5 };

static_assert(a[0] == 1.0, "");
static_assert(a[3] == 4.3, "");

static_assert(a.size() == 6, "");

Logré hacerlo con la siguiente implementación y funciona bien (con GCC 4.7):

#include <initializer_list>

template<typename T>
struct array
{
    private:

        const std::size_t _size;
        const T* _data;

    public:

        constexpr array(std::initializer_list<T> values):
            _size(values.size()),
            _data(values.begin())
        {}

        constexpr auto operator[](std::size_t n)
            -> T
        {
            return _data[n]
        }

        constexpr auto size() const
            -> std::size_t;
        {
            return _size;
        }
};

A pesar de que funciona bien para mí, no estoy seguro del comportamiento destd::initializer_list y puede usar algunos que son de comportamiento indefinido.

constexpr parastd::initializer_list constructor,begin ysize está bien, aunque no es estrictamente hablando C ++ 11, ya que la N3471 fue adoptada recientemente y cumplió con la norma.

Con respecto al comportamiento indefinido, no estoy seguro de si la matriz subyacente de lastd::initializer_list vivirá o, de no ser así, si existe un medio para que viva más tiempo que soloarray's constructor. ¿Qué piensas?

EDITAR: Puede que no haya sido claro, pero realmente no me importa la matriz real. Lo que realmente me interesa es el comportamiento destd::initializer_list y su matriz subyacente en tiempo de compilación.