does C++ have spread operator? - c++

Question

can you do this in C++:
vector<int> v1={1,2}, v2={3,4};
vector<int> v3={...v1, ...v2, 5};
//v3 = {1,2,3,4,5}
What is the simplest way to do this with C++ ?

Answer 1

I would implement it with a helper function like this. Online demo here : https://onlinegdb.com/AnA3GkbQL
This template code kind of writes out all the individual push_backs and inserts needed to get the final result (at compile time).
#include <iostream>
#include <vector>
namespace details
{
template<typename type_t, typename arg_t, typename... args_t>
auto make_spread_impl(std::vector<type_t>& values, const arg_t& arg, const args_t&... args)
{
// check if template argument is a value or a std::vector of values.
if constexpr (std::is_same_v<arg_t, type_t>)
{
// single value
values.push_back(arg);
}
else
{
// vector of values
static_assert(std::is_same_v<std::vector<type_t>, arg_t>);
// append values to end
values.insert(values.end(), arg.begin(), arg.end());
}
// continue recursion
if constexpr (sizeof...(args_t) > 0)
{
return make_spread_impl(values, args...);
}
// recursion end condition
return values;
}
}
template<typename type_t, typename... args_t>
auto make_spread(const args_t&... args)
{
// one argument return a vector of values.
if constexpr (sizeof...(args) == 1ul)
{
return std::vector<type_t>{args...};
}
// otherwise recurse
std::vector<type_t> values;
details::make_spread_impl(values, args...);
return values;
}
int main()
{
std::vector<int> v1{ 1,2,3 };
std::vector<int> v2{ 5,6,7 };
auto result = make_spread<int>(v1, 4, v2, 8);
for (const auto& value : result)
{
std::cout << value << " ";
}
return 0;
}

Answer 2

No spread operator in C++.
Probably the simplest way would be a sequence of inserts
std::vector<int> v3;
v3.insert(v3.end(), v1.begin(), v1.end());
v3.insert(v3.end(), v2.begin(), v2.end());
v3.insert(v3.end(), 5);
Various range libraries have a concat function
auto v3 = ranges::views::concat(v1, v2, { 5 }) |
ranges::views::join |
ranges::views::to<vector>;
C++23 or ranges::v3. Still more verbose than spread operator.