Is there way to construct from initializer_list in compile time?

Question

I'm writing C++ ndarray class. I need both dynamic-sized and compile-time-size-known arrays (free store allocated and stack allocated, respectively). I want to support initializing from nested std::initializer_list.

Dynamic-sized one is OK: This works perfectly.

    frozenca::Array arr {{1, 2, 3}, {4, 5, 6}};
    std::cout << arr.size() << '
'; // 6
    std::cout << arr[{1, 1}] << '
'; // 5

Static-sized one is also OK: This works fine.

    frozenca::StaticArray arr2 {{1, 2, 3}, {4, 5, 6}};
    std::cout << arr2.size() << '
'; // 6
    std::cout << arr2[{1, 1}] << '
'; // 5
    // static_assert(arr2[{1, 1}] == 5); // THIS DOES NOT WORK

But I hate that the initialization is done in runtime actually. I want to make it as compile-time operation. My implementation detail is as follows:

template 
using DenseInitializer_t = typename DenseInitializer::type;

template 
struct DenseInitializer {
    using type = std::initializer_list>;
};

template 
struct DenseInitializer {
    using type = std::initializer_list;
};

template 
struct DenseInitializer;

template 
template 
constexpr void StaticArray::verifyDims(const Initializer& init) const {
    checkDims<0, Initializer, Sizes...>(init);
}

template 
StaticArray::StaticArray(DenseInitializer_t init) {
    verifyDims(init);
    insertFlat(data(), init);
}

template 
constexpr bool checkNonJagged(const Initializer& init) {
    auto i = std::cbegin(init);
    return std::all_of(init.begin(), init.end(), [&i](const auto& it) {
        return it.size() == i->size();
    });
}

template 
void checkDims(const Initializer& init) {
    if constexpr (k < sizeof...(Sizes) - 1) {
        if (!checkNonJagged(init)) {
            throw std::invalid_argument("Jagged matrix initializer");
        }
    }
    if (std::get(std::forward_as_tuple(Sizes...)) != std::ssize(init)) {
        throw std::invalid_argument("Matrix initializer does not match with static matrix");
    }
    if constexpr (k < sizeof...(Sizes) - 1) {
        checkDims(*std::begin(init));
    }
}

template 
void addList(T* data,
             const T* first, const T* last,
             int& index) {
    for (; first != last; ++first) {
        data[index] = *first;
        ++index;
    }
}

template 
void addList(T* data,
             const std::initializer_list* first, const std::initializer_list* last,
             int& index) {
    for (; first != last; ++first) {
        addList(data, first->begin(), first->end(), index);
    }
}

template 
void insertFlat(T* data, std::initializer_list list) {
    int index = 0;
    addList(data, std::begin(list), std::end(list), index);
}

addList and checkNonJagged doesn't work as compile-time, because the compiler thinks that init is not known as compile time even within the example case.

How can I make this as compile-time operation?

qqNade · Accepted Answer

Yes, there's no reason why constexpr std::initializer_list would be unusable in compile-time initialization.

From your code snippet, it's unclear whether you've used an in-class initialization for StaticArray members, so one of the issues you could've run into is that a constexpr constructor can't use a trivial constructor for members which would initialize them to unspecified run-time values.

So the fix for your example is to default-initialize StaticArray members and specify constexpr for the constructor, checkDims, addList and data. To initialize a runtime StaticArray with constexpr std::initializer_list validated at compile-time, you can make the initializer expression manifestly constant-evaluated using an immediate function.

As you probably realize, it is impossible to initialize a run-time variable at compile-time so that's the best one can do.

If what you wanted is to validate at compile-time the dimensions of an std::initializer_list that depends on runtime variables, it can't be done -- the std::initializer_list is not constexpr, so its size isn't either. Instead, you can define a wrapper type around Scalar, mark its default constructor as deleted, and accept an aggregate type of these wrappers in the StaticArray constructor, for example a nested std::array of the desired dimensions, or, to avoid double braces, a C-style multidimensional array. Then, if the dimensions don't match, compilation will fail for either of the two reasons: too many initializers or the use of the deleted default constructor.

The code below compiles on godbolt with every GCC, Clang, MSVC version that supports C++20.

#include 
#include 
#include 
#include 
#include 
#include 
#include 

namespace frozenca {

template 
constexpr std::size_t prod() {
    if constexpr (sizeof...(sz) == 0) {
        return sz0;
    } else {
        return sz0 * prod();
    }
}

template 
struct DenseInitializer;

template 
using DenseInitializer_t = typename DenseInitializer::type;

template 
constexpr void insertFlat(T* data, std::initializer_list list);

template 
constexpr void checkDims(const Initializer& init);

template 
struct StaticArray {
    using value_type = Scalar;
    static constexpr std::size_t N = sizeof...(Sizes);

    Scalar body[prod()];

    constexpr Scalar* data() {
        return body;
    }

    constexpr std::size_t size() const {
        return std::size(body);
    }

    // no bound checks performed
    constexpr Scalar operator[](const std::array& index) const {
        std::size_t dim = 0, idx = 0;
        ((idx = idx * Sizes + index[dim++]), ...);
        return body[idx];
    }

