0

Why do I need to dereference iterators? For example in the following program

#include <iostream>
#include <string>
#include <vector>

int main()
{
    using namespace std;
    string s("some string");

    for(auto it = s.begin(); it != s.end(); && !isspace(*it); ++it)
        *it = isupper(*it);
    cout<<s;
}

Why is it necessary to use isupper(*it); instead of just isupper(it);?

Justin
  • 84,773
  • 49
  • 224
  • 367
Slay
  • 730
  • 1
  • 7
  • 18

3 Answers3

11

Iterator is a generalized pointer. It points to something. If you have a function that needs that something(char or int, in this case), not the "pointer" itself, you need to dereference the iterator.

For example, the standard advance function takes an iterator as its argument. Therefore you pass the iterator without dereferencing it, as in

std::advance(it, n);

But if you have an iterator that points to an int and you want to increment that integer by 4, you need

(*it) += 4;

I suggest that you should read a good book on C++.

By the way, your entire loop can be replaced by a single call to transform

 std::transform(s.begin(), s.end(), s.begin(), toupper);
Community
  • 1
  • 1
Armen Tsirunyan
  • 130,161
  • 59
  • 324
  • 434
  • Hey, thanks. I'm currently reading c++ primer 5th edition. It's going alright. Anything better you can recommend? I've seen the thread you posted, but I'm not experienced enough to pick out the good ones. – Slay Jun 25 '13 at 11:18
  • 2
    @Armen `toupper` is an overloaded function, your `transform` example is not guaranteed to work. See http://gcc.gnu.org/onlinedocs/libstdc++/manual/strings.html#strings.string.simple – Jonathan Wakely Jun 25 '13 at 11:36
  • @JonathanWakely I was told that passing possibly negative values to `` is formaly undefined behaviour and that one should always cast the argument to `unsigned char`. – jrok Jun 25 '13 at 12:00
  • @user2474562: C++Primer is the way to go, IMO – Armen Tsirunyan Jun 25 '13 at 12:10
  • @jrok, it must be _representable_ as `unsigned char` (or equal `EOF`) so negative values are OK if they fit in an `unsigned char` – Jonathan Wakely Jun 25 '13 at 12:34
4

You need to be able to perform operations on the iterator itself e.g. your code does it != s.end() and ++it

And sometimes you need to be able to perform operations on the object the iterator points to, e.g. isupper(*it)

There has to be some operation to indicate you want to refer to the thing it refers to not the iterator itself, otherwise if you test if (it == another_it) how would the compiler know if you were trying to compare the iterators or the things they point to? The same applies to the ++it operation, which wants to modify the iterator, not the thing it points to.

Iterators could have a get() member to return the thing they refer to, so you'd do isupper(it.get()) but instead they support the dereference operator, which is less typing and is consistent with pointers and allows pointers to be used in any code that expects iterators.

Jonathan Wakely
  • 166,810
  • 27
  • 341
  • 521
2

In order to distinguish operations on pointer-to-T and operations on the subject T it is necessary to have a dereferencing operator.

For example:

int* x = ...;

x++;

Do you mean you want to increment the pointer so it is pointing to the next int in memory? Or do you want to increment the int pointed to by x?

Without the deferenencing operator this would be ambiguous.

Iterators are simply a generalization of the pointer interface.

Contrast with references:

int& x = ...;

x++;

References have the alternative semantic, and do not require dereferencing. An operation on reference-to-T applies to the subject T. The downside is that you can't modify the reference itself.

Andrew Tomazos
  • 66,139
  • 40
  • 186
  • 319