How can I construct an std::array filled with some uniform value?

Question

std::array can be constructed (at compile time with newer C++ versions) with specific values, e.g.

std::array a{1, 4, 9};

however - it does not have a constructor, or a standard-library named constructor idiom, taking a single value and replicating it. i.e. we don't have:

std::array<int, 3> a{11};
// a == std::array<int, 3>{11, 11, 11};

How can we, therefore, construct an array given just the value to repeat?

Edit: I'm looking for a solution which would work even for element types which are not default-constructible; so, a solution going through default-constructing the array, then filling it, is not what I'm after - despite the fact that this will work for the case of int (like in the example).

einpoklum · Accepted Answer · 2025-09-30 07:59:00Z

10

We can write an appropriate named constructor idiom to achieve this. Then, your example definition would look like:

auto a = array_repeat<3>(11);
// a == std::array<int, 3>{11, 11, 11};

Here's how you could implement array_repeat():

#include <array>
#include <type_traits>
#include <utility>

template<std::size_t N, class T>
constexpr auto array_repeat(T&& value)
{
    return [&]<std::size_t... Indices>(std::index_sequence<Indices...>) {
        return std::array<std::decay_t<T>, N> { (void(Indices), value)... };
    } (std::make_index_sequence<N>());
}

(See this working on GodBolt). The implementation uses the "indices trick". And - we assumed C++14 to avoid an implementation of std::make_index_sequence, which requires a bit of boilerplate. But - this can be achieved in C++11.

Notes:

Thanks goes to @Caleth and @L.F. for pointing out an inappropriate forwarding in an earlier revision and to @Deduplicator who suggested the simplification of the solution to what you now see here.
Remember that there can are no arrays of references in C++ - neither plain C-style arrays nor std::arrays - so that if you use repeat_array() with, say, an std::string& or std::string&&, you'll get an array of std::strings (containing copies of the string you passed).
... for which reason, you may therefore prefer to have a signature taking a T const& t to better indicate that copying is not avoided.

edited Sep 30 at 7:59

answered Sep 9, 2020 at 23:55

einpoklum

137k86 gold badges445 silver badges917 bronze badges

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

5 Comments

user4581301 Over a year ago

Here I was thinking, "Matt has his own button now! W00t w00t!" But no. Just sneaky tagging. I commend the sneaky tagging.

einpoklum Over a year ago

@Caleth: So, would you suggest something like T&& x_ref = std::forward<T>(x) and using that instead?

Caleth Over a year ago

No, just drop the forwarding at the point where you are copying x multiple times std::array{identity<Indices>(x)...};

L. F. Over a year ago

To support Caleth's comment, currently array_repeat<3>(std::string{"123"}) results in ["123", "", ""].

einpoklum Over a year ago

@L.F.: You're right. The use of an rvalue reference messes up the value. Fixing it.

Qaz · Accepted Answer · 2020-09-10 00:26:38Z

2

With C++20, you can make a helper for this straightforwardly when the type is default-constructible and copyable by using the now-constexpr fill function (live example):

#include <array>
#include <concepts>
#include <cstddef>

template<std::size_t N, std::semiregular T>
constexpr auto array_repeat(const T& value) -> std::array<T, N> {
    std::array<T, N> ret;
    ret.fill(value);
    return ret;
}

int main() {
    constexpr auto a = array_repeat<3>(11);
    static_assert(a == std::array<int, 3>{11, 11, 11});
}

This could potentially be less efficient, but whether that's a problem is up to you.

answered Sep 10, 2020 at 0:26

Qaz

62.3k14 gold badges149 silver badges210 bronze badges

2 Comments

einpoklum Over a year ago

Chris, I have to apologize, since I meant to ask about the case where you can't just default-construct-and-fill, and have to construct from the get-go with the repeated value. Perhaps I should also alter the example to reflect that. Again, my apology.

Qaz Over a year ago

@einpoklum, It's fine, I suspected this wouldn't be useful to you specifically, but I hope someone will find it useful who didn't otherwise know this was a possibility.

Collectives™ on Stack Overflow

How can I construct an std::array filled with some uniform value?

2 Answers 2

5 Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

5 Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related