Using accessors on reference to vector for iteration in C++

Question

I am trying to iterate over a reference to a vector of strings inside a function. The code originally iterated over an internal copy of the vector but I would like to iterate over the original if possible. However, when I try to do so, I get type mismatch problems.

I tried to work with just portions of an iterator by setting and printing it, but I get similar type mismatching for both the initialization and printing with a %s format specifier. Inside gdb, printing the begin accessor works the same for the reference to the vector or a copy of that to its own vector.

Outside:

std::vector<std::string> foo;
foo.pushback('alpha');
foo.pushback('bravo');
func(foo);

Inside with copying:

void func(const std::vector<std::string> &bar){

    std::vector<std::string> barcopy = bar;

    for (std::vector<std::string>::iterator barIt = barcopy.begin(); barIt != barcopy.end(); barIt++){
        //operations with the string inside barcopy
    }
}

Inside without copying:

void func(const std::vector<std::string> &bar){
    for (std::vector<std::string>::iterator barIt = bar.begin(); barIt != bar.end(); barIt++){
        //operations with the string inside bar
    }
}

I expected the reference to behave the same as the copy, but attempting this directly gets me the following when attempting to compile.

error: conversion from 
'__gnu_cxx::__normal_iterator<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >*, std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >' 
to non-scalar type 
'__gnu_cxx::__normal_iterator<std::basic_string<char, std::char_traits<char>, std::allocator<char> >*, std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >' 
requested

What type does the begin accessor return when performed on a reference to a vector? How do I go about iterating over this reference without copying?

See this [related question](https://stackoverflow.com/questions/30924328/does-const-containers-have-only-const-iterator). — 1201ProgramAlarm, Jul 16 '19 at 23:26

Paul Sanders · Accepted Answer · 2019-07-16T23:33:28.120

7

Because you are passing bar as a const ref, you need to change:

for (std::vector<std::string>::iterator barIt = bar.begin(); barIt != bar.end(); barIt++)

to:

for (std::vector<std::string>::const_iterator barIt = bar.cbegin(); barIt != bar.cend(); barIt++)

or, better still, use a ranged for loop, if all you want is to iterate through the elements in the vector:

for (auto &elem : bar)

Alternatively, change your function signature to void func(std::vector<std::string> &bar) (without the const). The ranged for loop will work in either case.

edited Jul 16 '19 at 23:33

answered Jul 16 '19 at 23:22

Paul Sanders

24,133
4
26
48

`cbegin()`/`cend()` returns `const_iterator` not `const iterator`. – David G Jul 16 '19 at 23:23
Why do you consider the ranged for loop better? Is it for flexibility? Would this take slightly longer to run than directly defining the iterator type? – meadowlark Jul 17 '19 at 15:05
I like its succintness and readability. Run time should be the same, see: https://en.cppreference.com/w/cpp/language/range-for – Paul Sanders Jul 17 '19 at 16:34
Thanks for the material, it looks like that is a good route for me – meadowlark Jul 18 '19 at 16:07

score 3 · Answer 2 · answered Jul 16 '19 at 23:22

3

Notice that you are taking the parameter as a const reference. The error is due to trying to take a non-const iterator from a const container. You could fix the error by changing your code to: (take note of the iterator type)

for (std::vector<std::string>::const_iterator barIt = bar.begin(); barIt != bar.end(); barIt++){
    //operations with the string inside bar
}

Alternatively, you could use the auto keyword which will deduce the correct iterator type:

for (auto barIt = bar.begin(); barIt != bar.end(); barIt++){
    //operations with the string inside bar
}

answered Jul 16 '19 at 23:22

Blastfurnace

18,411
56
55
70

Doesn't that need `cbegin` / `cend`? – Paul Sanders Jul 16 '19 at 23:24
@PaulSanders No, `const` versions of `begin()` and `end()` return `const_iterator`. – David G Jul 16 '19 at 23:26
1

@PaulSanders You could use `cbegin`/`cend` make your intention more explicit but `begin`/`end` on a `const` object also return a `const_iterator`. – Blastfurnace Jul 16 '19 at 23:27

Using accessors on reference to vector for iteration in C++

2 Answers2