📦 4. Data Types in C

A data type describes the kind of data associated with an object, expression, function return value, or other declaration in C.

For example:

int age = 20;
float price = 99.50f;
char grade = 'A';

The declarations tell the compiler that these objects have different types.

             DATA TYPE
                 │
        ┌────────┼────────┐
        │        │        │
        ▼        ▼        ▼
       int     float     char
        │        │        │
        ▼        ▼        ▼
       20      99.5       A

A program works with different kinds of information.

• whole numbers
• fractional values
• characters
• very large or very small numeric values
• addresses
• collections of related data

C needs a way to distinguish these different kinds of data.

int students = 60;
float temperature = 36.5f;
char section = 'A';

These objects represent different kinds of information and therefore use different types.

C TYPES
│
├── Basic / Fundamental Types
│   ├── char
│   ├── signed integer types
│   ├── unsigned integer types
│   ├── _Bool
│   ├── float
│   ├── double
│   └── long double
│
├── void
│
├── Derived Types
│   ├── Arrays
│   ├── Pointers
│   └── Function types
│
├── Structure Types
│
├── Union Types
│
└── Enumeration Types

Start with the basic types in this lesson. Later lessons explain arrays, pointers, functions, structures, unions, and enumerations.

The char type is designed for character data and is also an integer type in C.

char grade = 'A';
char symbol = '#';

Character constants use single quotation marks.

'A'
'B'
'7'
'@'

'A'
"A"

Integer types represent whole-number values.

int count = 100;
short smallNumber = 25;
long population = 1000000L;
long long distance = 9000000000LL;

C provides several integer types because programs may need different ranges and storage requirements.

signed int temperature = -10;
unsigned int students = 500;

The unsigned keyword specifies that the type is non-negative.

float is a floating-point type used for values that may contain a fractional component.

float temperature = 36.5f;
float price = 99.99f;

The f suffix indicates a float floating constant.

3.14f

Without the suffix:

3.14

the floating constant has type double.

double is a floating-point type that normally provides more precision than float.

double pi = 3.141592653589793;

Floating-point types can approximate a wide range of values, but they cannot represent every decimal value exactly. For example, 0.1 is not exact in common binary floating-point formats.

long double is an extended floating-point type. Its precision and representation are implementation-dependent.

long double value = 3.141592653589793238L;

The L suffix identifies a long double floating constant.

C provides the built-in integer type _Bool.

_Bool isPassed = 1;

In C99 through C17, the standard header <stdbool.h> provides the spelling bool and the true and false macros. In C23, bool, true, and false are keywords.

#include <stdbool.h>

bool isPassed = true;

void represents the absence of a value or type information in several C contexts.

A common example is a function that does not return a value:

void displayMessage(void)
{
    printf("Hello");
}

A pointer to void, written void *, is a separate concept and is useful for generic object pointers.

The sizeof operator determines the size in bytes of a type or object.

#include <stdio.h>

int main(void)
{
    printf("%zu\n", sizeof(int));
    printf("%zu\n", sizeof(double));
    printf("%zu\n", sizeof(char));

    return 0;
}

sizeof(type)
     │
     ▼
number of bytes
     │
     ▼
depends on implementation

A common beginner mistake is memorizing:

int = 4 bytes
char = 1 byte
float = 4 bytes
double = 8 bytes

These are common on many modern systems, but C does not require every implementation to use exactly those sizes.

The correct way to discover the size on the current implementation is:

sizeof(type)

The header <limits.h> provides macros describing limits of integer types on the current implementation.

#include <stdio.h>
#include <limits.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);

    return 0;
}

This is safer than assuming one universal numeric range.

The header <float.h> provides information about the characteristics of floating-point types.

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

int main(void)
{
    printf("FLT_DIG = %d\n", FLT_DIG);
    printf("DBL_DIG = %d\n", DBL_DIG);

    return 0;
}

For example, these values help you check how many decimal digits a floating-point type can preserve.

C provides keywords that combine with integer and floating types to describe different type forms.

short int a;
unsigned int b;
long int c;
long long int d;

Integer types

signed
│
├── signed char
├── short
├── int
├── long
└── long long

unsigned
│
├── unsigned char
├── unsigned short
├── unsigned int
├── unsigned long
└── unsigned long long

The compiler and system determine the exact sizes and ranges. C still sets minimum requirements and rules for how the standard integer types relate to one another.

C provides three character types:

char
signed char
unsigned char

Whether plain char behaves as signed or unsigned is implementation-defined.

Integer literals can use suffixes to influence their type.

100
100U
100L
100UL
100LL
100ULL

3.14
3.14f
3.14L

When different arithmetic types participate in an expression, C may convert values according to its conversion rules.

int a = 10;
double b = 2.5;

double result = a + b;

The integer value participates in the calculation after the appropriate conversion.

       10        +        2.5
        │                  │
        │                  │
        └──────┬───────────┘
               ▼
       common arithmetic
          conversion
               │
               ▼
             12.5

Type conversion is covered in greater depth when expressions and operators are introduced.

int a = 5;
int b = 2;

printf("%d\n", a / b);

Because both operands are integers, the division is integer division and the result is 2.

Compare:

double result = 5.0 / 2.0;

Here the result is 2.5.

C also supports derived and user-defined type constructs.

int numbers[5];

int *ptr;

struct Student
{
    int roll;
};

Arrays, pointers, structures, unions, enumerations and function types will be studied separately.

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

int main(void)
{
    int age = 21;
    float height = 5.8f;
    double percentage = 87.4567;
    char grade = 'A';
    bool passed = true;

    printf("Age = %d\n", age);
    printf("Height = %.1f\n", height);
    printf("Percentage = %.4f\n", percentage);
    printf("Grade = %c\n", grade);
    printf("Passed = %d\n", passed);

    return 0;
}

Program
│
├── int
│   └── age
│
├── float
│   └── height
│
├── double
│   └── percentage
│
├── char
│   └── grade
│
├── bool
│   └── passed
│
└── printf()
    └── displays values

1. Assuming every C compiler uses exactly the same type sizes.
2. Using int for a value that cannot fit in the required range.
3. Expecting integer division to produce a fractional result.
4. Confusing char with a string.
5. Using the wrong printf() format specifier.
6. Assuming plain char is always signed.
7. Treating floating-point values as if they were always exact decimal numbers.