Contents

Introduction
Three Types of Char
The Short Int Types
The Int Types
The Long Int Types
Coming Soon: long long
Common Problems With Integer Types
The Usual Integer Conversions Coming Soon
Values In <limits.h>
A C Program To Display Integer Type Information
A C++ Program To Display Integer Type Information

Introduction

The most common source of confusion are the sizes of the integer types, and the range of values which they can hold. That is because the languages leave many features of the integer types implementation-defined, meaning that it is up to the particular compiler to determine their exact specifications. C and C++ do set minimum requirements for each of the integer types, but the compiler is free to exceed these limits.

Each compiler is required to document its implementation. This information should be available in the printed manuals, online help, or man pages which come with the compiler.

In addition, there is a required standard header named <limits.h> (<climits> in newer C++ compilers) which provides information about the integer types which can be used in your programs at run time. A compiler is not required to provide a header like <limits.h> as a readable text file, but I do not know of any compilers which do not. There are programs on this page to display the information that this file contains.

[ Top ]

Three Types Of Char

signed char
unsigned char
"plain" char (default char without signed or unsigned)

• Each of the character types occupies exactly one byte. That is, sizeof(char) == 1, by definition in C and C++, and always will.
• The header <limits.h> contains a macro, CHAR_BIT, which expands to an integer constant specifying the number of bits in the character types.
• There is a third type in addition to signed and unsigned. It is up to the compiler to decide whether "plain" char or default char is signed or unsigned.

Q: If sizeof(char) == 1, doesn't that mean that CHAR_BIT is always 8?

