How to iterate through a vector of vector in C++? - c++

Question

I would like to know if it is possible to access the elements of std::vector<std::vector<int>> via iterators: I cannot understand why this won't compile:
#include<vector>
#include<iostream>
std::vector<std::vector<int>> vec {{1,2},{3,4}} ;
// to access the single vector
auto it = vec.begin() ;
// to access the element of the vector
auto iit = it.begin() ;
Here the error I get:
prova.cpp: In function ‘int main()’:
prova.cpp:10:15: error: ‘class __gnu_cxx::__normal_iterator<std::vector<int>*, std::vector<std::vector<int> > >’ has no member named ‘begin’
10 | auto iit = it.begin() ;

Answer 1

You can get an iterator to the inner elements from a reference to the inner vector. An iterator is not a reference to the element, but you have to dereference it. Change this:
// to access the element of the vector
auto iit = it.begin() ;
To
auto iit = it->begin();
Don't overcomplicate stuff. You iterate a vector like this:
std::vector<T> vect;
for (auto it = vect.begin(); it != vect.end(); ++it) {
auto& element = *it;
// element is a reference to the element in the vector
}
or with a range based loop:
for (auto& element : vect) {
// element is a reference to the element in the vector
}
It really never gets more complicated than that.
When you have a nested vector and you want to iterate elements of the inner vectors you just need to first get elements of the outer vector, then elements of the inner ones:
std::vector<std::vector<T>> vect2;
for (auto& inner_vector : vect2) {
// inner_vector is reference to element of vect2
for (auto& element : inner_vector) {
// element is reference to element of inner vector
}
}

Answer 2

auto iit = it.begin();
doesn't compile because it is an iterator, not a vector. You should use the overloaded value-of operator to get the vector pointed to by it.
auto iit = (*it).begin();
Then you can use the iterators as normal.
You can also use range-based for-loops:
for(auto &row : vec) {
for(auto &col : row) {
// do things
}
}

Answer 3

Iterators in particularly random access iterators simulate the behavior of pointers.
For example if you have an object of a class like:
struct A
{
int x;
} a = { 10 };
and a pointer to the object:
A *pa = &a;
then to access data members of the object using the pointer you need to write for example either:
std::cout << pa->x << '\n';
or:
std::cout << ( *pa ).x << '\n';
So consider this declaration:
auto it = vec.begin();
as a declaration of a pointer.
So using this iterator you can gets iterators of stored vectors like
auto iit1 = it->begin() ;
auto iit2 = ( ++it )->begin();
Using this approach you can write nested for loops to output the vector.
Here is a demonstration program:
#include <iostream>
#include <vector>
int main()
{
std::vector<std::vector<int>> vec { { 1, 2 }, { 3, 4 } };
for ( auto it = vec.cbegin(); it != vec.cend(); ++it )
{
for ( auto iit = it->cbegin(); iit != it->cend(); ++iit )
{
std::cout << *iit << ' ';
}
std::cout << '\n';
}
std::cout << '\n';
return 0;
}
The program output is:
1 2
3 4
I have used member functions cbegin and cend instead of begin and end to show that the vector is not being changed within the loops.
To do the same it is simpler to use the range-based for loop. For example:
#include <iostream>
#include <vector>
int main()
{
std::vector<std::vector<int>> vec { { 1, 2 }, { 3, 4 } };
for (const auto &v : vec )
{
for ( const auto &item :v )
{
std::cout << item << ' ';
}
std::cout << '\n';
}
std::cout << '\n';
return 0;
}
The program output is the same as shown above.
In the range-based for loop the compiler itself dereferences the iterators instead of you.

Answer 4

If you really want to use iterators the following code would do the job.
#include<vector>
#include<iostream>
int main()
{
std::vector<std::vector<int>> vec {{1,2},{3,4}} ;
for (auto it = vec.cbegin(); it != vec.cend(); ++it)
{
for (auto iit = it->cbegin(); iit != it->cend(); ++iit)
{
std::cout << "elem: " << *iit << "\n";
}
}
}
Otherwise, by all means use ranged for loops.
#include<vector>
#include<iostream>
int main()
{
std::vector<std::vector<int>> vec {{1,2},{3,4}} ;
for (const auto& inner_vec : vec)
{
for (const auto& elem : inner_vec)
{
std::cout << "elem: " << elem << '\n';
}
}
}

Answer 5

According to Cplusplus
An iterator is any object that, pointing to some element in a range of
elements (such as an array or a container)
vector <int> v = {0,1,2};
auto it = v.begin();
// it is a iterator pointing to the first element of the vector
// To access the first element, we will use *it
cout << *it; // will output 0
// Notice how * is used to get the value where it points at
In your case, vec is a vector of vectors. Where each element of vec is itself a vector. Each element of v defined in the above code snippet was an int.
std::vector<std::vector<int>> vec {{1,2},{3,4}} ;
// it is an iterator pointing to the elements of vec
// Notice that it points to the elements of vec
// Each element of vec is a vector itself
// So it "points" to a vector
auto it = vec.begin() ;
// to access the element of the vector
//auto iit = it.begin() ;
// To access the elements (which are int) of the vector, you need to use:
auto iit = (*it).begin();
// *it is the value where it points to (which is basically the first vector )
Another way to iterate over vec would be to use for each loop
for(auto v : vec)
{
for(int a : v)
{
cout<<a;
// a is an integer
}
}