C how many bytes in an int

Most of the textbooks say integer variables occupy 2 bytes. But when I run a program printing the successive addresses of an array of integers it shows the difference of 4. I know it's equal to sizeof int. The size of an int is really compiler dependent. Back in the day, when processors were 16 bit, an int was 2 bytes.

Nowadays, it's most often 4 bytes on a bit as well as bit systems. Still, using sizeof int is the best way to get the size of an integer for the specific system the program is executed on. EDIT: Fixed wrong statement that int is 8 bytes on most bit systems. For example, it is 4 bytes on bit GCC. This is one of the points in C that can be confusing at first, but the C standard only specifies a minimum range for integer types that is guaranteed to be supported.

In that case, int , is 2 bytes. However, implementations are free to go beyond that minimum, as you will see that many modern compilers make int bit which also means 4 bytes pretty ubiquitously. The reason your book says 2 bytes is most probably because it's old. At one time, this was the norm. In general, you should always use the sizeof operator if you need to find out how many bytes it is on the platform you're using.

Prior to that, there was no universal way to get an integer of a specific width although most platforms provided similar types on a per-platform basis. There's no specific answer. It depends on the platform. It is implementation-defined. It can be 2, 4 or something else. The idea behind int was that it was supposed to match the natural "word" size on the given platform: 16 bit on bit platforms, 32 bit on bit platforms, 64 bit on bit platforms, you get the idea.

However, for backward compatibility purposes some compilers prefer to stick to bit int even on bit platforms. The time of 2-byte int is long gone though bit platforms? Your textbooks are probably very old. The answer to this question depends on which platform you are using. But irrespective of platform, you can reliably assume the following types:.

The size of int and all other integer types are implementation defined, C99 only specifies:. That depends on the platform you're using, as well as how your compiler is configured. The only authoritative answer is to use the sizeof operator to see how big an integer is in your specific situation.

Range might be best considered, rather than size. Both will vary in practice, though it's much more fool-proof to choose variable types by range than size as we shall see. The following statement, taken from the C standard linked to above , describes this in words that I don't think can be improved upon. The sizeof operator yields the size in bytes of its operand, which may be an expression or the parenthesized name of a type. The size is determined from the type of the operand.

Assuming a clear understanding will lead us to a discussion about bytes. That's just another one of those nuances which isn't considered when talking about the common two or four byte integers. That's not necessarily useful information, is it? Let's delve deeper From this, we can derive a minimum for how many bits are required to store the value , but we may as well just choose our variables based on ranges.

Nonetheless, a huge part of the detail required for this answer resides here. For example, the following that the standard unsigned int requires at least sixteen bits of storage:.

This explains the phenomena you've observed:. You should upgrade your textbook and compiler , and strive to remember that I. Enough about that, though; let's see what other non-portable secrets those underlying integer bytes store Value bits are what the common misconceptions appear to be counting.

The above example uses an unsigned integer type which typically contains only value bits, so it's easy to miss the devil in the detail. Sign bits For signed types, in order to distinguish between positive and negative values that's the sign , we need to also include the sign bit. Padding bits While it's not common to encounter computers that have padding bits in integers, the C standard allows that to happen; some machines i.

That wasted bit is considered padding in C. Other examples of padding bits might include parity bits and trap bits. So, one byte in C is not necessarily an octet , i. While bit machines are mostly dead, there are still platforms with nonbit bytes. The minimum value is 0, the maximum value is 65 The size of the int type is 4 bytes 32 bits.

The minimal value is -2 , the maximal one is 2 The unsigned integer type is uint. It takes 4 bytes of memory and allows expressing integers from 0 to 4 The size of the long type is 8 bytes 64 bits. Although recompiling will still be required.

The first two runs went according to plan. It tried very hard to bring in a decimal number. It found the character 0 in our input, which is a valid decimal digit, so it started parsing that character.

But it next encountered the x character which is not valid for a base 10 number. So that was the end of the parsing and our program converted the value 0 into each of the three bases. Try running this program yourself and switch the mode a few times.

Do you get the behavior you expect? Can you cause any errors? It should be possible to accept any of the three bases for input without the big if statement. Starting out on limited hardware like C did means occasionally working with data at the bit level quite apart from printing or reading in binary data. C supports this work with bitwise operators. These operators allow you to tweak individual bits inside int variables or char or long , of course.

Table describes these operators and shows some examples that make use of the following two variables:. You can technically apply bitwise operators to any variable type to tweak particular bits.

