examples

/**
 * Passing Arrays to Functions - Examples
 * 
 * This file demonstrates various techniques for passing
 * arrays to functions in C.
 * 
 * Compile: gcc examples.c -o examples
 * Run: ./examples
 */

#include <stdio.h>
#include <stdlib.h>

/* ============================================================
 * EXAMPLE 1: Basic Array Passing (1D)
 * ============================================================ */

// Method 1: Array notation
void printArray_v1(int arr[], int size) {
    printf("Method 1 (arr[]): ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// Method 2: Pointer notation
void printArray_v2(int *arr, int size) {
    printf("Method 2 (*arr):  ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// Method 3: Sized array (size ignored by compiler)
void printArray_v3(int arr[100], int size) {
    printf("Method 3 ([100]): ");
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void example1_basic_passing(void) {
    printf("=== EXAMPLE 1: Basic Array Passing ===\n\n");
    
    int numbers[] = {10, 20, 30, 40, 50};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    // All three methods work the same way
    printArray_v1(numbers, size);
    printArray_v2(numbers, size);
    printArray_v3(numbers, size);
    
    printf("\nAll three declarations are equivalent!\n");
}


/* ============================================================
 * EXAMPLE 2: Demonstrating Array Decay to Pointer
 * ============================================================ */

void showArrayDecay(int arr[], int size) {
    printf("Inside function:\n");
    printf("  sizeof(arr) = %zu (pointer size, NOT array size)\n", sizeof(arr));
    printf("  arr points to: %p\n", (void*)arr);
}

void example2_array_decay(void) {
    printf("\n=== EXAMPLE 2: Array Decay to Pointer ===\n\n");
    
    int numbers[] = {1, 2, 3, 4, 5};
    
    printf("In main():\n");
    printf("  sizeof(numbers) = %zu (actual array size)\n", sizeof(numbers));
    printf("  numbers address: %p\n", (void*)numbers);
    
    printf("\n");
    showArrayDecay(numbers, 5);
    
    printf("\nNotice: sizeof gives different values!\n");
}


/* ============================================================
 * EXAMPLE 3: Modifying Array Elements (Pass by Reference)
 * ============================================================ */

void doubleElements(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        arr[i] *= 2;  // Modifies original array!
    }
}

void example3_modify_array(void) {
    printf("\n=== EXAMPLE 3: Modifying Array Elements ===\n\n");
    
    int values[] = {1, 2, 3, 4, 5};
    int size = 5;
    
    printf("Before doubleElements(): ");
    for (int i = 0; i < size; i++) {
        printf("%d ", values[i]);
    }
    printf("\n");
    
    doubleElements(values, size);
    
    printf("After doubleElements():  ");
    for (int i = 0; i < size; i++) {
        printf("%d ", values[i]);
    }
    printf("\n");
    
    printf("\nOriginal array was modified!\n");
}


/* ============================================================
 * EXAMPLE 4: Using const to Prevent Modification
 * ============================================================ */

int calculateSum(const int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
        // arr[i] = 0;  // ERROR! Cannot modify const array
    }
    return sum;
}

double calculateAverage(const int arr[], int size) {
    if (size == 0) return 0.0;
    return (double)calculateSum(arr, size) / size;
}

void example4_const_arrays(void) {
    printf("\n=== EXAMPLE 4: Using const for Safety ===\n\n");
    
    int data[] = {10, 20, 30, 40, 50};
    int size = 5;
    
    printf("Array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", data[i]);
    }
    printf("\n");
    
    printf("Sum: %d\n", calculateSum(data, size));
    printf("Average: %.2f\n", calculateAverage(data, size));
    
    printf("\nArray unchanged (const protected it)\n");
}


/* ============================================================
 * EXAMPLE 5: Passing 2D Arrays - Fixed Columns
 * ============================================================ */

#define COLS 4

void print2DArray(int arr[][COLS], int rows) {
    printf("2D Array (%d x %d):\n", rows, COLS);
    for (int i = 0; i < rows; i++) {
        printf("  ");
        for (int j = 0; j < COLS; j++) {
            printf("%3d ", arr[i][j]);
        }
        printf("\n");
    }
}

void example5_2d_array_passing(void) {
    printf("\n=== EXAMPLE 5: Passing 2D Arrays ===\n\n");
    
    int matrix[3][COLS] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    
    print2DArray(matrix, 3);
}


/* ============================================================
 * EXAMPLE 6: Passing 2D Arrays - Pointer to Array
 * ============================================================ */

void print2DArray_ptr(int (*arr)[4], int rows) {
    printf("Using pointer to array notation:\n");
    for (int i = 0; i < rows; i++) {
        printf("  ");
        for (int j = 0; j < 4; j++) {
            printf("%3d ", arr[i][j]);
        }
        printf("\n");
    }
}

void example6_pointer_to_array(void) {
    printf("\n=== EXAMPLE 6: Pointer to Array Notation ===\n\n");
    
    int data[2][4] = {
        {10, 20, 30, 40},
        {50, 60, 70, 80}
    };
    
    print2DArray_ptr(data, 2);
    
    printf("\nint (*arr)[4] means: pointer to array of 4 ints\n");
}


/* ============================================================
 * EXAMPLE 7: Variable Length Arrays (C99)
 * ============================================================ */

void printVLA(int rows, int cols, int arr[rows][cols]) {
    printf("VLA (%d x %d):\n", rows, cols);
    for (int i = 0; i < rows; i++) {
        printf("  ");
        for (int j = 0; j < cols; j++) {
            printf("%3d ", arr[i][j]);
        }
        printf("\n");
    }
}

void example7_vla_passing(void) {
    printf("\n=== EXAMPLE 7: Variable Length Arrays (C99) ===\n\n");
    
    int small[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int large[3][5] = {
        {1, 2, 3, 4, 5},
        {6, 7, 8, 9, 10},
        {11, 12, 13, 14, 15}
    };
    
    printVLA(2, 3, small);
    printf("\n");
    printVLA(3, 5, large);
    
    printf("\nSame function works for any dimensions!\n");
}


/* ============================================================
 * EXAMPLE 8: Search Function Pattern
 * ============================================================ */

int linearSearch(const int arr[], int size, int target) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {
            return i;  // Found at index i
        }
    }
    return -1;  // Not found
}

void example8_search_pattern(void) {
    printf("\n=== EXAMPLE 8: Search Function Pattern ===\n\n");
    
    int numbers[] = {15, 3, 99, 42, 7, 55, 23};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    printf("Array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", numbers[i]);
    }
    printf("\n\n");
    
    int targets[] = {42, 100, 15, 23};
    
    for (int i = 0; i < 4; i++) {
        int result = linearSearch(numbers, size, targets[i]);
        if (result != -1) {
            printf("Found %d at index %d\n", targets[i], result);
        } else {
            printf("%d not found\n", targets[i]);
        }
    }
}


