# Introduction to C for Java and Python Programmers

As a Java or Python programmer, you'll find C both familiar and different. C is a procedural language that directly influenced both Java and Python, but it's lower-level, giving you more direct control over memory and hardware. Here's an introduction to help you bridge the gap.

## Core Characteristics of C

C is a compiled, statically-typed language with manual memory management. Unlike Java's JVM or Python's interpreter, C code compiles directly to machine code for your specific hardware. There's no garbage collection - you allocate and free memory yourself.

## Basic Syntax and Data Types

C syntax will look familiar with some key differences:
```c
#include <stdio.h>  // Header files use angle brackets

int main() {  // Every C program needs a main function
    // Basic data types
    int number = 42;          // Integer
    float decimal = 3.14;     // Single-precision floating point
    double precise = 3.14159; // Double-precision floating point
    char letter = 'A';        // Single character
    
    // C has no built-in boolean type (before C99)
    // Traditionally 0 is false, anything else is true
    int is_valid = 1;  // true
    
    // Output
    printf("Number: %d, Decimal: %f\n", number, decimal);
    
    return 0;  // Return value from main indicates program status
}
```

## Control Structures

Control structures are similar to Java:
```c
int value = 10;

// If-else statement
if (value > 5) {
    printf("Value is greater than 5\n");
} else if (value == 5) {
    printf("Value is equal to 5\n");
} else {
    printf("Value is less than 5\n");
}

// While loop
int counter = 0;
while (counter < 5) {
    printf("Counter: %d\n", counter);
    counter++;
}

// For loop
for (int i = 0; i < 5; i++) {
    printf("Index: %d\n", i);
}

// Switch statement
switch (value) {
    case 5:
        printf("Value is 5\n");
        break;
    case 10:
        printf("Value is 10\n");
        break;
    default:
        printf("Value is something else\n");
}
```

## Functions

Functions in C are straightforward but require explicit type declarations:
```c
// Function declaration (prototype)
int add(int a, int b);

int main() {
    int result = add(5, 3);
    printf("5 + 3 = %d\n", result);
    return 0;
}

// Function definition
int add(int a, int b) {
    return a + b;
}
```

## Arrays

Arrays in C are fixed-size and zero-indexed:
```c
// Array declaration and initialization
int numbers[5] = {1, 2, 3, 4, 5};

// Accessing elements
printf("Third element: %d\n", numbers[2]);  // Prints 3

// Array without size (compiler calculates)
char name[] = "Hello";  // Creates a 6-element array (including null terminator)

// Multi-dimensional arrays
int matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

printf("matrix[1][2] = %d\n", matrix[1][2]);  // Prints 6
```

## Strings

Unlike Java and Python, C has no built-in string type. Strings are arrays of characters terminated by a null character (`\0`):
```c
// String declaration
char greeting[] = "Hello, World!";  // Compiler adds the null terminator

// String functions require the string.h header
#include <string.h>

int main() {
    char str1[50] = "Hello";
    char str2[] = ", World!";
    
    // String length
    printf("Length: %lu\n", strlen(str1));  // 5
    
    // String concatenation
    strcat(str1, str2);
    printf("Concatenated: %s\n", str1);  // "Hello, World!"
    
    // String comparison
    if (strcmp(str1, "Hello, World!") == 0) {
        printf("Strings are equal\n");
    }
    
    return 0;
}
```

## Structs

Structs let you create custom data types by grouping related variables:
```c
// Struct definition
struct Person {
    char name[50];
    int age;
    float height;
};

int main() {
    // Creating a struct variable
    struct Person person1;
    
    // Assigning values
    strcpy(person1.name, "Alice");
    person1.age = 30;
    person1.height = 1.75;
    
    // Alternative initialization syntax
    struct Person person2 = {"Bob", 25, 1.82};
    
    // Accessing struct members
    printf("Name: %s, Age: %d, Height: %.2f\n", 
           person1.name, person1.age, person1.height);
    
    return 0;
}
```

## Pointers

Pointers are perhaps the most distinctive feature of C. They store memory addresses:
```c
int main() {
    int x = 10;
    int *ptr = &x;  // ptr stores the address of x
    
    printf("Value of x: %d\n", x);       // 10
    printf("Address of x: %p\n", &x);    // Memory address
    printf("Value of ptr: %p\n", ptr);   // Same memory address
    printf("Value at *ptr: %d\n", *ptr); // 10 (dereferencing)
    
    // Modifying value through pointer
    *ptr = 20;
    printf("New value of x: %d\n", x);   // 20
    
    return 0;
}
```

Pointers are essential for:
1. Dynamic memory allocation
2. Passing large data structures efficiently
3. Creating complex data structures like linked lists

## Dynamic Memory Allocation

Unlike Java and Python, C requires manual memory management:
```c
#include <stdlib.h>  // Required for malloc and free

int main() {
    // Allocate memory for an integer
    int *ptr = (int *)malloc(sizeof(int));
    
    // Check if allocation was successful
    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }
    
    // Use the allocated memory
    *ptr = 42;
    printf("Value: %d\n", *ptr);
    
    // Free the memory when done
    free(ptr);
    
    // Allocate an array of integers
    int *array = (int *)malloc(5 * sizeof(int));
    
    if (array != NULL) {
        for (int i = 0; i < 5; i++) {
            array[i] = i * 10;
            printf("array[%d] = %d\n", i, array[i]);
        }
        free(array);
    }
    
    return 0;
}
```

## Key Differences to Remember

1. **Manual Memory Management**: Unlike Java and Python, C has no garbage collection. You must free any memory you allocate.
2. **No Objects or Classes**: C is procedural, not object-oriented.
3. **No Exception Handling**: C uses return values to indicate errors.
4. **Pointers**: Direct memory manipulation is both C's power and danger.
5. **No Built-in Data Structures**: No lists, dictionaries, or sets; you build these yourself.

C is powerful because it's close to the hardware, but this requires more attention to detail. Start with small programs, and always check your code for memory leaks and pointer errors.