C Programming Interview Questions & Answers

#include <stdio.h>

int main() {
    printf("Hello, C Program!\n"); // Output statement
    return 0; // Indicate successful execution
}

int num;
printf("Enter a number: ");
scanf("%d", &num);
printf("You entered: %d\n", num);

int num = 10;
int *ptr; // Declaration
ptr = # // Initialization

int numbers[5]; // Declares an integer array of size 5
numbers[0] = 10; // Assigns value to the first element
int x = numbers[0]; // Accesses the first element

#include <stdio.h>

void swap_val(int a, int b) { // Call by value
    int temp = a; a = b; b = temp; // Changes local copies
}

void swap_ref(int *a, int *b) { // Call by reference
    int temp = *a; *a = *b; *b = temp; // Changes original values
}

int main() {
    int x = 10, y = 20;
    swap_val(x, y); // x and y remain 10, 20
    printf("Call by Value: x=%d, y=%d\n", x, y);

    x = 10, y = 20;
    swap_ref(&x, &y); // x and y become 20, 10
    printf("Call by Reference: x=%d, y=%d\n", x, y);
    return 0;
}

#include <stdio.h>
void func() {
    static int counter = 0; // Initialized once, retains value
    counter++;
    printf("Counter: %d\n", counter);
}
int main() { func(); func(); return 0; } // Output: Counter: 1, Counter: 2

char greeting[] = "Hello"; // String literal, null-terminated automatically
char name[20];
strcpy(name, "World"); // Copy "World" into name

int a;
double b;
printf("Size of int: %zu bytes\n", sizeof(a));
printf("Size of double: %zu bytes\n", sizeof(double));

int arr[10];
printf("Size of array arr: %zu bytes\n", sizeof(arr));

for (int i = 0; i < 5; i++) {
    if (i == 2) continue; // Skips 2
    if (i == 4) break;    // Exits at 4
    printf("%d ", i);    // Output: 0 1 3
}

#include <stdlib.h>
int *ptr = (int *)malloc(sizeof(int));
if (ptr != NULL) {
    *ptr = 100;
    free(ptr);
    ptr = NULL;
}

int *arr1 = (int *)malloc(5 * sizeof(int));
int *arr2 = (int *)calloc(5, sizeof(int));

int x = 10;
void *ptr = &x;
printf("Value: %d\n", *(int *)ptr); // Cast to int* before dereferencing

int add(int a, int b) { return a + b; }

int main() {
    int (*func_ptr)(int, int); // Declare function pointer
    func_ptr = &add;           // Assign address of add function

    int result = func_ptr(5, 3); // Call function via pointer
    printf("Result: %d\n", result); // Output: Result: 8
    return 0;
}

unsigned char a = 5; // 00000101
unsigned char b = 3; // 00000011
unsigned char c = a & b; // 00000001 (1)

FILE *fp = fopen("example.txt", "w");
if (fp != NULL) {
    fprintf(fp, "Hello, File!");
    fclose(fp);
}

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("Program name: %s\n", argv[0]);
    for (int i = 1; i < argc; i++) {
        printf("Argument %d: %s\n", i, argv[i]);
    }
    return 0;
}

int num_int = 10;
double num_double = (double)num_int; // int to double

float pi = 3.14f;
int int_pi = (int)pi; // float to int (truncates decimal part)

int sum = 10, count = 3;
double average = (double)sum / count; // Ensures float division

#include <stdio.h>

// Recursive function to calculate factorial
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1; // Base case
    } else {
        return n * factorial(n - 1); // Recursive step
    }
}

int main() {
    printf("Factorial of 5: %d\n", factorial(5)); // Output: 120
    return 0;
}

enum Weekday {
    SUNDAY,    // 0 by default
    MONDAY,    // 1
    TUESDAY = 5, // Explicitly set to 5
    WEDNESDAY, // 6
    THURSDAY,
    FRIDAY,
    SATURDAY
};

enum Weekday today = MONDAY;
printf("Today is %d\n", today); // Output: Today is 1

    // file1.c
    static int count = 0; // Only visible in file1.c
    int global_var = 10; // Visible everywhere
    

    // file1.c
    static void helper_function() { /* ... */ }
    

// file1.c
int global_counter = 0; // Definition

// file2.c
extern int global_counter; // Declaration, refers to global_counter in file1.c

void increment_counter() {
    global_counter++;
}

// 2D array: 3 rows, 4 columns
int matrix[3][4];

// Initialization during declaration
int board[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

// Accessing an element (row 1, column 2)
int value = board[1][2]; // value will be 6

// Iterating through a 2D array
for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        printf("%d ", board[i][j]);
    }
    printf("\n");
}

