Data Types in C: int, float, char, double, and More

Every variable in C has a type, chosen when you declare it and fixed for its lifetime. The type decides three things: how many bytes the variable occupies, how those bytes are interpreted, and what operations make sense on it.

C's type list is short. The complexity is in the modifiers.

The Four Base Types

#include <stdio.h>

int main(void) {
    char  initial = 'K';        /* one character / one byte */
    int   count   = 42;         /* whole number */
    float ratio   = 3.14f;      /* decimal, single precision */
    double precise = 3.141592653589793;  /* decimal, double precision */

    printf("char:   %c\n", initial);
    printf("int:    %d\n", count);
    printf("float:  %f\n", ratio);
    printf("double: %.15f\n", precise);
    return 0;
}

• char holds one byte. It is used for single characters ('A'), for the bytes of a string, and sometimes as a tiny integer.
• int is the workhorse whole-number type. Loop counters, sizes, IDs.
• float and double hold real numbers. double has roughly twice the precision.
• void is the fourth type in a sense, but it means "no value" - you cannot declare a void variable, only use it as a function return type, an empty parameter list, or a typeless pointer.

Note the f suffix on 3.14f. Without it the literal is a double, and assigning it to a float loses precision silently. Some compilers warn about it.

Modifiers: short, long, unsigned

The base integer types come with modifiers that change the size or the sign.

#include <stdio.h>

int main(void) {
    short small = 32000;
    int normal = 2000000;
    long big = 2000000000L;
    long long huge = 9000000000000000000LL;

    unsigned int positive_only = 4000000000U;

    printf("short:        %hd\n", small);
    printf("int:          %d\n", normal);
    printf("long:         %ld\n", big);
    printf("long long:    %lld\n", huge);
    printf("unsigned int: %u\n", positive_only);
    return 0;
}

Each integer type needs its own format specifier: %hd for short, %d for int, %ld for long, %lld for long long, %u for unsigned. Using the wrong one is undefined behavior, not a rounding error.

unsigned removes the sign bit and doubles the positive range. An unsigned int holds 0 to about 4.3 billion instead of -2.1 to +2.1 billion. It is the right choice for things that genuinely cannot be negative - sizes, counts of bytes, bit patterns - and a trap for anything that might be subtracted below zero.

signed is the default for int, short, long, and long long, so you almost never write it. The one place it matters is char: whether plain char is signed or unsigned is implementation-defined, so write signed char or unsigned char when the sign matters.

Sizes: What You Actually Get

The C standard specifies minimums, not exact sizes. On any modern 64-bit Linux, macOS, or Windows machine you will see this:

The long row is the one that catches people: it is 8 bytes on Linux and macOS, and 4 bytes on 64-bit Windows. Code that assumes long can hold a 64-bit value is not portable. Use long long, or the exact-width types from stdint.h (int32_t, uint64_t) when the size is part of the requirement.

sizeof: Ask the Compiler

Never guess a size - measure it:

#include <stdio.h>

int main(void) {
    printf("char:        %zu byte(s)\n", sizeof(char));
    printf("short:       %zu bytes\n", sizeof(short));
    printf("int:         %zu bytes\n", sizeof(int));
    printf("long:        %zu bytes\n", sizeof(long));
    printf("long long:   %zu bytes\n", sizeof(long long));
    printf("float:       %zu bytes\n", sizeof(float));
    printf("double:      %zu bytes\n", sizeof(double));
    printf("a pointer:   %zu bytes\n", sizeof(int *));
    return 0;
}

sizeof is an operator, not a function, and it is evaluated at compile time. It yields a value of type size_t, which prints with %zu.

sizeof(char) is guaranteed to be exactly 1 - that is the definition of a byte in C. Everything else is measured relative to it.

limits.h and float.h

The exact ranges for your compiler are available as named constants:

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

int main(void) {
    printf("INT_MIN      = %d\n", INT_MIN);
    printf("INT_MAX      = %d\n", INT_MAX);
    printf("UINT_MAX     = %u\n", UINT_MAX);
    printf("LONG_MAX     = %ld\n", LONG_MAX);
    printf("CHAR_BIT     = %d bits per byte\n", CHAR_BIT);
    printf("FLT_DIG      = %d decimal digits\n", FLT_DIG);
    printf("DBL_DIG      = %d decimal digits\n", DBL_DIG);
    return 0;
}