They are rarely used on floating point types, though. You usually pick an integral type that is big enough to hold however many individual bits you need. One size rarely fits all, so remember your options and pick one that balances between ease of use and any resource constraints you have. We now have enough elements of C under our belts to start writing some really interesting code. We can combine all of our previous discussions on bits, arrays, types, looping, and branching to tackle a popular way of encoding binary data in text.

One format for transmitting binary data through networks of devices with potentially limited resources is to convert it to simple lines of text. The 64 comes from the fact that this encoding uses 6-bit chunks, and 2 to the 6th power is For this encoding, values 0 through 25 are the uppercase letters A through Z. Values 26 through 51 are the lowercase letters a through z. Values 52 through 61 are the digits 0 through 9, and finally, value 62 is the plus sign, and 63 is the forward slash.

Yes, they are. We can use this new knowledge to change those 8-bit chunks into 6-bit chunks. Figure shows a small example of converting three bytes into a string of base64 text. These happen to be the first few bytes of a valid JPEG file, but you could work on any source you like. This is a fairly trivial bit of binary data, of course, but it will validate our algorithm.

We have nine bytes total to encode in our example, but really we just want to take things three bytes at a time, like the illustration, and repeat. Sounds like a job for a loop! The next big step is getting the four 6-bit chunks into our buffer.

We can use our bitwise operators to grab what we need. Look back at Table The leftmost six bits of byte1 make up our first 6-bit chunk. In this case, we can just shift those six bits to the right two slots:. One down, three to go. The second 6-bit chunk, though, is a little messy because it uses the two remaining bits from byte1 and four bits from byte2. First, take the right two bits from byte1 and scoot them to the left four spaces to make room for the rest of our 6-bit chunk.

Now, take the left four bits from byte2 , scoot them to the right four spaces, and put them into buffer[1] without disturbing the upper half of that variable. In this case, we take and scoot the right four bits of byte2 and scoot them over two slots to make room for the left two bits of byte3.

But like before, we have to scoot those two bits all the way to the right first. Our last 6-bit chunk is another easy one. We just want the right six bits of byte4 , no scooting required:. We have successfully done the 3x8-bit to 4x6-bit conversion! Now we just need to print out each of the values in our buffer array.

Sounds like another loop. We could list out all 64 cases in a switch , but that feels tedious. It would be very self-documenting, at least.

As you read this next snippet, see if you can figure out how that character math is working its magic:. Does the character math make sense? If we add one to the character A , we get B. Add two to A and we get C , etc. For the lowercase letters and the digits, we first have to realign our buffered value so it is in a range starting at zero.

The last two cases are easy, since we have one value that maps directly to one character. Hopefully, we never hit our else clause, but that is exactly what those clauses are for.

If we got something wrong, print out a warning! Those are some impressive moving parts. As always, I encourage you to type in the program yourself, making any adjustments you want or adding any comments to help you remember what you learned. You can also compile the encode Very, very cool. Congratulations, by the way! That is a nontrivial bit of code there. You should be proud. But if you want to really test your skills, try writing your own decoder to reverse this process.

If you start with the output above, do you get the original nine bytes? Whether or not you tackle decoding the base64 encoded string, hopefully you tried converting the values in Table yourself. You can compare your answers here. Or use the rosetta.

And if you are only storing small, yes or no, on or off type values, C has several operators that make it possible to squeeze those values into the individual bits of a larger data type like an int.

Modern desktops rarely require that much attention to detail, but some of our Arduino options in the latter half of this book care very much! Think about this book, for example. It is not made up of one, excessive run-on sentence. It is broken into chapters. Those chapters, in turn, are broken into sections. Those sections are broken into paragraphs. It is usually easier to discuss a single paragraph than it is an entire book. C allows you to perform this type of breakdown for your own logic.

And once you have the logic in digestible blocks, you can use those blocks just like we have been doing with the printf and scanf functions. Your operating system or version, compiler version, or even the conditions on your system at runtime can all affect the output. The point is to be careful not to overflow your arrays.

This is a compile-time flag that is off by default. Skip to main content. Smaller C by Marc Loy. Start your free trial. Chapter 4. Bits and Many Bytes Before we start building more complex programs with things like functions in Chapter 5 , we should cover two more useful storage categories in C: arrays and individual bits. Storing Multiple Things with Arrays It is almost impossible to find a C program tackling real-world problems that does not use arrays.

Figure An empty array of type char called name.