/* ============================================================
 * EXAMPLE 9: Aggregation Functions
 * ============================================================ */

int findMax(const int arr[], int size) {
    int max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

int findMin(const int arr[], int size) {
    int min = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    return min;
}

void findMinMax(const int arr[], int size, int *min, int *max) {
    *min = *max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < *min) *min = arr[i];
        if (arr[i] > *max) *max = arr[i];
    }
}

void example9_aggregation(void) {
    printf("\n=== EXAMPLE 9: Aggregation Functions ===\n\n");
    
    int data[] = {45, 12, 89, 3, 67, 23, 56, 91, 8, 34};
    int size = sizeof(data) / sizeof(data[0]);
    
    printf("Array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", data[i]);
    }
    printf("\n\n");
    
    printf("Sum: %d\n", calculateSum(data, size));
    printf("Average: %.2f\n", calculateAverage(data, size));
    printf("Max: %d\n", findMax(data, size));
    printf("Min: %d\n", findMin(data, size));
    
    int min, max;
    findMinMax(data, size, &min, &max);
    printf("Range: %d to %d\n", min, max);
}


/* ============================================================
 * EXAMPLE 10: Array Modification Patterns
 * ============================================================ */

void reverseArray(int arr[], int size) {
    for (int i = 0; i < size / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[size - 1 - i];
        arr[size - 1 - i] = temp;
    }
}

