Beginner C Interview Questions and Answers

• Compiled to fast native machine code.
• Procedural: programs are built from functions.
• Low-level access: pointers, direct memory management and bitwise operations, which is why operating systems, embedded firmware and databases are written in C.
• Small and portable: a small language with a standard library, and compilers for almost every processor.
• Manual memory management with malloc and free, with no garbage collector.

Four stages, which gcc main.c -o main runs together:

1. Preprocessing: handles #include, #define and #if (gcc -E).
2. Compilation: translates C to assembly (gcc -S).
3. Assembly: turns assembly into an object file of machine code (gcc -c).
4. Linking: joins object files and libraries into an executable, resolving calls such as printf.

A missing semicolon is a compiler error; a declared but never defined function is a linker error ("undefined reference").

= assigns a value; == compares two values. Writing if (x = 5) assigns 5 to x and the condition is always true. GCC warns about this with -Wall:

int x = 3;
if (x == 5) printf("five\n");
else printf("not five\n");

not five

Dividing two integers gives an integer: the fraction is discarded (truncated towards zero). Make one operand a floating-point value:

int a = 7, b = 2;
printf("%d\n", a / b);
printf("%d\n", -7 / 2);
printf("%d\n", a % b);
printf("%.1f\n", (double)a / b);

3
-3
1
3.5

Sizes are platform-dependent; the standard only guarantees minimums (for example, int is at least 16 bits). Use sizeof to check.

break leaves the loop (or switch) completely; continue skips the rest of the current iteration and goes on to the next:

for (int i = 1; i <= 6; i++) {
    if (i == 3) continue;
    if (i == 5) break;
    printf("%d ", i);
}
printf("\n");

1 2 4 

while checks the condition first and may run zero times. do-while checks after the body, so it always runs at least once:

int n = 10;
while (n < 5) printf("while ran\n");
do { printf("do-while ran\n"); } while (n < 5);

do-while ran

• Local: declared in a block, visible only there, created on each entry, garbage if not initialised.
• Global: declared outside functions, visible to the rest of the file (and others via extern), lives for the whole program, starts at 0.
• Static local: visible only in its block but keeps its value between calls, starts at 0.

#include <stdio.h>

int calls_total;                    /* global */

void f(void) {
    int local = 0;
    static int kept = 0;
    local++;
    kept++;
    calls_total++;
    printf("%d %d %d\n", local, kept, calls_total);
}

int main(void) {
    f();
    f();
    return 0;
}

1 1 1
1 2 2

Always by value: the function receives a copy. To change a caller's variable, pass its address (a pointer):

#include <stdio.h>

void by_value(int x) { x = 99; }
void by_pointer(int *x) { *x = 99; }

int main(void) {
    int a = 1, b = 1;
    by_value(a);
    by_pointer(&b);
    printf("%d %d\n", a, b);
    return 0;
}

1 99

Arrays seem to be passed "by reference" because the array name decays to a pointer to its first element.

As an array of char ending with the null character '\0'. "cat" needs 4 bytes. strlen counts the characters before '\0'; sizeof an array gives its full size:

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

int main(void) {
    char s[10] = "cat";
    printf("%zu %zu\n", strlen(s), sizeof s);
    return 0;
}

3 10

== on two strings compares their addresses, not their characters. Use strcmp, which returns 0 when the contents are equal:

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

int main(void) {
    char a[] = "hello";
    char b[] = "hello";
    printf("%d %d\n", a == b, strcmp(a, b) == 0);
    return 0;
}

0 1

GCC even warns comparison between two arrays on a == b.

A header (.h) holds declarations shared between files: function prototypes, types, macros. A source file (.c) holds definitions: function bodies and variables. Source files #include headers, and each source file is compiled separately, then linked. See Multi-file Programs.

The clear way uses a temporary variable and pointers:

#include <stdio.h>

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

int main(void) {
    int x = 4, y = 9;
    swap(&x, &y);
    printf("%d %d\n", x, y);
    return 0;
}

9 4

Interviewers sometimes ask for a swap "without a temporary" (a ^= b; b ^= a; a ^= b;). It works for distinct variables but breaks if both pointers point to the same variable, and it is not faster.

Only divisors up to √n need checking:

#include <stdio.h>

int is_prime(int n) {
    if (n < 2) return 0;
    for (int d = 2; d * d <= n; d++) {
        if (n % d == 0) return 0;
    }
    return 1;
}

int main(void) {
    for (int n = 1; n <= 30; n++) {
        if (is_prime(n)) printf("%d ", n);
    }
    printf("\n");
    return 0;
}

2 3 5 7 11 13 17 19 23 29