Initializing static constexpr member of type std::array

Question

I'm failing to programmatically initialize a static constexpr std::array member.
This is a minimal example of my issue (for simplification size is known and small, thus initialization could be manual but I'd like to make the actual size a template non-type parameter, thus ruling out a manual initialization):

#include <array>

constexpr std::size_t N = 3;
using Mat = std::array<double, N * N>;

// OK, can initialize a free constexpr Mat
constexpr Mat InitEye() noexcept {
    Mat TmpEye{0};
    for (std::size_t r = 0; r < N; ++r) {
        for (std::size_t c = 0; c < N; ++c) {
            TmpEye[r * N + c] = (r == c) ? 1. : 0.;
        }
    }
    return TmpEye;
}

// KO
class Wrapper {
   private:
    // KO cannot use it to initialize static constexpr member
    static constexpr Mat WrappedInitEye() noexcept {
        Mat TmpEye{0};
        for (std::size_t r = 0; r < N; ++r) {
            for (std::size_t c = 0; c < N; ++c) {
                TmpEye[r * N + c] = (r == c) ? 1. : 0.;
            }
        }
        return TmpEye;
    }

   public:
    static constexpr Mat Eye = WrappedInitEye();
};

// also KO
class Wrapper2 {
   public:
    // OK in C++17, still KO in C++17 due to lack of constexpr access operator
    static constexpr Mat Eye = [] {
        Mat TmpEye{0};
        for (std::size_t r = 0; r < N; ++r) {
            for (std::size_t c = 0; c < N; ++c) {
                TmpEye[r * N + c] = (r == c) ? 1. : 0.;
            }
        }
        return TmpEye;
    }();
};

int main() {
    constexpr Mat Eye = InitEye();
    constexpr Mat Eye2 = Wrapper::Eye;
    return 0;
}

The closest answer I found is this one (thus the lambda version above).

Yet live example si showing two issues:

1. Non lambda version never works:

\<source\>:32:46: error: 'static constexpr Mat Wrapper::WrappedInitEye()' called in a constant expression before its definition is complete
   32 |     static constexpr Mat Eye = WrappedInitEye();

2. Lambda version does not work either in C++14, due to the lack of constexpr access function for std::array

My questions are:

1. Why does the non-lambda version gives this "uncomplete definition" error?
2. How can I implement a programmatic std::array initialization with C++14?

Answer 1

1. Why does the non-lambda version gives this "uncomplete definition" error?

Because the definition of the static member function WrappedInitEye is not complete until the end of the class definition. I'm not quite sure where in the standard this is addressed, but that particular error disappears if you make WrappedInitEye a free function instead.

2. How can I implement a programmatic std::array initialization with C++14?

Best I could do in C++14 is this:

#include <array>
#include <utility>

constexpr std::size_t N = 3;
using Mat = std::array<double, N * N>;

template<std::size_t Index>
static constexpr bool condition = Index / N == Index % N;

template<std::size_t Index>
constexpr auto genElement(char(*)[condition<Index>] = 0) -> double {
    return 1.;
}

template<std::size_t Index>
constexpr auto genElement(char(*)[!condition<Index>] = 0) -> double {
    return 0.;
}

template<std::size_t... Indices>
constexpr auto gen(std::index_sequence<Indices...>) {
    return Mat{ genElement<Indices>()... };
}

int main() {
    constexpr Mat a = gen(std::make_index_sequence<N*N>());
}

Demo

It only works for your particular pattern (identity matrix, so a 1 when Index / N == Index % N, a 0 otherwise), but you might be able to modify it for more complex patterns. The char(*)[condition<Index>()] = 0 part uses SFINAE. I got it from here.

You can also use tag dispatching:

template<std::size_t Index>
using Condition = std::integral_constant<bool, Index / N == Index % N>;

template<std::size_t Index>
constexpr auto genElement(std::true_type) -> double {
    return 1.;
}

template<std::size_t Index>
constexpr auto genElement(std::false_type) -> double {
    return 0.;
}

template<std::size_t... Indices>
constexpr auto gen(std::index_sequence<Indices...>) {
    return Mat{ genElement<Indices>(Condition<Indices>{})... };
}

Demo