C Type Modifiers

Types of Modifiers

short int x;    // 2 bytes
long int y;     // 4-8 bytes
long long z;    // 8 bytes

signed int a;    // +/- values
unsigned int b;  // + values only

static int count;
extern int global_var;
register int fast_var;

const int readonly = 10;
volatile int hardware_reg;

🔹 Size Modifiers

Size modifiers change memory allocation for data types to accommodate different value ranges efficiently. The short modifier reduces size for memory conservation, while long increases size for larger value ranges. Use short int (typically 2 bytes) for small integers or long int (typically 4-8 bytes) for large integers. Proper size selection balances between memory usage and range requirements, enabling optimized programs for memory-constrained environments.

#include <stdio.h>

int main() {
    short int small = 32000;
    int normal = 100000;
    long int large = 2000000000L;
    long long int huge = 9000000000000000000LL;
    
    printf("short int: %d (size: %zu bytes)\n", small, sizeof(small));
    printf("int: %d (size: %zu bytes)\n", normal, sizeof(normal));
    printf("long int: %ld (size: %zu bytes)\n", large, sizeof(large));
    printf("long long: %lld (size: %zu bytes)\n", huge, sizeof(huge));
    
    return 0;
}

short int: 32000 (size: 2 bytes)
int: 100000 (size: 4 bytes)
long int: 2000000000 (size: 8 bytes)
long long: 9000000000000000000 (size: 8 bytes)

🔹 Sign Modifiers

Sign modifiers control whether variables can store negative values or only non-negative values. By default, integer types are signed, accommodating both positive and negative numbers. Use unsigned to restrict variables to non-negative values, doubling the maximum positive range. For example, unsigned int ranges from 0 to 4,294,967,295 instead of including negative values. Selecting proper sign types prevents overflow and enables efficient representation for applications using only positive numbers.

#include <stdio.h>

int main() {
    signed int temperature = -15;      // Can be negative
    unsigned int age = 25;             // Only positive
    unsigned char ascii_code = 255;    // 0 to 255
    signed char offset = -50;          // -128 to 127
    
    printf("Temperature: %d°C\n", temperature);
    printf("Age: %u years\n", age);
    printf("ASCII code: %u\n", ascii_code);
    printf("Offset: %d\n", offset);
    
    // Demonstrating range
    printf("\nRanges:\n");
    printf("unsigned char: 0 to %u\n", (unsigned char)-1);
    printf("signed char: %d to %d\n", (signed char)(1 << 7), (signed char)((1 << 7) - 1));
    
    return 0;
}

Temperature: -15°C
Age: 25 years
ASCII code: 255
Offset: -50

Ranges:
unsigned char: 0 to 255
signed char: -128 to 127

🔹 Combining Modifiers

Combine multiple modifiers to create specialized types meeting specific memory and range requirements. For example, unsigned long int combines unsignedness with extended size for very large non-negative integers. Use short signed int for small signed integers or unsigned short for small non-negative integers. Combining modifiers enables fine-tuning data types for performance-critical applications, embedded systems, and specialized algorithms requiring precise memory management.

#include <stdio.h>

int main() {
    unsigned short int port_number = 8080;
    unsigned long int file_size = 4294967295UL;
    signed long long int timestamp = -1234567890123LL;
    
    const unsigned int MAX_USERS = 1000;
    static long int counter = 0;
    
    counter++;
    
    printf("Port: %u\n", port_number);
    printf("File size: %lu bytes\n", file_size);
    printf("Timestamp: %lld\n", timestamp);
    printf("Max users: %u\n", MAX_USERS);
    printf("Counter: %ld\n", counter);
    
    // Size information
    printf("\nSizes:\n");
    printf("unsigned short: %zu bytes\n", sizeof(unsigned short int));
    printf("unsigned long: %zu bytes\n", sizeof(unsigned long int));
    printf("signed long long: %zu bytes\n", sizeof(signed long long int));
    
    return 0;
}

Port: 8080
File size: 4294967295 bytes
Timestamp: -1234567890123
Max users: 1000
Counter: 1

Sizes:
unsigned short: 2 bytes
unsigned long: 8 bytes
signed long long: 8 bytes