int x = 10; // x is an Lvalue, 10 is an Rvalue
int *p = &x; // p is an Lvalue, &x is an Rvalue (address of x)
*p = 20;    // *p is an Lvalue, 20 is an Rvalue
(x + 5) = 15; // Error: (x + 5) is an Rvalue, cannot be assigned to

#include <stdio.h>
#define MAX_LINE_LENGTH 256

int main() {
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL) { /* error handling */ return 1; }

    char line[MAX_LINE_LENGTH];
    while (fgets(line, MAX_LINE_LENGTH, fp) != NULL) {
        printf("Read: %s", line); // line already contains \n
    }
    fclose(fp);
    return 0;
}

#define PI 3.14159
#ifdef DEBUG
    #define LOG(msg) printf("DEBUG: %s\n", msg)
#else
    #define LOG(msg)
#endif

typedef unsigned long ulong; // Alias for unsigned long
ulong my_id = 12345UL;

typedef struct Point {
    int x;
    int y;
} Point; // Alias for 'struct Point'
Point p1 = {10, 20};

typedef int (*Operation)(int, int); // Alias for a function pointer
int add(int a, int b) { return a + b; }
Operation op_ptr = add;

#include <stdio.h>

void modifyArray(int *arr, int size) { // Receives a pointer
    for (int i = 0; i < size; i++) {
        arr[i] = arr[i] * 2; // Modifies original array elements
    }
}

int main() {
    int my_array[] = {1, 2, 3, 4, 5};
    int n = sizeof(my_array) / sizeof(my_array[0]);

    printf("Original array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", my_array[i]);
    }
    printf("\n");

    modifyArray(my_array, n); // Pass array name (decays to pointer)

    printf("Modified array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", my_array[i]);
    }
    printf("\n");

    return 0;
}

#include <stdio.h>
#include <string.h>

enum MessageType {
    INT_MSG,
    FLOAT_MSG,
    STRING_MSG
};

struct Message {
    enum MessageType type;
    union {
        int int_val;
        float float_val;
        char str_val[20];
    } payload;
};

int main() {
    struct Message msg;

    msg.type = INT_MSG;
    msg.payload.int_val = 123;
    printf("Int message: %d\n", msg.payload.int_val);

    msg.type = FLOAT_MSG;
    msg.payload.float_val = 3.14f;
    printf("Float message: %.2f\n", msg.payload.float_val);

    msg.type = STRING_MSG;
    strcpy(msg.payload.str_val, "Hello Union");
    printf("String message: %s\n", msg.payload.str_val);

    // Note: accessing int_val after setting str_val would be undefined behavior
    return 0;
}

void *ptr = malloc(10);
// ptr++; // Error: invalid use of void expression
char *byte_ptr = (char *)ptr;
byte_ptr++; // OK: increments by 1 byte

struct Example {
    char c;    // 1 byte
    int i;     // 4 bytes (might have 3 bytes padding after c)
    short s;   // 2 bytes (might have 2 bytes padding after i)
}; // Total size could be 12 or 16 bytes depending on alignment

struct OptimizedExample {
    int i;     // 4 bytes
    short s;   // 2 bytes
    char c;    // 1 byte (less padding overall)
}; // Total size likely 8 bytes

void copy_data(int *restrict dest, const int *restrict src, int n) {
    for (int i = 0; i < n; i++) {
        dest[i] = src[i];
    }
}

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

struct Node {
    int data;
    struct Node *next; // Pointer to the next node of type Node
};

int main() {
    struct Node *head = (struct Node *)malloc(sizeof(struct Node));
    head->data = 10;
    head->next = NULL; // Initially, points to nothing

    struct Node *second = (struct Node *)malloc(sizeof(struct Node));
    second->data = 20;
    second->next = NULL;

    head->next = second; // Link head to second node

    printf("First node data: %d\n", head->data);
    printf("Second node data: %d\n", head->next->data);

    free(head);
    free(second);
    return 0;
}

    int (*ptr_to_array)[5]; // ptr_to_array is a pointer to an array of 5 integers
    int arr[5] = {1, 2, 3, 4, 5};
    ptr_to_array = &arr; // Assigns the address of the entire array
    printf("%d\n", (*ptr_to_array)[0]); // Dereference and access element
    

    int *arr_of_ptr[5]; // arr_of_ptr is an array of 5 integer pointers
    int a=10, b=20;
    arr_of_ptr[0] = &a; // Element 0 points to 'a'
    arr_of_ptr[1] = &b; // Element 1 points to 'b'
    printf("%d\n", *arr_of_ptr[0]); // Access via pointer in array