What happens if...?

What happens if you, the programmer, or the user of the program, either intentionally or accidentally attempt to store a value greater than an int type is able to handle? For example, say you had an int with byte size 4 bytes, and you attempted to store a value that could not fit inside 4 bytes only (i.e. it needs more bytes). What would happen?

The variable "rolls over". For a simple example of this run this code:

Code:

---

for(unsigned char charCounter = 250; ; charCounter++)
{
    printf("charCounter is %d\n", (int)charCounter);
}

---

I may be mistaken, but the result of overflow with signed integers is undefined behavior, and with unsigned types they "wrap around" (modulo arithmetics).

If the user enters values too big, then I suppose the result depends entirely on how input is validated, and if you use a literal value too big for the type as a programmer, the compiler might warn of this.

I think anon and jeffcobb are both right. jeffcob describes the typical behavior, but technically the result is undefined.

Quote:

---

Originally Posted by anon

I may be mistaken, but the result of overflow with signed integers is undefined behavior, and with unsigned types they "wrap around" (modulo arithmetics).

If the user enters values too big, then I suppose the result depends entirely on how input is validated, and if you use a literal value too big for the type as a programmer, the compiler might warn of this.

---

It's effect on your application may be undefined, but the results are very well defined. It rolls over and sets the carry flag (CF).

I've found in my programs that if the user puts a number larger than 2147483647 (32 bits with all but the leftmost bit as 1) into an int (using cin>>), the program skips over any cin>> anywhere else in the program. This usually causes my programs to get stuck in an infinite loop, because every cin>> has input validation, which continually fails, and the program asks the user for input again but never waits for it to be entered.

Why this happens, I have no idea. But nothing I've made so far has any reason for a number even close to 2 billion.

That's because std::cin does input validation. You'll need to check the result of an input operation, and if there was a problem "ignore" unread characters and "clear" the error bits.

Code:

---

#include <iostream>
#include <limits>

int main()
{
    int n = 1;
    do {
        if (std::cin >> n) {
            std::cout << "Ok " << n << '\n';
        }
        else {
            std::cout << "Not Ok\n";
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        }
    } while (n);
}

---

Quote:

---

Originally Posted by King Mir

I think anon and jeffcobb are both right. jeffcob describes the typical behavior, but technically the result is undefined.

---

jeffcob described the behaviour of unsigned integral types. Anon described the behaviour with signed types (undefined) and unsigned types (modulo arithmetic).

With unsigned types the maximum value is implementation defined (although the standards specify lower bounds for the maximum), but - whatever the maximum is - the arithmetic is modulo that maximum plus one.

Thank you.