C Data Types

Every variable in C has a type, and that type decides what the variable can hold. C data types tell the compiler two things: what kind of value lives in a variable (a whole number, a decimal, a character) and how much memory to set aside for it. In this lesson, you'll meet all the basic types, see their typical sizes and ranges, and learn how to choose the right one.

What are data types in C?

A data type is a label that describes a kind of value and how it's stored in memory. Because C is statically typed, you choose the type when you declare a variable, and it never changes afterward.

The basic C data types in action

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    int age = 34;
    float temperature = 21.5f;
    double balance = 1520.75;
    char grade = 'A';
    bool is_member = true;

    printf("Age: %d\n", age);
    printf("Temperature: %.1f\n", temperature);
    printf("Balance: %.2f\n", balance);
    printf("Grade: %c\n", grade);
    printf("Member: %d\n", is_member);
    return 0;
}

Age: 34
Temperature: 21.5
Balance: 1520.75
Grade: A
Member: 1

Notice that true prints as 1. In C, a bool is really a tiny number: 1 means true and 0 means false.

int: whole numbers

int (short for integer) stores whole numbers with no decimal part, like 7, -40 or 2026. It's the type you'll use most: counters, ages, scores, quantities. On most systems an int takes 4 bytes and can hold roughly −2.1 billion to +2.1 billion.

float vs double: decimal numbers

Numbers with a decimal point are called floating-point numbers. C has two main kinds:

• float: usually 4 bytes, about 6 to 7 significant digits of precision.
• double: usually 8 bytes, about 15 to 16 significant digits. "Double" means double precision.

Let's divide 1 by 3 with each type and print ten decimal places:

#include <stdio.h>

int main(void) {
    float f = 1.0f / 3.0f;
    double d = 1.0 / 3.0;

    printf("float:  %.10f\n", f);
    printf("double: %.10f\n", d);
    return 0;
}

float:  0.3333333433
double: 0.3333333333

The float runs out of precision after about seven digits and starts showing noise. That's why double is the default choice for decimals in C. The f at the end of 21.5f or 1.0f marks the number as a float; without it, a decimal literal is a double.

char: single characters

A char holds exactly one character, written in single quotes: 'A', '7', '?'. Behind the scenes, a char is a small number (its character code), so you can print it as a letter or as a number:

#include <stdio.h>

int main(void) {
    char size = 'M';

    printf("Size: %c\n", size);
    printf("Code: %d\n", size);
    return 0;
}

Size: M
Code: 77

77 is the ASCII code for M. You'll use this trick in type conversion. Whole words like "Medium" are strings, which you'll learn in C strings.

bool: true or false

Early C had no boolean type; programmers used int with 0 and 1. The C99 standard added _Bool, and the header <stdbool.h> gives it the friendlier names bool, true and false. Include that header whenever you want to use bool.

#include <stdbool.h>

bool door_locked = true;
bool alarm_on = false;

short, long and long long

Size modifiers change how much memory an integer uses, and therefore how big a number it can hold:

• short (or short int): smaller, usually 2 bytes.
• long (or long int): at least 4 bytes; 8 bytes on 64-bit Linux and macOS, but 4 bytes on Windows.
• long long: at least 8 bytes on every system. Use it for really big whole numbers.

signed vs unsigned

By default, integer types are signed: they can be negative or positive. Adding unsigned removes the negative half and doubles the positive range. That's useful for values that can never be below zero, like a seat count.

#include <stdio.h>

int main(void) {
    unsigned int seats = 180;
    short floor_number = -2;
    long long world_population = 8100000000LL;

    printf("Seats: %u\n", seats);
    printf("Floor: %hd\n", floor_number);
    printf("World population: %lld\n", world_population);
    return 0;
}

Seats: 180
Floor: -2
World population: 8100000000

The world population is too big for a 4-byte int, so it needs long long. The LL suffix marks the literal as a long long. Each type has its own placeholder: %u for unsigned, %hd for short and %lld for long long.

C data type sizes and ranges

The C standard only sets minimum sizes, so exact sizes depend on your computer and compiler. The table shows typical values on most 64-bit systems:

You can check the sizes on your own machine with the sizeof operator.

How do you choose the right data type?

Ask yourself two questions: Does the value have decimals? and How big can it get? Then pick from this table:

Common mistakes with C data types

1. Storing a decimal in an int

int price = 9.99;   /* price becomes 9 */

An int can't hold decimals, so C silently drops the .99 and price holds 9. Use double for prices.

2. Using double quotes for a char

char grade = "A"; is wrong. Double quotes make a string, not a single character. GCC warns about converting a pointer to an integer. Use single quotes: char grade = 'A';.

3. Forgetting <stdbool.h>

Before C23, using bool without the header gives error: unknown type name 'bool'. Add #include <stdbool.h> at the top.

4. Picking a type that's too small

Storing 3 billion in an int doesn't fit in its range. For signed types this is overflow, which is undefined behavior: you usually get a wrong, often negative, number. Use long long for big counts.

Practice exercise

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    int age = 19;
    double gpa = 3.85;
    char grade = 'B';
    bool enrolled = true;

    printf("Age: %d\n", age);
    printf("GPA: %.2f\n", gpa);
    printf("Grade: %c\n", grade);
    printf("Enrolled: %d\n", enrolled);
    return 0;
}

Age: 19
GPA: 3.85
Grade: B
Enrolled: 1

What's next?

Some values, like a tax rate or the number of seats in a theater, should never change while a program runs. Learn how to lock them in with constants in C.