Why can I operate with int > +32767?

Question

I can read that int range (signed) is from [−32767, +32767] but I can say, for example

int a=70000;
int b=71000;
int c=a+b;

printf("%i", c);
return 0;

And the output is 141000 (correct). Should not the debugger tell me "this operation is out of range" or something similar?

I suppose that this has to be with me ignoring the basics of C programming, but none of the books that I'm currently reading tell nothing about this "issue".

EDIT: 2147483647 seems to be the upper limit, thank you. If a sum exceeds that number, the result is negative, wich is expected, BUT if it is a subtraction, for example: 2147483649-2147483647=2 the result is still good. I mean, why the value 2147483649 is correctly hold for that substraction purpose (or at least it seems to me)?

If you print `sizeof(int)`, that's the number of **bytes** your `int` can store. That's a hint. — erip, Jan 15 '16 at 13:21
Are you sure that is the range of int's on your machine? Try printing the number of bytes an int has with sizeof(int). — Daniel Severo, Jan 15 '16 at 13:21
On today's machine, is it default to be 32-bit at least for `int`? — gongzhitaao, Jan 15 '16 at 13:21
http://stackoverflow.com/questions/11438794/is-the-size-of-c-int-2-bytes-or-4-bytes — Andrei Bozantan, Jan 15 '16 at 13:22
@gongzhitaao The C++ Standard says at least 16 bits to store an `int`. — erip, Jan 15 '16 at 13:22
The range of int is usually -2,147,483,648 to 2,147,483,647. — ZunTzu, Jan 15 '16 at 13:22
There is not absoute rule on how big an int is in C, depends on the machine, probably yours run with 32 bits int — angrykoala, Jan 15 '16 at 13:22
@erip "However, on 32/64 bit systems it is almost exclusively guaranteed to have width of at least 32 bits... - [cppreference](http://en.cppreference.com/w/cpp/language/types)" — gongzhitaao, Jan 15 '16 at 15:15
@ikeki - **2147483649-2147483647=2** is really another question, but using values that are too large for an `int` is again undefined behavior. In that case absolutely **anything** can happen, including sometimes getting the correct answer. — Bo Persson, Jan 15 '16 at 19:40

score 6 · Answer 1 · answered Jan 15 '16 at 13:23

6

The range [−32767, +32767] is the required minimum range. An implementation is allowed to provide a larger range.

answered Jan 15 '16 at 13:23

Bo Persson

90,663
31
146
203

2

I think it's `[-32768, 32767]`. – erip Jan 15 '16 at 13:24
4

@erip - No, that's a common range for 16-bit two's complement systems. But the absolute minimum is slightly smaller to also allow sign-magnitude and one's complement. – Bo Persson Jan 15 '16 at 13:26
Ah, interesting! TIL. Thanks for keeping me honest. +1 – erip Jan 15 '16 at 13:26
5

@erip *I think it's `[-32768, 32767]`* No. See **[5.2.4.2.1 Sizes of integer types ``](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf)** – Andrew Henle Jan 15 '16 at 13:27

score 5 · Answer 2 · answered Jan 15 '16 at 13:23

All types are compiler-dependent. int used to be the "native word" of the underlying hardware, which on 16-bit systems meant that int was 16 bits (which leads to the -32k to +32k range). When 32-bit systems started coming then int naturally followed along and became 32 bits, which can store values around -2 billion to +2 billion.

However this "native word" use for int didn't follow along when 64-bit systems came around, I know of no 64-bit system or compiler that have int being 64 bits.

See e.g. this reference of integer types for more information.

TemplateRex · Answer 3 · 2016-01-15T13:28:29.527

4

In C++, int is at least 16-bits long, but typically 32-bits on modern hardware. You can write INT_MIN and INT_MAX and check yourself.

Note that signed integer overflow is undefined behavior, you are not guaranteed to get a warning, except perhaps with high compiler warnings and debug mode.

edited Jan 15 '16 at 13:28

answered Jan 15 '16 at 13:22

TemplateRex

69,038
19
164
304

There are implementations where INT_MAX is 2147483648, but sizeof(int) is 1. (On such machines, CHAR_BIT will be 32.) – Martin Bonner supports Monica Jan 15 '16 at 13:25
@MartinBonner ok, yes, strictly speaking one should divide by `CHAR_BIT`. Changed the answer to look at `INT_MAX`. – TemplateRex Jan 15 '16 at 13:29

score 3 · Accepted Answer · answered Jan 15 '16 at 13:25

3

You have misunderstood. The standard guarantees that a int holds [-32767, +32767], but it is permitted to hold more. (In particular, nearly every compiler you are likely to use allows a range [-2147483648, 2147483647]).

There is another problem. If you make the value you assign to a and b bigger you still probably won't get any warning or error. Integer overflow causes "undefined behaviour", and literally anything is allowed to happen.

answered Jan 15 '16 at 13:25

Martin Bonner supports Monica

28,528
3
51
88

"If a sum exceed that number" ... anything can happen. See this bug report where GCC converted a loop from 0 to 64 to an infinite loop which overwrote all of memory because there was signed integer overflow within the loop. https://gcc.gnu.org/bugzilla/show_bug.cgi?id=33498 – Martin Bonner supports Monica Jan 15 '16 at 13:50
2147483647seems to be the upper limit, thank you. If a sum exceed that number, the result is negative, wich is expected, BUT if it is a subtraction, for example: 2147483649-2147483647=2 the result is still good. I mean, why the value 2147483649 is correctly hold for that substraction purpose (or at least it seems to me)? – ikeeki Jan 15 '16 at 13:51
1

You are getting (un)lucky. 2147483649 overflows, and results in an `int` with value -2147483647. Subtracting 2147483647 from that *should* result in -4294967294, but *that* underflows and you end up with +2. *HOWEVER* beware that arithmetic overflow is undefined behaviour, and the compiler may assume it doesn't happen - and all sorts of thing go wrong when it does. – Martin Bonner supports Monica Jan 15 '16 at 15:11

score 1 · Answer 5 · answered Jan 15 '16 at 13:49

1

If an int is four bytes an unsigned is 4294967295, signed max. 2147483647 and signed min. -2147483648

unsigned int ui = ~0;
int max = ui>>1;
int min = ~max;
int size = sizeof(max);

answered Jan 15 '16 at 13:49

kometen

6,536
6
41
51

score 0 · Answer 6 · answered Jan 15 '16 at 13:24

0

While the standard guarantees the size of int to be 16 bit, it is usually implemented as a 32-bit value.

answered Jan 15 '16 at 13:24

adjan

13,371
2
31
48

score 0 · Answer 7 · answered Jan 15 '16 at 13:31

The size of an int (and the max value it can hold) depends on the compiler and the computer you are using. There is no guarantee that it will have 2 bytes or 4 bytes, but there is a guaranteed minimum size for the c++ variables.

You can see a list of minimum sizes for c++ types in this page: http://www.cplusplus.com/doc/tutorial/variables/

Why can I operate with int > +32767?

7 Answers7