No overflow in cout

I am a little confused on why I do not get an overflow when I use the the following code.

I am using testvar+1 as an expression in cout. This should cause an overflow but doesn't

Code:

---

#include<iostream>
#include<cstdlib>
#include<cmath>
using namespace std;

int main()
{
       

        short testvar=32767;
       
        cout<<"The contents of testvar is"<<testvar<<endl;
        cout<<"The contents of testvar with one added is: "<<testvar+1<<endl;
       
       
        system("pause");
        return 0;
}

---

However

The code below causes an overlow, with the variable testvar in cout.

Code:

---


#include<iostream>
#include<cstdlib>
#include<cmath>
using namespace std;

int main()
{
       

        short testvar=32767;
       
        cout<<"The contents of testvar is"<<testvar<<endl;
        testvar+=1;
       
        cout<<"The contents of testvar with one added is: "<<testvar<<endl;
       
       
        system("pause");
        return 0;
}

---

Not sure I understand what the differences are between the two code segments. In both instances you are adding 1 to testvar which should cause an overflow.

You probably believe testvar+1 is of type short. It is not. testvar is of type short, but 1 is of type int, and C++ will automatically promote the smaller datatype to the larger before doing arithmetic. I don't think there's a suffix you can use to mean short (like you can use "L" for long, for instance), but you can do an explicit cast:

Code:

---

testvar+(short)1

---

The literal value, 1, is of type int. Therefore, when computing "testvar+1", testvar is promoted to be of type int, and then 1 is added. The result is of type int. If an int can hold a larger value than a short - which is typical of most modern compilers - there will be no overflow.

Note also that, strictly speaking, overflowing a signed int type gives undefined behaviour.

An example, just to beat a dead horse (this is done in Visual Studio 2008):

Code:

---

#include <iostream>
#include <typeinfo>
#include <limits>

int main()
{
    short test = std::numeric_limits<short>::max();

    // Output original value of test and its type
    std::cout << "test  is: " << test
              << " and is of type " << typeid(test).name()
              << std::endl;

    // Output temporary value (test+1) and its type
    std::cout << "test+1 is: " << test+1
              << " and is of type " << typeid(test+1).name()
              << std::endl;

    // Increment variable test and then display value
    ++test;
    std::cout << "test  is: " << test << std::endl;

    return 0;
}

---

Output is:

I suggest that you modify hk_mp5kpdw's example to add:

Code:

---

// Output temporary value (test+test) and its type
std::cout << "test+1 is: " << test+test
          << " and is of type " << typeid(test+test).name()
          << std::endl;

---

You should observe that the result is still of type int, even though both operands are of type short. The points made by tabstop and grumpy are generally valid, but the usual arithmetic conversions are such that integral promotions are performed on both operands of operator+ here. In fact this rule, not the fact that one of the operands in your original example was of type int, is the reason for the integral promotion that was observed.

Note: tabstop was correct, there is no suffix for short literals. You may be interested in this: http://cboard.cprogramming.com/c-pro...iteral-ul.html

Quote:

---

Originally Posted by dwks

Note: tabstop was correct, there is no suffix for short literals. You may be interested in this: http://cboard.cprogramming.com/c-pro...iteral-ul.html

---

I would guess that goes back to Laserlight's point that shorter types get automatically promoted whenever they appear in a statement anyway, so there's not much point in it anyway. (I guess if you really wanted one, you could do "short(1)".)

Thanks for the feedback. I didn't realize how the rule with short to int applies. Is this a valid line of code to get testvar to overflow?


cout<<static_cast<short>(testvar+1)<<endl;

Thanks

Dante

Quote:

---

Originally Posted by DanteXP

Thanks for the feedback. I didn't realize how the rule with short to int applies. Is this a valid line of code to get testvar to overflow?


cout<<static_cast<short>(testvar+1)<<endl;

---

For one thing, you would not actually be getting "testvar to overflow", since testvar is not modified. Now, if the result of testvar+1 cannot fit into the range of short, the result of the cast would be implementation defined (and perhaps this is the overflow that you are looking for).