These are the values to compare against when you need to know whether an operation will overflow. Checking if (a > INT_MAX - b) before computing a + b is how you detect overflow before it happens - which matters, because you cannot detect signed overflow after.

Integer Overflow

What happens when a value exceeds its type's range depends entirely on the sign.

Unsigned overflow is defined: the value wraps modulo 2^N.

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

int main(void) {
    unsigned int u = UINT_MAX;
    printf("UINT_MAX     = %u\n", u);
    printf("UINT_MAX + 1 = %u\n", u + 1);   /* guaranteed to be 0 */

    unsigned int zero = 0;
    printf("0 - 1        = %u\n", zero - 1); /* wraps to UINT_MAX */
    return 0;
}

That second case is a real source of bugs. A loop like for (unsigned i = n - 1; i >= 0; i--) never ends, because an unsigned value is always >= 0.

Signed overflow is undefined behavior. Not "wraps around" - undefined. The compiler is allowed to assume it never happens and optimize on that basis, which means an overflow check written after the fact can be deleted:

int sum = a + b;
if (sum < a) { /* the compiler may remove this entirely */ }

Check before, using the limits:

if (b > 0 && a > INT_MAX - b) {
    /* a + b would overflow - handle it */
}

Floating-Point Precision

float and double store numbers in binary, and most decimal fractions have no exact binary form - the same way 1/3 has no exact decimal form.

#include <stdio.h>

int main(void) {
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    printf("0.1 + 0.2 = %.20f\n", sum);
    printf("Is it 0.3? %s\n", (sum == 0.3) ? "yes" : "no");

    /* The right way: compare within a tolerance. */
    double diff = sum - 0.3;
    if (diff < 0) diff = -diff;
    printf("Close enough? %s\n", (diff < 1e-9) ? "yes" : "no");
    return 0;
}

The rule that follows: never compare floating-point values with ==. Compare the absolute difference against a small tolerance instead.

And never use floating-point for money. Store cents as an integer; a long long of cents is exact where a double of dollars is not.

Choosing a Type

A short decision list that covers most code:

• Whole numbers: int unless you have a reason. It is the type the CPU handles most efficiently and the type that all the arithmetic rules are built around.
• Anything bigger than 2 billion: long long, or int64_t from stdint.h.
• Sizes, lengths, array indices from sizeof or strlen: size_t. It is unsigned and guaranteed large enough for any object.
• Decimals: double. Use float only to halve memory in large arrays or on embedded hardware without a double-precision unit.
• Single characters and raw bytes: char for text, unsigned char for binary data.
• True/false: bool from stdbool.h - see booleans in C.
• Exact bit widths (file formats, network protocols, hardware registers): stdint.h - uint8_t, int16_t, uint32_t, and so on.

#include <stdio.h>
#include <stdint.h>

int main(void) {
    uint8_t  flags = 0xFF;          /* exactly 8 bits, unsigned */
    int32_t  offset = -100000;      /* exactly 32 bits, signed */
    uint64_t file_size = 5000000000ULL;

    printf("flags:     %u\n", flags);
    printf("offset:    %d\n", offset);
    printf("file_size: %llu bytes\n", (unsigned long long)file_size);
    return 0;
}

Mixing Types

When you combine two different types in one expression, C converts them behind your back before doing the arithmetic. That is usually helpful and occasionally disastrous:

#include <stdio.h>

int main(void) {
    int a = 7, b = 2;

    printf("7 / 2  as ints   = %d\n", a / b);        /* 3, not 3.5 */
    printf("7 / 2  with 2.0  = %f\n", a / 2.0);      /* 3.5 */

    int  small = -1;
    unsigned int big = 1;
    printf("-1 < 1u ? %s\n", (small < big) ? "yes" : "no");  /* surprising */
    return 0;
}

The first is integer division: both operands are int, so the result is an int and the fraction is discarded. The third is worse - comparing a signed value with an unsigned one converts the signed one to unsigned, turning -1 into a huge positive number.

Those conversion rules, and how to take control of them with explicit casts, are the subject of type casting in C.