A: The value of CHAR_BIT is required to be at least 8. Almost all modern computers today use 8 bit bytes (technically called octets, but there are still some in production and use with other sizes, such as 9 bits. Also some processors (especially Digital Signal Processors) cannot efficiently access memory in smaller pieces than the processor's word size. There is at least one DSP I have worked with where CHAR_BIT is 24. The char types, short, and int are all 24 bits, and long is 48 bits. Even more common these days are 32 bit DSPs where all the integer types including long are 32 bits.

The one byte which is sizof(char) meets the C and C++ definition of a byte, which is the amount of memory required to store a character. It does not necessarily correspond to a machine byte.

Q: Why is it up to the compiler to decide whether the default char type is signed or unsigned?

A: This is just the way that the C language evolved. By the time a standard for the C language was being developed there were compilers which implemented ordinary char as signed, and others as unsigned. If the standard required one choice or the other it would break a lot of existing, working code.

On all compilers, "plain" char must have exactly the same representation and interpretation as either signed or unsigned char.

Many compilers offer a command line or IDE option to set default char to either signed or unsigned for compatibility with code developed on either type of system.

Q: What other differences are there between the three types of char?

A: All three types of char are different types. A pointer to one type of char cannot be assigned to a pointer to another char type without a cast. This is also true when passing a pointer as an argument to a function.

Q: What other special properties do the char types have?

A: Every bit in an object of one of the character types contributes to its value. There are no unused or padding bits.

Also every object which program can legally access can be accessed as an array of unsigned chars. There are no illegal or trap representations for an unsigned char.

Q: What range of values can the character types hold?

A: Signed char can hold all values in the range of SCHAR_MIN to SCHAR_MAX, defined in <limits.h>. SCHAR_MIN must be -127 or less (more negative), and SCHAR_MAX must be 127 or greater. Note that many compilers for processors which use a 2's complement representation support SCHAR_MIN of -128, but this is not required by the standards.

Unsigned char can hold values between 0 and UCHAR_MAX inclusive, which is required to be at least 255. If CHAR_BIT is greater than 8, UCHAR_MAX is required to be 2 ^CHAR_BIT - 1. So an implementation which uses 9 bit chars can fit values from 0 to 511 in an unsigned char.

Finally default or "plain" char can hold all the values CHAR_MIN and CHAR_MAX inclusive. If char is signed by default CHAR_MIN is equal to SCHAR_MIN and CHAR_MAX is equal to SCHAR_MAX. Otherwise the default char type is unsigned and CHAR_MIN is 0 and CHAR_MAX is equal to UCHAR_MAX.

[ Top ]

The Short Int Types

The range of the short int types:

A signed short can hold all the values between SHRT_MIN and SHRT_MAX inclusive. SHRT_MIN is required to be -32767 or less, SHRT_MAX must be at least 32767. Again, many 2's complement implementations will define SHRT_MIN to be -32768 but this is not required.

An unsigned short can hold all the values between 0 and USHRT_MAX inclusive. USHRT_MAX must be at least 65535. The short types must contain at least 16 bits to hold the required range of values.

1. Short is truly smaller than int on the implementation.
   
2. All of the required values can fit into a short.
   

[ Top ]

The Int Types

It is int which causes the greatest confusion. Some people are certain that an int has 16 bits and sizeof(int) is 2. Others are equally sure that an int has 32 bits and sizeof(int) is 4.

Who is right? On any given compiler, one or the other could be right. On some compilers, both would be wrong. I know of one compiler for a 24 bit DSP where an ini has 24 bits.

The actual range of values which the signed and unsigned int types can hold are:

A signed int can hold all the values between INT_MIN and INT_MAX inclusive. INT_MIN is required to be -32767 or less, INT_MAX must be at least 32767. Again, many 2's complement implementations will define INT_MIN to be -32768 but this is not required.

An unsigned int can hold all the values between 0 and UINT_MAX inclusive. UINT_MAX must be at least 65535. The int types must contain at least 16 bits to hold the required range of values.

[ Top ]

The Long Int Types

The range of the long int types:

A signed long can hold all the values between LONG_MIN and LONG_MAX inclusive. LONG_MIN is required to be -2147483647 or less, LONG_MAX must be at least 2147483647. Again, many 2's complement implementations will define LONG_MIN to be -2147483648 but this is not required.

An unsigned short can hold all the values between 0 and ULONG_MAX inclusive. ULONG_MAX must be at least 4294967295. The long types must contain at least 32 bits to hold the required range of values.

[ Top ]

Coming Soon: long long

There is an update to the C language standard being developed right now. It is commonly referred to as "C9x" and will probably become official in 1999 or 2000.

Included in this update are the new variable types signed and unsigned long long . The selected name comes from gcc and several other compilers which already provide this type as an extension. On 32 bit Windows compilers from Microsoft, Borland (and maybe others) this same extension has the name __int64.

While the C++ standard is quite new and most likely will not change for several years, it is almost certain that C++ compilers will add support for these types as well. The C++ compilers which come with the implementations mentioned above do.

The information on long long below is based on the draft C standard update. There are two types of long long int, signed and unsigned. If neither is specified the long long is signed. The "int" in the declaration is optional. All 6 of the following declarations are correct:

The range of the long long int types:

A signed long long can hold all the values between LLONG_MIN and LLONG_MAX inclusive. LLONG_MIN is required to be -9223372036854775807 or less, LLONG_MAX must be at least 9223372036854775807. Again, many 2's complement implementations will define LLONG_MIN to be -9223372036854775808 but this is not required.

An unsigned long long can hold all the values between 0 and ULLONG_MAX inclusive. ULLONG_MAX must be at least 18446744073709551615. The long types must contain at least 64 bits to hold the required range of values.

[ Top ]

Common Problems With Integer Types

The page listed here shows one method for Bullet Proof Integer Input Using strtol().

[ Top ]

Values In <limits.h>

Note 2: The signed and unsigned long long types are part of the draft standard update for C which is likely to become official in late 1999 or early 2000. They are not yet part of the C or C++ language.

[ Top ]

A C Program To Display Integer Type Information

#include <stdio.h>
#include <limits.h>

volatile int char_min = CHAR_MIN;

int main(void)
{
    printf("\n\n\n\n\n        Character Types\n");
    printf("Number of bits in a character: %d\n", CHAR_BIT);
    printf("Size of character types is %d byte\n", (int)sizeof(char));
    printf("Signed char min: %d max: %d\n", SCHAR_MIN, SCHAR_MAX);
    printf("Unsigned char min: 0 max: %u\n", (unsigned int)UCHAR_MAX);
    printf("Default char is ");

    if (char_min < 0)
        printf("signed\n");
    else if (char_min == 0)
        printf("unsigned\n");
    else
        printf("non-standard\n");

    printf("\n        Short Int Types\n");
    printf("Size of short int types is %d bytes\n", (int)sizeof(short));
    printf("Signed short min: %d max: %d\n", SHRT_MIN, SHRT_MAX);
    printf("Unsigned short min: 0 max: %u\n", (unsigned int)USHRT_MAX);

    printf("\n           Int Types\n");
    printf("Size of int types is %d bytes\n", (int)sizeof(int));
    printf("Signed int min: %d max: %d\n", INT_MIN, INT_MAX);
    printf("Unsigned int min: 0 max: %u\n", (unsigned int)UINT_MAX);

    printf("\n        Long Int Types\n");
    printf("Size of long int types is %d bytes\n", (int)sizeof(long));
    printf("Signed long min: %ld max: %ld\n", LONG_MIN, LONG_MAX);
    printf("Unsigned long min: 0 max: %lu\n", ULONG_MAX);

    return 0;
}

[ Top ]

A C++ Program To Display Integer Type Information

#include <iostream.h>
#include <limits.h>

volatile int char_min = CHAR_MIN;

int main(void)
{
    cout << "\n\n\n\n\n        Character Types" << endl;
    cout << "Number of bits in a character: " << CHAR_BIT << endl;
    cout << "Size of character types is " << sizeof(char) << " byte" << endl;
    cout << "Signed char min: " << SCHAR_MIN << " max: " <<SCHAR_MAX << endl;
    cout << "Unsigned char min: 0 max: " << UCHAR_MAX << endl;
    cout << "Default char is ";

    if (char_min < 0)
        cout << "signed";
    else if (char_min == 0)
        cout << "unsigned";
    else
        cout << "non-standard";
    cout << endl;

    cout << "\n        Short Int Types" << endl;
    cout << "Size of short int types is " << sizeof(short) << " bytes" << endl;
    cout << "Signed short min: " << SHRT_MIN << " max: " << SHRT_MAX << endl;
    cout << "Unsigned short min: 0 max: " << USHRT_MAX << endl;

    cout << "\n           Int Types" << endl;
    cout << "Size of int types is " << sizeof(int) << " bytes" << endl;
    cout << "Signed int min: " << INT_MIN << " max: " << INT_MAX << endl;
    cout << "Unsigned int min: 0 max: " << UINT_MAX << endl;

    cout << "\n        Long Int Types" << endl;
    cout << "Size of long int types is " << sizeof(long) << " bytes" << endl;
    cout << "Signed long min: " << LONG_MIN << " max: " << LONG_MAX << endl;
    cout << "Unsigned long min: 0 max: " << ULONG_MAX << endl;

    return 0;
}

This page validated by W3C HTML Validation Service.