Question
Answer and Explanation
Flattening a vector of vectors in C++ involves combining all elements from the inner vectors into a single, flat vector. Here's how you can achieve this using standard C++ features.
First, let's define what a vector of vectors is:
A std::vector<std::vector<T>> where T is the type of the elements, means a dynamic array of dynamic arrays. The inner vectors can have different sizes.
To flatten this, we iterate through each inner vector and append all its elements into a new single vector.
Here’s a complete example:
#include <iostream>
#include <vector>
#include <algorithm>
std::vector<int> flattenVectorOfVectors(const std::vector<std::vector<int>>& vecOfVec) {
std::vector<int> flattenedVec;
for (const auto& innerVec : vecOfVec) {
flattenedVec.insert(flattenedVec.end(), innerVec.begin(), innerVec.end());
}
return flattenedVec;
}
int main() {
std::vector<std::vector<int>> vecOfVec = {
{1, 2, 3},
{4, 5},
{6, 7, 8, 9}
};
std::vector<int> flattened = flattenVectorOfVectors(vecOfVec);
std::cout << "Flattened vector: ";
for (int val : flattened) {
std::cout << val << " ";
}
std::cout << std::endl;
return 0;
}
Explanation:
1. We include necessary headers: iostream for printing, vector for using vectors, and algorithm is not directly used here, but good to have for more advanced operations.
2. The function flattenVectorOfVectors takes a constant reference to the vector of vectors to avoid copying.
3. We create an empty vector flattenedVec that will store the combined elements.
4. The code uses a range-based for loop to iterate over each inner vector. flattenedVec.insert adds the elements from the innerVec to the flattenedVec at the end.
5. Finally, flattenedVec returns the flattened vector.
6. In main(), we create the sample vector of vectors, call the flattenVectorOfVectors function, and print the result.
Alternative using std::accumulate:
You can also use the std::accumulate algorithm to flatten vector of vectors:
#include <iostream>
#include <vector>
#include <numeric>
std::vector<int> flattenVectorOfVectorsAccumulate(const std::vector<std::vector<int>>& vecOfVec) {
return std::accumulate(vecOfVec.begin(), vecOfVec.end(), std::vector<int>{},
[](std::vector<int> acc, const std::vector<int>& val) {
acc.insert(acc.end(), val.begin(), val.end());
return acc;
}
);
}
int main() {
std::vector<std::vector<int>> vecOfVec = {
{1, 2, 3},
{4, 5},
{6, 7, 8, 9}
};
std::vector<int> flattened = flattenVectorOfVectorsAccumulate(vecOfVec);
std::cout << "Flattened vector (using accumulate): ";
for (int val : flattened) {
std::cout << val << " ";
}
std::cout << std::endl;
return 0;
}
This alternative uses std::accumulate to accumulate all inner vectors. A lambda function is used to perform insertion of inner vector to the accumulator.
Both methods provide effective ways to flatten a vector of vectors in C++. Choose the one that fits your coding style. The first approach using explicit loop may be easier to understand, especially for the beginners.