    void print() const {
        for (const auto& i: body) {
            std::cout << i << ' ';
        }
        std::cout << std::endl;
    }

    template 
    constexpr void verifyDims(const Initializer& init) const;

    constexpr StaticArray(DenseInitializer_t init);
};


template 
struct DenseInitializer {
    using type = std::initializer_list>;
};

template 
struct DenseInitializer {
    using type = std::initializer_list;
};

template 
struct DenseInitializer;

template 
template 
constexpr void StaticArray::verifyDims(const Initializer& init) const {
    checkDims<0, Initializer, Sizes...>(init);
}

template 
constexpr StaticArray::StaticArray(DenseInitializer_t init) : body{} {
    verifyDims(init);
    insertFlat(data(), init);
}

template 
constexpr bool checkNonJagged(const Initializer& init) {
    auto i = std::cbegin(init);
    return std::all_of(init.begin(), init.end(), [&i](const auto& it) {
        return it.size() == i->size();
    });
}

template 
constexpr void checkDims(const Initializer& init) {
    if constexpr (k < sizeof...(Sizes) - 1) {
        if (!checkNonJagged(init)) {
            throw std::invalid_argument("Jagged matrix initializer");
        }
    }
    if (std::get(std::forward_as_tuple(Sizes...)) != std::ssize(init)) {
        throw std::invalid_argument("Matrix initializer does not match with static matrix");
    }
    if constexpr (k < sizeof...(Sizes) - 1) {
        checkDims(*std::begin(init));
    }
}

template 
constexpr void addList(T* data,
                       const T* first, const T* last,
                       int& index) {
    for (; first != last; ++first) {
        data[index] = *first;
        ++index;
    }
}

template 
constexpr void addList(T* data,
                       const std::initializer_list* first, const std::initializer_list* last,
                       int& index) {
    for (; first != last; ++first) {
        addList(data, first->begin(), first->end(), index);
    }
}

template 
constexpr void insertFlat(T* data, std::initializer_list list) {
    int index = 0;
    addList(data, std::begin(list), std::end(list), index);
}

}

consteval auto echo(std::copy_constructible auto val) {
    return val;
}

void check0() {
    // frozenca::StaticArray arr_jagged {{1, 2, 3}, {4, 5}}; // throws an exception
    frozenca::StaticArray arr2 {{1, 2, 3}, {4, 5, 6}};
    std::cout << arr2.size() << '
'; // 6
    std::cout << arr2[{1, 1}] << '
'; // 5
    // static_assert(arr2[{1, 1}] == 5); // THIS DOES NOT WORK
    arr2.print();
}

void check1() {
    // constexpr frozenca::StaticArray arr_jagged {{1, 2, 3}, {4, 5}}; // compile-time error
    constexpr frozenca::StaticArray arr2 {{1, 2, 3}, {4, 5, 6}};
    static_assert(arr2.size() == 6);
    static_assert(arr2[{1, 1}] == 5);
    arr2.print();
}

void check2() {
    // auto arr_jagged = echo(frozenca::StaticArray{{1, 2, 3}, {4, 5}}); // compile-time error
    auto arr2 = echo(frozenca::StaticArray{{3, 2, 1}, {6, 5, 4}});
    std::cout << arr2.size() << '
'; // 6
    std::cout << arr2[{1, 1}] << '
'; // 5
    // static_assert(arr2[{1, 1}] == 5); // THIS DOES NOT WORK
    arr2.print();
}

namespace aggregate {

struct NoDefault {
  int val;

  constexpr NoDefault() = delete;
  constexpr NoDefault(int val) : val{val} {};
  constexpr operator int() const { return val; }
};

template 
struct NDNested;

template 
using NDNested_t = typename NDNested::type;

template <>
struct NDNested<> {
    using type = NoDefault;
};

template 
struct NDNested {
    using type = NDNested_t[size0];
};

template 
constexpr int sum(const NDNested_t& t) {
    if constexpr (sizeof...(sizes) != 0) {
        constexpr auto op = [](int acc, const auto& arr) { return acc + sum(arr); };
        return std::accumulate(std::begin(t), std::end(t), 0, op);
    } else {
        return std::accumulate(std::begin(t), std::end(t), 0);
    }
}

}

void check_aggregate() {
    using aggregate::sum;
#ifndef _MSC_VER
    static_assert(sum<2, 2, 2>({{{1, 1}, {2, 4}}, {{1, 2}, {3, 4}}}) == 18);
#endif
    int x = 100;
    std::cout << sum<2, 2, 2>({{{1, 1}, {2, 4}}, {{1, 2}, {x, 4}}}) << '
';
    // std::cout << sum<2, 2, 2>({{{1, 1}, {2, 4}}, {{1, 2}, {x}}}) << '
'; // deleted constructor
    // std::cout << sum<2, 2, 2>({{{1, 1}, {2, 4}}, {{1, 2}, {x, 3, 4}}}) << '
'; // excess elements
}

int main() {
    check0();
    check1();
    check2();
    check_aggregate();
}

Is there way to construct from initializer_list in compile time?

Answers (1)

Related Questions