void rotateLeft(int arr[], int size) {
    if (size <= 1) return;
    
    int first = arr[0];
    for (int i = 0; i < size - 1; i++) {
        arr[i] = arr[i + 1];
    }
    arr[size - 1] = first;
}

void rotateRight(int arr[], int size) {
    if (size <= 1) return;
    
    int last = arr[size - 1];
    for (int i = size - 1; i > 0; i--) {
        arr[i] = arr[i - 1];
    }
    arr[0] = last;
}

void example10_modification(void) {
    printf("\n=== EXAMPLE 10: Array Modification Patterns ===\n\n");
    
    int arr1[] = {1, 2, 3, 4, 5};
    int size = 5;
    
    printf("Original:     ");
    for (int i = 0; i < size; i++) printf("%d ", arr1[i]);
    printf("\n");
    
    reverseArray(arr1, size);
    printf("Reversed:     ");
    for (int i = 0; i < size; i++) printf("%d ", arr1[i]);
    printf("\n");
    
    int arr2[] = {1, 2, 3, 4, 5};
    rotateLeft(arr2, size);
    printf("Rotate Left:  ");
    for (int i = 0; i < size; i++) printf("%d ", arr2[i]);
    printf("\n");
    
    int arr3[] = {1, 2, 3, 4, 5};
    rotateRight(arr3, size);
    printf("Rotate Right: ");
    for (int i = 0; i < size; i++) printf("%d ", arr3[i]);
    printf("\n");
}


/* ============================================================
 * EXAMPLE 11: Sorting with Array Functions
 * ============================================================ */

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void bubbleSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(&arr[j], &arr[j + 1]);
            }
        }
    }
}

void selectionSort(int arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        int minIdx = i;
        for (int j = i + 1; j < size; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        if (minIdx != i) {
            swap(&arr[i], &arr[minIdx]);
        }
    }
}

void example11_sorting(void) {
    printf("\n=== EXAMPLE 11: Sorting Functions ===\n\n");
    
    int arr1[] = {64, 34, 25, 12, 22, 11, 90};
    int arr2[] = {64, 34, 25, 12, 22, 11, 90};
    int size = 7;
    
    printf("Original:       ");
    for (int i = 0; i < size; i++) printf("%d ", arr1[i]);
    printf("\n");
    
    bubbleSort(arr1, size);
    printf("Bubble Sorted:  ");
    for (int i = 0; i < size; i++) printf("%d ", arr1[i]);
    printf("\n");
    
    selectionSort(arr2, size);
    printf("Selection Sort: ");
    for (int i = 0; i < size; i++) printf("%d ", arr2[i]);
    printf("\n");
}


/* ============================================================
 * EXAMPLE 12: Filter and Copy Pattern
 * ============================================================ */

int filterEven(const int src[], int srcSize, int dest[]) {
    int count = 0;
    for (int i = 0; i < srcSize; i++) {
        if (src[i] % 2 == 0) {
            dest[count++] = src[i];
        }
    }
    return count;  // Return new size
}

int filterGreaterThan(const int src[], int srcSize, int dest[], int threshold) {
    int count = 0;
    for (int i = 0; i < srcSize; i++) {
        if (src[i] > threshold) {
            dest[count++] = src[i];
        }
    }
    return count;
}

void example12_filter_copy(void) {
    printf("\n=== EXAMPLE 12: Filter and Copy Pattern ===\n\n");
    
    int source[] = {1, 8, 3, 12, 5, 20, 7, 15, 9, 4};
    int size = sizeof(source) / sizeof(source[0]);
    
    printf("Source: ");
    for (int i = 0; i < size; i++) printf("%d ", source[i]);
    printf("\n\n");
    
    int evenNumbers[10];
    int evenCount = filterEven(source, size, evenNumbers);
    printf("Even numbers: ");
    for (int i = 0; i < evenCount; i++) printf("%d ", evenNumbers[i]);
    printf("(count: %d)\n", evenCount);
    
    int largeNumbers[10];
    int largeCount = filterGreaterThan(source, size, largeNumbers, 10);
    printf("Numbers > 10: ");
    for (int i = 0; i < largeCount; i++) printf("%d ", largeNumbers[i]);
    printf("(count: %d)\n", largeCount);
}


