27

I've been moving back and forth with Java/C++ so I messed up with my console output and accidentally wrote lines like:

cout << "num" + numSamples << endl;
cout << "max" + maxSampleValue << endl;

Each of which gave me bits and pieces of other strings I had in my program. I realize my mistake now, but what was C++ interpreting those lines as so that they output different parts of different strings in my program?

GuitarStrum
  • 713
  • 8
  • 24
  • 5
    The `cout` is irrelevant here. What are the types of `numSamples` and `maxSampleValue`? `int`s? – BoBTFish Apr 17 '15 at 22:16
  • 2
    Try a longer string and use 0, 1, 2, etc instead of your variables. – molbdnilo Apr 17 '15 at 22:21
  • 2
    That you're asking about `cout` indicates a misunderstanding about the language. `cout` isn't a keyword, and it's not magical. It's an ordinary object. `cout` is fed the *result* of `"num" + numSamples`; it has way of knowing that the original expression contained a `+` in it. – jamesdlin Apr 18 '15 at 07:25
  • 1
    Depending on your compiler, you could have used `"num"s + numSamples ` (with a using for the appropriate namespace) and got exactly what you expected, by the way. – Kate Gregory Apr 18 '15 at 12:51
  • @jamesdlin I think `operator<<` contributes to this confusion for newcomers as well. It's easy really - "look! Just a function call! `operator<<( operator<<(cout, "num"+numsamples), endl );`" – OJFord Apr 18 '15 at 18:43
  • 1
    (Oops, I meant to write: "it has *no* way of knowing...") – jamesdlin Apr 18 '15 at 20:06

5 Answers5

36

There is a simple reason for this:

"num" and "max" are string literal. Their type is const char *. Assuming numSamples is an integer, what you are doing is is pointer arithmetic.

You are basically printing a string that points to "num" + numSamples bytes.

If you did cout << "num" + 1 << endl this would print "um".

You probably figured it out, but the correct way to do this is: cout << "num" << numSamples << endl;

Also, you asked:

But what was C++ interpreting those lines as so that they output different parts of different strings in my program?

As stated before, "num" is a string literal. Generally string literals sits in the same place in the binary program: .rodata. All other string literals sits in this region, so when you are advancing your pointer by a certain amount of bytes, you will likely points to some other string literals, thus printing (part of) them.

Andriy
  • 8,486
  • 3
  • 27
  • 51
Xaqq
  • 4,308
  • 2
  • 25
  • 38
30

It is just pointer arithmetic. For instance,

cout << "num" + 1 << endl;

would print a string staring from ((address of)"num" + 1), i.e. "um".

If the value we add exceeds the length of the string, then we have undefined behavior.

AlexD
  • 32,156
  • 3
  • 71
  • 65
3

Keep in mind that although iostreams overload << (and >>) to do I/O, these were originally defined as bit-shift operators. When the compiler's parsing the expression, it's basically seeing "operand, operator, operand", then checking whether the operands are of types to which that operator can be applied.

In this case, we have a string literal and (apparently) some sort of integer, and the compiler knows how to do math on those (after converting the string literal to a pointer).

From the compiler's viewpoint, however, this isn't a whole lot different from something like:

int a, b=1, c=2, d = 3;

a = b << c + d;

The difference is that with operands of type int, the meaning is fairly obvious: it's doing addition and bit-shifting. With iostreams, the meaning attached to << and >> change, but the syntax allowed for them in an expression is unchanged.

From the compiler's "viewpoint" the only question is whether the operands to + are of types for which + is allowed--in this case, you have pointer to char + integer, so that's allowed. The result is a pointer to char, and it has an overload of << that takes a left-hand operand of type ostream and a right-hand operator of type pointer to char, so the expression as a whole is fine (as far as it cares).

Jerry Coffin
  • 476,176
  • 80
  • 629
  • 1,111
2

"num" type is char const [4]. If numSamples is integer, "num" + numSamples type is const char *. So you call operator << cor std::cout, that overloaded for const char * and prints string that starts from address addres("num") + numSamples in pointer arithmetic.

Try this:

cout << "num" + std::to_string(numSamples) << endl;
cout << "max" + std::to_string(maxSampleValue) << endl;

std::to_string() function you can find in <string>

gomons
  • 1,946
  • 14
  • 25
2

if you look at operator_precedence, you will see that + gets evaluated before <<, which leaves this expression to be evaluated before being passed to the operator <<: 

"num" + numSamples

Now "num" is going to be a static const char * and I'm assuming numSamples is an integral type. Since the left-hand side of the + is a pointer type and you are adding to it, that's pointer arithmetic. The cout now gets a pointer to a location in memory that is numSamples or maxSamplueValue more than the location of "num" or "max". Most likely all of your static strings were lined up in in the same region of memory which is why you saw them rather than random gibberish.

evan
  • 265
  • 2
  • 8