How to append the content of arrays to a std::vector? - c++

Question

I have two arrays
float vertices[] = {
-0.5f, -0.5f, 0.0f,
0.5f, -0.5f, 0.0f,
0.0f, 0.5f, 0.0f
};
float normals[] = {
0.0, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f
};
I first want to add the vertices array to a std::vector<float> and after that insert the normals array to the vector.
What I can think of is running a loop based on the sizeof(Array) and push back individual element to the vector.
Would that guarantee that the values inserted are in the correct sequence when I access them back?

Answer 1

You can std::vector::insert the elements in the end of the vector.
#include <iterator> // std::cbegin, std::cend, std::size
#include <vector>
std::vector<float> vec;
// reserve the memory for unwated reallocations.
vec.reserve(std::size(vertices) + std::size(normals));
vec.insert(vec.end(), std::cbegin(vertices), std::cend(vertices));
vec.insert(vec.end(), std::cbegin(normals), std::cend(normals));
[...] running a loop based on the sizeof(Array) and push back
individual element to the vector. Would that guarantee that the values
inserted are in the correct sequence when I access them back?
Yes, indeed. Remember you can use std::size to find the size of the array, if you have access to c++17 or later compiler.

Answer 2

You may want to append those two arrays to an existing std::vector or create a new one out of them. In both cases, you very likely want to reserve all the memory needed for the insertions in one go to avoid additional unnecessary reallocations.
For the former case, you can use the following function template:
template<size_t... Ns>
void append_to_vector(std::vector<float>& vec, float (&...arrs)[Ns]) {
constexpr auto num_elements_to_append = sizeof...(Ns);
vec.reserve(vec.size() + num_elements_to_append);
(vec.insert(vec.end(), std::cbegin(arrs), std::cend(arrs)),...);
}
Appending vertices and normals to an existing std::vector<float> becomes:
std::vector<float> vec; // your existing vector
// ...
append_to_vector(vec, vertices, normals);
For the latter case – i.e., you want to create a new vector out of those two arrays – you can use the following function template, create_vector, that in turn calls append_to_vector:
template<size_t... Ns>
std::vector<float> create_vector(float (&...arrs)[Ns]) {
std::vector<float> vec;
append_to_vector(vec, arrs...);
return vec;
}
Creating a new vector from the arrays vertices and normals comes down to a single line:
auto vec = create_vector(vertices, normals);
You are not limited to two arrays. You can actually provide an arbitrary number of arrays to these function templates thanks to their variadic nature, e.g.:
auto vec = create_vector(vertices, vertices, normals, vertices, normals);
The line above works as you may expect, i.e., it creates a new vector resulting from the concatenation of the elements in vertices, vertices (again), normals, vertices and normals.
In any case, for each call to append_to_vector(), only one reallocation will be performed at most because the call to std::vector::reserve() ensures that the memory needed to insert the new elements is available before the insertions.

Answer 3

To insert elements into a std::vector of floats, you can use std::copy:
std::vector<float> my_vector;
my_vector.reserve(std::size(vertices) + std::size(normals)); // optional
std::copy(std::begin(vertices), std::end(vertices), std::back_inserter(my_vector));
std::copy(std::begin(normals), std::end(normals), std::back_inserter(my_vector));
The order of elements in my_vector will be the same as in vertices and normals.
Do we need to reserve the memory before inserting the Arrays ?
Technically, no. But reserving memory might help to avoid unnecessary reallocations.
Edit.
The Notes section for std::vector::reserve at cppreference reads:
When inserting a range, the range version of insert() is generally preferable as it preserves the correct capacity growth behavior, unlike reserve() followed by a series of push_back()s.
The recipe in my answer works, but that in JeJo's one should be preferred.