Data Types in C

📖 Introduction

Data types specify the type of data a variable can hold. C is a statically-typed language, meaning you must declare the type of each variable before using it. Understanding data types is fundamental to writing correct and efficient C programs.

---

🎯 Categories of Data Types

                        C Data Types
                             │
        ┌────────────────────┼────────────────────┐
        │                    │                    │
   Primary/Basic        Derived             User-Defined
        │                    │                    │
   ┌────┴────┐         ┌─────┴─────┐        ┌────┴────┐
   │         │         │           │        │         │
 Integer   Floating   Arrays    Pointers  Structures  Unions
   │       Point      Functions            typedef    enum
   │         │
 int      float
 char     double
 short    long double
 long
 long long

---

📊 Primary (Basic) Data Types

1. Integer Types

Integer types store whole numbers (no decimal point).

Integer Declaration Examples:

// Signed integers (can hold negative values)
int age = 25;
short temperature = -10;
long population = 7800000000L;
long long bigNumber = 9223372036854775807LL;

// Unsigned integers (only positive values)
unsigned int count = 100;
unsigned long fileSize = 4294967295UL;

Integer Literal Suffixes:

int a = 100;        // int
long b = 100L;      // long
long long c = 100LL; // long long
unsigned d = 100U;  // unsigned int
unsigned long e = 100UL;  // unsigned long

Integer in Different Bases:

int decimal = 42;       // Decimal (base 10)
int octal = 052;        // Octal (base 8) - starts with 0
int hex = 0x2A;         // Hexadecimal (base 16) - starts with 0x
int binary = 0b101010;  // Binary (base 2) - C23, starts with 0b

2. Floating-Point Types

Floating-point types store decimal numbers.

Floating-Point Declaration Examples:

float price = 19.99f;           // Note: 'f' suffix for float
double pi = 3.14159265358979;   // More precision
long double precise = 3.14159265358979323846L;  // Maximum precision

Floating-Point Literal Suffixes:

float f = 3.14f;        // float (f or F suffix)
double d = 3.14;        // double (default)
long double ld = 3.14L; // long double (L suffix)

Scientific Notation:

double avogadro = 6.022e23;     // 6.022 × 10²³
double planck = 6.626e-34;      // 6.626 × 10⁻³⁴
float small = 1.5E-10f;         // 1.5 × 10⁻¹⁰

3. Character Type

The char type stores a single character (1 byte).

char letter = 'A';          // Character literal
char newline = '\n';        // Escape sequence
char digit = '5';           // Character '5' (not integer 5)
char asciiValue = 65;       // Also 'A' (ASCII value)

ASCII Values:

Escape Sequences:

4. Void Type

void represents "no type" or "no value."

// Function that returns nothing
void printMessage(void) {
    printf("Hello!\n");
}

// Void pointer (generic pointer)
void *ptr;

// Function with no parameters
int getValue(void) {
    return 42;
}

---

📏 Size and Range Verification

The exact size of data types can vary by system. Use sizeof to check:

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

int main() {
    // Check sizes
    printf("char: %zu bytes\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));

    // Check ranges (from limits.h)
    printf("\nint range: %d to %d\n", INT_MIN, INT_MAX);
    printf("unsigned int max: %u\n", UINT_MAX);

    // Check float limits (from float.h)
    printf("\nfloat max: %e\n", FLT_MAX);
    printf("double max: %e\n", DBL_MAX);

    return 0;
}

limits.h Constants:

float.h Constants:

---

🔄 Type Modifiers

Modifiers change the properties of basic types:

signed and unsigned

signed int x = -10;     // Can hold negative (default for int)
unsigned int y = 10;    // Only positive, larger range

signed char a = -100;   // -128 to 127
unsigned char b = 200;  // 0 to 255

short and long

short int small = 100;      // At least 16 bits
long int large = 1000000L;  // At least 32 bits
long long int huge = 10000000000LL;  // At least 64 bits

Modifier Combinations:

unsigned long int value = 4000000000UL;
signed short int temp = -32000;
long long unsigned int bigPositive = 18000000000000000000ULL;

---

🎨 Format Specifiers Summary

Format Modifiers:

printf("%10d\n", 42);      // Right-aligned, width 10
printf("%-10d\n", 42);     // Left-aligned, width 10
printf("%010d\n", 42);     // Zero-padded, width 10
printf("%.2f\n", 3.14159); // 2 decimal places
printf("%8.2f\n", 3.14159);// Width 8, 2 decimal places
printf("%+d\n", 42);       // Show sign

---

⚠️ Common Mistakes

1. Overflow

int max = 2147483647;
int overflow = max + 1;  // OVERFLOW! Wraps to -2147483648

unsigned char c = 255;
c = c + 1;  // Wraps to 0

2. Precision Loss

float f = 123456789.0f;  // May lose precision
printf("%f\n", f);        // Might print 123456792.000000

double d = 123456789.0;  // Better precision

3. Integer Division

int a = 5, b = 2;
float result = a / b;     // result = 2.0, not 2.5!
float correct = (float)a / b;  // result = 2.5

4. Uninitialized Variables

int x;  // Contains garbage value!
printf("%d", x);  // Undefined behavior

---

✅ Best Practices

1. •Use int for most integer needs - it's the natural size for the CPU
2. •Use double for floating-point - unless memory is critical
3. •Use unsigned for non-negative values - like sizes, counts
4. •Always initialize variables - avoid undefined behavior
5. •Check for overflow - especially in loops and calculations
6. •Use size_t for array indices - guaranteed to be large enough
7. •Use stdint.h for exact sizes - int32_t, uint64_t, etc.

Fixed-Width Types (stdint.h):

#include <stdint.h>

int8_t   a;  // Exactly 8 bits, signed
uint8_t  b;  // Exactly 8 bits, unsigned
int16_t  c;  // Exactly 16 bits, signed
uint16_t d;  // Exactly 16 bits, unsigned
int32_t  e;  // Exactly 32 bits, signed
uint32_t f;  // Exactly 32 bits, unsigned
int64_t  g;  // Exactly 64 bits, signed
uint64_t h;  // Exactly 64 bits, unsigned

---

🔑 Key Takeaways

1. •C has four basic types: char, int, float, double
2. •Modifiers (signed, unsigned, short, long) alter type properties
3. •Size varies by system - use sizeof() to check
4. •Use correct format specifiers - mismatches cause undefined behavior
5. •Understand overflow - values wrap around at type limits
6. •void means "no type" - used for functions and generic pointers

---

⏭️ Next Topic

Continue to Variables and Constants to learn how to declare and use variables.