1

Is there away to achieve the behavior shown in the example (non compiling) code below? I (think I) understand why it doesn't compile given that the required calls to std::initializer_list functions are not constexpr.

The goal is to be able to create an array from a constant initialiser list when an additional element is appended to the end that is the sum of the preceeding elements.

All the posts I found on initialising arrays at compile time required lots of complex recursive template function calls and all were related to generating sequences of numbers.

#include <initializer_list>
#include <array>

template <typename T> constexpr auto CheckSummedArray(const std::initializer_list<T> & i)
{
    std::array<T, i.size() + 1> res;
    std::copy(i.begin(), i.end(), res.begin());
    auto cs = T();
    for (auto r : i)
    {
        cs += r;
    }
    res[res.size() - 1] = cs;
    return res;
}

constexpr auto testArray = CheckSummedArray<int>({1,2,3,4});

static_assert(testArray.size() == 5);
static_assert(testArray[0] == 1);
static_assert(testArray[4] == 9);
Improve this question
1
  • What's your compiler version? What's the compile option -std=c++14 or -std=c++17 you are using? Commented Apr 8, 2021 at 3:29

1 Answer 1

Reset to default
2

The issue is not the calls to the members of std::initializer_list, those functions are actually constexpr. The issue is that you are using the result of i.size() in a template parameter, but i is not a constant expression, since it's a function parameter.

You can solve this by making the argument an array type, and so you can deduce its size with a template parameter:

template <typename T, std::size_t N> 
constexpr auto CheckSummedArray(T const(&i)[N])
{
    std::array<T, N + 1> res{};
    std::copy(i, i + N, res.begin());
    res.back() = std::accumulate(i, i + N, 0);
    return res;
}

Here's a demo.

I cleaned up the function a little by using an algorithm instead of a loop. If you're not using C++20, you don't have access to constexpr algorithms, so your copy and accumulate will need to be raw loops anyway.

for(std::size_t j = 0; j < N; ++j)
{    
    res[j] = i[j];
    res.back() += i[j];
}

Here's a C++17 demo.

Improve this answer
Sign up to request clarification or add additional context in comments.

12 Comments

Thankyou for your answer, it was exactly what I was looking for. Unfortunately I cant use C++20 in this project, only C++17. Actually, the assert is correct, the code itself is incorrect. There should be a -1 after the sum. This was a simplified example to not overcomplicate the question and it looks like I forgot some details!
@AshleyDuncan As I mentioned, the solution to your problem works in C++17, and all you need to do is write the raw loops instead of the algorithms. I added that solution explicitly in the answer anyway.
@AshleyDuncan Oh, I see what you mean by the assert being right. Your function was supposed to do res[res.size()] = cs - 1; instead of res[res.size() - 1] = cs;. Well, that's not relevant to your issue, so it's fine :)
It think I already know the answer to this, but would it be possible to use a technique like this to initialise a plain array?
@AshleyDuncan Sure, I think that'll work. Arrays are usable in constexpr contexts IIRC.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.