In 'for (auto c : str)' what exactly is c? - c++

Question

If I declare:
string s = "ARZ";
And then run the following code:
for (auto& c : s) {
cout << (void*)&c << endl;
}
the results will correspond to the addresses of s[0], s[1] and s[2] respectively.
If I remove the & and run:
for (auto c : s) {
cout << (void*)&c << endl;
}
the address of c is always the same.
Presumably c is just a pointer into the vector and it's value advances by sizeof(char) with each loop but I'm finding it hard to get my head round why I'm not required to write *c to access the string char values.
And finally if I run:
for (auto c: s) {
c='?';
cout << c << endl;
}
It prints out 3 question marks.
I'm finding it hard to fathom what c actually is?

Answer 1

In 'for (auto c : str)' what exactly is c?
It's a local variable whose scope is the entire for block and has char type.
for (auto c : str) { loop_statement }
is equivalent to
{
for (auto __begin = str.begin(), __end = str.end(); __begin != __end; ++__begin) {
auto c = *__begin;
loop_statement
}
}
On some implementations, under some conditions, since the lifetime of c ends before the lifetime of next-iteration's c begins, it gets allocated at the same place and gets the same address. You cannot rely on that.

Answer 2

If you don't know the type, you can let the compiler tell you:
#include <string>
template <typename T>
struct tell_type;
int main(){
std::string s = "asdf";
for (auto& c : s) {
tell_type<decltype(c)>();
}
}
Note that there is no definition for tell_type, hence this will result in an error along the line of:
error: implicit instantiation of undefined template 'tell_type<char>'
And similarly
error: implicit instantiation of undefined template 'tell_type<char &>'
for the for (auto& ... loop.

Answer 3

c is char.
The syntax can be misleading until you get it under your skin (but it makes sense).
for (auto c : s) //*distinct object* (think: a copy usually)
for (auto& c : s) //reference into the string (can modify string)
Short: use auto& when you need to modify the contents.

Answer 4

In 'for (auto c : str)' what exactly is c?
c is a local variable with automatic storage within the scope of the range-for statement. It's type will be deduced because you used auto. In case of string str="ARZ";, the deduced type will be char.
Presumably c is just a pointer into the vector
There is no vector, and c is not a pointer. It is a char.
Understanding what range-for does may help. It is equivalent to doing following (the __ prefixed variables are not accessible to the programmer; they are conceptual for the behaviour of the loop):
{
auto && __range = range_expression;
auto __begin = begin_expr;
auto __end = end_expr;
for (; __begin != __end; ++__begin) {
range_declaration = *__begin;
loop_statement
}
}
Or, in this particular case:
{
auto && __range = str;
auto __begin = range.begin();
auto __end = range.end();
for ( ; __begin != __end; ++__begin) {
auto c = *__begin; // note here
cout << (void*)&c << endl;
}
}
Note that if you use auto&, then c will be deduced to be a reference to char. Applying the addressof operator to a reference will not produce the address of the reference variable, but instead the address of the referred object. In this case the referred object would be the character within the string.

Answer 5

In this range-based for loop
for (auto c: s) {c='?'; cout << c << endl;}
there are three iterations because the size of the string s is equal to 3.
Within the loop the assigned value of the object c is ignored and the object is reassigned by the character '?'. So three characters '?' are outputted.
The type of the local variable c is char that is the value type of the class std::string
In this range-based for loop
for (auto& c : s) cout << (void*)&c << endl;
the variable c has a referenced type more precisely the type char &. So in this loop the addresses of the referenced objects are outputted. That is in this loop the addresses of elements of the string s are outputted.
In this range-based for loop
for (auto c : s) cout << (void*)&c << endl;
there is outputted the address of the same local variable c.

Answer 6

When you use references, the reference c is a reference to a character inside the string.
When you don't use references, c is a plain char variable, which contains a copy of the character in the string.
The reason the non-reference variant gives the same pointer for all iterations is simply an implementation detail, where the compiler reuses the space for the variable c inside each iteration.

Answer 7

for (auto& c : s)
c is a reference to a character (char&)
This loop is roughly equivalent to C:
for (char* c=str; *c; ++c)
for (auto c : s)
c is a character (char)
This loop is roughly equivalent to C:
int i=0;
for (char c=str[i]; i<strlen(str); c=str[++i])