/* ============================================================
 * EXAMPLE 13: Matrix Operations with Functions
 * ============================================================ */

#define MAT_SIZE 3

void initializeMatrix(int matrix[][MAT_SIZE], int rows) {
    int value = 1;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < MAT_SIZE; j++) {
            matrix[i][j] = value++;
        }
    }
}

void printMatrix(int matrix[][MAT_SIZE], int rows, const char *name) {
    printf("%s:\n", name);
    for (int i = 0; i < rows; i++) {
        printf("  ");
        for (int j = 0; j < MAT_SIZE; j++) {
            printf("%3d ", matrix[i][j]);
        }
        printf("\n");
    }
}

void transposeMatrix(int src[][MAT_SIZE], int dest[][MAT_SIZE], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < MAT_SIZE; j++) {
            dest[j][i] = src[i][j];
        }
    }
}

void addMatrices(int a[][MAT_SIZE], int b[][MAT_SIZE], 
                 int result[][MAT_SIZE], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < MAT_SIZE; j++) {
            result[i][j] = a[i][j] + b[i][j];
        }
    }
}

void example13_matrix_operations(void) {
    printf("\n=== EXAMPLE 13: Matrix Operations ===\n\n");
    
    int matrixA[MAT_SIZE][MAT_SIZE];
    int matrixB[MAT_SIZE][MAT_SIZE] = {
        {9, 8, 7},
        {6, 5, 4},
        {3, 2, 1}
    };
    int transposed[MAT_SIZE][MAT_SIZE];
    int sum[MAT_SIZE][MAT_SIZE];
    
    initializeMatrix(matrixA, MAT_SIZE);
    
    printMatrix(matrixA, MAT_SIZE, "Matrix A");
    printf("\n");
    printMatrix(matrixB, MAT_SIZE, "Matrix B");
    printf("\n");
    
    transposeMatrix(matrixA, transposed, MAT_SIZE);
    printMatrix(transposed, MAT_SIZE, "A Transposed");
    printf("\n");
    
    addMatrices(matrixA, matrixB, sum, MAT_SIZE);
    printMatrix(sum, MAT_SIZE, "A + B");
}


/* ============================================================
 * EXAMPLE 14: Returning Results via Output Parameters
 * ============================================================ */

void getStatistics(const int arr[], int size, 
                   int *min, int *max, double *avg) {
    *min = *max = arr[0];
    int sum = arr[0];
    
    for (int i = 1; i < size; i++) {
        if (arr[i] < *min) *min = arr[i];
        if (arr[i] > *max) *max = arr[i];
        sum += arr[i];
    }
    
    *avg = (double)sum / size;
}

void example14_output_parameters(void) {
    printf("\n=== EXAMPLE 14: Multiple Return Values ===\n\n");
    
    int scores[] = {85, 92, 78, 95, 88, 76, 91, 83};
    int size = sizeof(scores) / sizeof(scores[0]);
    
    printf("Scores: ");
    for (int i = 0; i < size; i++) printf("%d ", scores[i]);
    printf("\n\n");
    
    int min, max;
    double avg;
    
    getStatistics(scores, size, &min, &max, &avg);
    
    printf("Statistics:\n");
    printf("  Minimum: %d\n", min);
    printf("  Maximum: %d\n", max);
    printf("  Average: %.2f\n", avg);
}


/* ============================================================
 * MAIN FUNCTION
 * ============================================================ */

int main(void) {
    printf("╔══════════════════════════════════════════════════════╗\n");
    printf("║   PASSING ARRAYS TO FUNCTIONS - EXAMPLES             ║\n");
    printf("╚══════════════════════════════════════════════════════╝\n");
    
    example1_basic_passing();
    example2_array_decay();
    example3_modify_array();
    example4_const_arrays();
    example5_2d_array_passing();
    example6_pointer_to_array();
    example7_vla_passing();
    example8_search_pattern();
    example9_aggregation();
    example10_modification();
    example11_sorting();
    example12_filter_copy();
    example13_matrix_operations();
    example14_output_parameters();
    
    printf("\n════════════════════════════════════════════════════════\n");
    printf("All examples completed!\n");
    
    return 0;
}