{"id":4217,"date":"2020-07-04T00:01:21","date_gmt":"2020-07-04T07:01:21","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=4217"},"modified":"2025-05-26T08:53:25","modified_gmt":"2025-05-26T15:53:25","slug":"what-size-integer","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=4217","title":{"rendered":"What Size Integer?"},"content":{"rendered":"

Things were stable back in the old days. When I first coded C, a char<\/em> was 8-bits (a byte), and an int<\/em> was 16-bits. The short<\/em> was also 16-bits and the long<\/em>, it was truly long at 32-bits. Today, things aren’t as consistent.
\n
\nThe problem is that no true standard exists for the size of a C language integer data type. The only constant is that a char<\/em> is still a byte, an 8-bit value. Otherwise, to determine the size of things for a given compiler, you can run this code:<\/p>\n

2020_07_04-Lesson-a.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n    printf(\"char is %lu bits\\n\",sizeof(char)*8);\r\n    printf(\"short is %lu bits\\n\",sizeof(short)*8);\r\n    printf(\"int is %lu bits\\n\",sizeof(int)*8);\r\n    printf(\"long is %lu bits\\n\",sizeof(long)*8);\r\n    printf(\"long long is %lu bits\\n\",sizeof(long long)*8);\r\n\r\n    return(0);\r\n}<\/pre>\n
Each printf()<\/em> statement takes a given integer data type and outputs its bit width. The sizeof<\/em> operator returns the size in bytes, which are assumed to be 8-bits wide. The %lu<\/code> placeholder handles the long unsigned<\/em> value returned from the sizeof<\/em> operator.<\/p>\n
The output on my iMac appears as follows:<\/p>\n
char is 8 bits
\nshort is 16 bits
\nint is 32 bits
\nlong is 64 bits
\nlong long is 64 bits<\/code><\/p>\n
Decades ago, a short<\/em> and an int<\/em> were the same size. No more! On the Mac, a long<\/em> is 64 bits — and so is the long long<\/em>. On some systems, the long long<\/em> might be 128 bits. Who knows?<\/p>\n
Well, the compiler knows, of course. The sizeof<\/em> operator returns the width. Constants declared in the limits.h<\/code> header file also help with determining the maximum values that certain data types can handle.<\/p>\n
Beyond these tidbits, you can use special defined types that predicate their bit width right in the type definition. They are:<\/p>\n
int8_t<\/em>, an 8-bit integer
\nint16_t<\/em>, a 16-bit integer
\nint32_t<\/em>, a 32-bit integer
\nint64_t<\/em>, a 64-bit integer<\/p>\n
These typedefs are available in the stdint.h<\/code> header file, though they might also be available directly in stdio.h<\/code> — but don’t count on it! Regardless, these types define precise bit widths as their names imply. No matter how the compiler interprets a short<\/em>, int<\/em>, or long<\/em>, these data types remain consistent, as this sample code demonstrates:<\/p>\n
2020_07_04-Lesson-b.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <stdint.h>\r\n\r\nint main()\r\n{\r\n    printf(\"int8_t is %lu bits\\n\",sizeof(int8_t)*8);\r\n    printf(\"int16_t is %lu bits\\n\",sizeof(int16_t)*8);\r\n    printf(\"int32_t is %lu bits\\n\",sizeof(int32_t)*8);\r\n    printf(\"int64_t is %lu bits\\n\",sizeof(int64_t)*8);\r\n\r\n    return(0);\r\n}<\/pre>\n
The output:<\/p>\n
int8_t is 8 bits
\nint16_t is 16 bits
\nint32_t is 32 bits
\nint64_t is 64 bits<\/code><\/p>\n
There. Consistency.<\/p>\n
Two variations exist for each of these defined data types, least<\/em> and fast<\/em>. The least version ensures that the values use at least the bit width specified:<\/p>\n
int_least8_t<\/em>, at least an 8-bit integer
\nint_least16_t<\/em>, at least a 16-bit integer
\nint_least32_t<\/em>, at least a 32-bit integer
\nint_least64_t<\/em>, at least a 64-bit integer<\/p>\n
For example, int_least8_t<\/em> has a minimum width of 8-bits.<\/p>\n
I’m unsure what the fast variation does:<\/p>\n
int_fast8_t<\/em>, a fast 8-bit integer
\nint_fast16_t<\/em>, a fast 16-bit integer
\nint_fast32_t<\/em>, a fast 32-bit integer
\nint_fast64_t<\/em>, a fast 64-bit integer<\/p>\n
Internally and at least on the Mac, the stdint.h<\/code> header typedef’s all these variations to the basic definitions. These types most likely exist for compatibility purposes only.<\/p>\n
Another data type not yet available in C is the variable width integer. The varint<\/em> declares its bit width and then ensures that all declared variables use the given width. This additional data type sounds interesting and would be a fun addition to C in the future.<\/p>\n","protected":false},"excerpt":{"rendered":"
Is an int<\/em> the same as a short<\/em> or a long<\/em>? The number of bits in an integer isn’t really defined. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-4217","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4217","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=4217"}],"version-history":[{"count":8,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4217\/revisions"}],"predecessor-version":[{"id":7018,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/4217\/revisions\/7018"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=4217"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=4217"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=4217"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}