C Handout · ⁨Cハンド아웃⁩

Every C program starts in main. #include <stdio.h> pulls in a header 头文件 so you can use printf to print. A function 函数 is a named block you can call; \n starts a new line. main returns 0 to mean "success".

#include <stdio.h>

void greet(void) {
    printf("Hello, world!\n");
}

int main(void) {
    greet();
    printf("I am learning C.\n");
    return 0;
}

C needs a type for every variable: int (integer 整数), double (floating-point 浮点数), char (one character). printf uses a format specifier 格式说明符 — %d, %f, %c — for each value. / between two ints is integer division; % is the remainder 余数.

#include <stdio.h>

int main(void) {
    int n = 17;
    double pi = 3.14;
    char grade = 'A';
    printf("%d %.2f %c\n", n, pi, grade);   // 17 3.14 A
    printf("%d %d\n", 7 / 2, 7 % 2);        // 3 1
    return 0;
}

The format string drives both printing and reading:

scanf("%d", &n) reads keyboard input with the same specifiers (note the &). Its sibling sscanf parses values out of a string, so it runs anywhere:

#include <stdio.h>

int main(void) {
    char line[] = "Mei 88";
    char name[20];
    int score;
    sscanf(line, "%19s %d", name, &score);   // parse text -> values
    printf("%s scored %d\n", name, score);   // Mei scored 88
    return 0;
}

A comment 注释 is a note for humans; the compiler ignores it. Use // for one line and /* ... */ for a block. Good indentation 缩进 and clear names make code easy to read.

#include <stdio.h>

int main(void) {
    // a single-line comment
    /* a block
       comment */
    int total = 3 + 4;       // clear names help
    printf("%d\n", total);   // 7
    return 0;
}

Common mistakes

• Every statement ends with ;, and main should return int (return 0;).
• printf needs a format string: %d for int, %f for double, and \n for a new line.
• A wrong format like %d for a double prints garbage — match the type.

if는 조건이 참일 때 블록을 실행합니다. C는 기본적으로 진정한 부울리/type이 없습니다: 0은 false이고 0이 아닌 모든 값은 true입니다. else if와 else으로 선택을 체인할 수 있습니다. ==, !=, <, >, <=, >=과 비교하십시오.

#include <stdio.h>

int main(void) {
    int score = 72;
    if (score >= 90) {
        printf("A\n");
    } else if (score >= 60) {
        printf("Pass\n");
    } else {
        printf("Fail\n");
    }
    return 0;
}

switch은 정수 값으로 하나의 case을 선택합니다. 각 case에는 빠져나가기 위한 break이 필요하며, 없으면 C는 다음 case로 'fall through'됩니다.matched ничего when nothing matches runs default runs when nothing matches.

#include <stdio.h>

int main(void) {
    int day = 3;
    switch (day) {
        case 1: printf("Mon\n"); break;
        case 2: printf("Tue\n"); break;
        case 3: printf("Wed\n"); break;
        default: printf("Other\n");
    }
    return 0;
}

Common mistakes

• if (x = 5)는 할당하고 항상 참입니다; ==을 사용하여 비교하십시오.
• 각 switch 케이스에는 break;이 필요합니다. 그렇지 않으면 다음 케이스로Fall through됩니다.
• 조건식에서 0는 false이고, 0이 아닌 모든 값은 true입니다.

루프는 블록을 반복합니다. while 루프는 조건이 true인 동안 실행됩니다. for 루프는 시작값, 테스트 조건, 증가량(i++)을 한 줄에 묶습니다 — 반복 횟수를 미리 알 때 가장 좋습니다.

#include <stdio.h>

int main(void) {
    int i = 1;
    while (i <= 3) {
        printf("%d ", i);
        i++;
    }
    printf("\n");                    // 1 2 3
    for (int j = 0; j < 5; j++) {
        printf("%d ", j);
    }
    printf("\n");                    // 0 1 2 3 4
    return 0;
}

일반적인 패턴: accumulator를 0로 시작하여 루프 내부에서 더합니다. 같은 아이디어로 항목을 세거나 누적 합계를 구할 수 있습니다.

#include <stdio.h>

int main(void) {
    int total = 0;
    for (int i = 1; i <= 5; i++) {
        total += i;            // 1 + 2 + 3 + 4 + 5
    }
    printf("%d\n", total);     // 15
    return 0;
}

루프 안의 루프는 중첩 루프입니다. 외부 루프의 각 단계마다 내부 루프가 완전히 끝납니다 — 격자나 패턴을 만들기에 완벽합니다.

#include <stdio.h>

int main(void) {
    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 3; col++) {
            printf("*");
        }
        printf("\n");
    }
    return 0;
}

Common mistakes

• for (i = 0; i < n; i++)는 n번 실행됩니다; for (...) 바로 뒤에 세미콜론이 있으면 빈 루프가 됩니다.
• 조건이 절대 false가 되지 않는 while는 무한 루프가 됩니다.
• 카운터(int i)를 for 헤더 sebelum 또는 안에 선언합니다.

함수는 매개변수(입력)를 받아 반환 값을 돌려줍니다. 반환 유형이 먼저 오고(int, double, …); void는 아무것도 반환하지 않음을 의미합니다.

#include <stdio.h>

int square(int x) {        // x is a parameter
    return x * x;          // hand back a value
}

int main(void) {
    int r = square(5);
    printf("%d\n", r);     // 25
    return 0;
}

C는 위에서 아래로 읽으므로 함수는 호출되기 전에 알려져야 합니다. 프로토타입 — 헤더 줄과 ; — 는 일찍 선언되어 main를 최상단에 두게 합니다. 변수의 scope는 그 변수가 존재하는 블록입니다: 로컬이며 블록이 끝나면 사라집니다.

#include <stdio.h>

int add(int a, int b);     // prototype: declared before use

int main(void) {
    printf("%d\n", add(3, 4));   // 7
    return 0;
}

int add(int a, int b) {    // definition comes later
    int sum = a + b;       // sum is local to add
    return sum;
}

Common mistakes

• 정의되기 전에 사용되는 함수 위에는 main 위에 프로타입이 있어야 합니다.
• 인자는 BY VALUE로 전달됩니다 — 함수 내부의 변경 사항은 포인터를 전달하지 않는 한 caller에 영향을 주지 않습니다.
• 함수 내에서宣言된 변수는 해당 함수에 국한된 로컬 변수입니다.

An array 数组 holds several values of one type. Index 索引 from 0. C does not store an array's length, so a common trick computes the element 元素 count: sizeof(a) / sizeof(a[0]).

#include <stdio.h>

int main(void) {
    int scores[3] = {88, 71, 95};
    printf("%d\n", scores[0]);     // 88
    scores[1] = 100;
    printf("%d\n", scores[1]);     // 100
    int n = sizeof(scores) / sizeof(scores[0]);
    printf("%d\n", n);             // 3
    return 0;
}

Traverse 遍历 an array with a for loop to find a max, a total, or a count. Always loop from 0 up to n - 1.

#include <stdio.h>

int main(void) {
    int a[] = {3, 9, 2, 7};
    int n = sizeof(a) / sizeof(a[0]);
    int max = a[0], total = 0;
    for (int i = 0; i < n; i++) {
        if (a[i] > max) max = a[i];
        total += a[i];
    }
    printf("%d %d\n", max, total);   // 9 21
    return 0;
}

A 2-D array is a grid of rows 行 and columns 列: grid[row][col]. Use two nested loops to visit every cell.

#include <stdio.h>

int main(void) {
    int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
    printf("%d\n", grid[1][2]);    // 6
    for (int r = 0; r < 2; r++) {
        for (int c = 0; c < 3; c++) {
            printf("%d ", grid[r][c]);
        }
    }
    printf("\n");                  // 1 2 3 4 5 6
    return 0;
}

Common mistakes

• C does NOT check array bounds: writing a[n] in a size-n array is undefined behaviour.
• Valid indexes run from 0 to n - 1.
• The array name is a pointer to its first element; sizeof only gives the size in the array's own scope.

A pointer 指针 stores the address 地址 of a variable. &x gives the address of x; *p dereferences 解引用 the pointer — it reads or writes the value stored there. Passing a pointer lets a function change the caller's variable (pass-by-pointer).

#include <stdio.h>

void addOne(int *p) {     // p holds an address
    *p = *p + 1;          // change the value at that address
}

int main(void) {
    int x = 10;
    int *ptr = &x;        // & takes the address of x
    printf("%d\n", *ptr); // * reads the value: 10
    addOne(&x);
    printf("%d\n", x);    // 11 — changed through the pointer
    return 0;
}

The classic use is a swap function. Passing values only copies them — the swap is lost. Passing pointers lets the function reach the caller's variables:

#include <stdio.h>

void swap_values(int a, int b) {      // copies: the caller sees nothing
    int t = a; a = b; b = t;
}

void swap_pointers(int *a, int *b) {  // addresses: the swap is real
    int t = *a; *a = *b; *b = t;
}

int main(void) {
    int x = 1, y = 2;
    swap_values(x, y);
    printf("%d %d\n", x, y);   // 1 2  (unchanged!)
    swap_pointers(&x, &y);
    printf("%d %d\n", x, y);   // 2 1  (swapped)
    return 0;
}

An array name acts as a pointer to its first element, and pointer arithmetic 指针运算 steps by whole elements:

#include <stdio.h>

int main(void) {
    int a[] = {10, 20, 30};
    int *p = a;                 // same as &a[0]
    printf("%d\n", *p);         // 10
    printf("%d\n", *(p + 2));   // 30 — same as a[2]
    return 0;
}

• NULL is the pointer that points at nothing — check for it before you dereference.

Common mistakes

• &x is the address of x; *p is the value stored at p.
• Never use *p on an uninitialised or NULL pointer — it crashes or corrupts memory.
• To change a caller's variable, pass its address and write through the pointer.

A C string 字符串 is an array of char. Every string ends with a hidden null terminator 空终止符 '\0', which marks where it stops. strlen (from <string.h>) counts characters up to that '\0'. Print a whole string with %s and one character 字符 with %c.

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

int main(void) {
    char name[] = "Mei";            // 'M', 'e', 'i', '\0'
    printf("%s\n", name);           // Mei
    printf("%zu\n", strlen(name));  // 3 (stops at '\0')
    printf("%c\n", name[0]);        // M
    return 0;
}

You can traverse a string by looping until you reach '\0'.

#include <stdio.h>

int main(void) {
    char word[] = "banana";
    int count = 0;
    for (int i = 0; word[i] != '\0'; i++) {
        if (word[i] == 'a') count++;
    }
    printf("%d\n", count);   // 3
    return 0;
}

struct는 관련된 값들을 하나의 유형에 묶습니다. 각 값은 멤버입니다. typedef은 struct에 짧은 이름을 부여하여 Dog을 struct Dog 대신 쓸 수 있게 합니다. struct 값에는 .을 사용하되, struct 포인터에는 ->을 사용합니다.

#include <stdio.h>

typedef struct {
    char name[20];
    int age;
} Dog;

int main(void) {
    Dog d = {"Rex", 3};
    printf("%s is %d\n", d.name, d.age);   // Rex is 3   (. on a value)

    Dog *p = &d;
    p->age = 4;                            // -> on a pointer
    printf("%s is %d\n", d.name, d.age);   // Rex is 4
    return 0;
}

Common mistakes

• struct value에는 .를 사용하고, struct pointer에는 ->을 사용하십시오.
• typedef는Declaration 시 word struct을 생략하게 해줍니다; 없으면 struct Point p;를 써야 합니다.
• 한 struct를 다른 struct에 할당하면 모든 필드를 복사합니다.

malloc allocates 分配 memory on the heap 堆 at run time and returns a pointer to it. realloc resizes that block; free gives it back. Every malloc needs a matching free, or you get a memory leak 内存泄漏. These live in <stdlib.h>.

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

int main(void) {
    int n = 3;
    int *a = malloc(n * sizeof(int));    // room for 3 ints
    for (int i = 0; i < n; i++) a[i] = i * 10;

    a = realloc(a, 4 * sizeof(int));     // grow to 4 ints
    a[3] = 30;

    for (int i = 0; i < 4; i++) printf("%d ", a[i]);
    printf("\n");                        // 0 10 20 30

    free(a);                             // hand the memory back
    return 0;
}

• calloc(n, size) allocates an array like malloc AND fills it with zeros.

Common mistakes

• Every malloc needs a matching free; forgetting to free leaks memory.
• Using memory after free (a "use-after-free") is a serious bug.
• Check that malloc did not return NULL before you use the memory.

연결リスト는 노드의 사슬입니다. 각 노드는 값과 next 노드에 대한 포인터를 유지하며, 마지막 노드는 NULL을 가리킵니다. 배열과는 달리, 연결리스트는 malloc로 한 번에 하나의 노드를 추가하여 확장됩니다. 작업이 완료되면 항상 모든 노드를 free해야 합니다.

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

typedef struct Node {
    int value;
    struct Node *next;
} Node;

int main(void) {
    Node *head = NULL;
    for (int v = 10; v <= 30; v += 10) {   // prepend 10, 20, 30
        Node *n = malloc(sizeof(Node));
        n->value = v;
        n->next = head;
        head = n;
    }
    for (Node *p = head; p != NULL; p = p->next) {
        printf("%d ", p->value);           // 30 20 10
    }
    printf("\n");

    while (head != NULL) {                 // free the whole list
        Node *t = head;
        head = head->next;
        free(t);
    }
    return 0;
}

스택은 LIFO(후입력 우선출력)입니다: 같은 끝에서 push와 pop을 수행합니다. 큐는 FIFO(전입력 우선출력)입니다: 뒤쪽에서 추가하고 앞쪽에서 제거합니다. 두 구조 모두 인덱스 변수가 있는 배열 위에 쉽게 구현할 수 있습니다.

#include <stdio.h>

int main(void) {
    int stack[10];
    int top = 0;                       // next free slot
    stack[top++] = 1;                  // push
    stack[top++] = 2;
    stack[top++] = 3;
    while (top > 0) {
        printf("%d ", stack[--top]);   // pop: 3 2 1
    }
    printf("\n");
    return 0;
}

#include <stdio.h>

int main(void) {
    int queue[10];
    int front = 0, back = 0;
    queue[back++] = 1;                       // enqueue
    queue[back++] = 2;
    queue[back++] = 3;
    while (front < back) {
        printf("%d ", queue[front++]);       // dequeue: 1 2 3
    }
    printf("\n");
    return 0;
}

Common mistakes

• 링크드 리스트에서 head 포인터를 잃으면 전체 리스트에 접근할 수 없게 됩니다.
• unlink하기 전에 리스트를 순회하여 작업이 완료된 모든 노드를 free하십시오.
• pop하기 전에 빈 리스트(NULL head)인지 확인하십시오.

선형 탐색은 요소를 순차적으로 확인하므로 어떤 배열에서도 작동합니다. 이진 탐색은 훨씬 빠르지만 정렬된 배열이 필요합니다: 중간 요소를 확인하고 매 단계마다 절반을 삭제합니다. 둘 다 인덱스를 반환하며, 요소가 없을 경우 -1을 반환합니다.

#include <stdio.h>

int linear(int a[], int n, int target) {
    for (int i = 0; i < n; i++)
        if (a[i] == target) return i;
    return -1;
}

int binary(int a[], int n, int target) {
    int lo = 0, hi = n - 1;
    while (lo <= hi) {
        int mid = (lo + hi) / 2;
        if (a[mid] == target) return mid;
        else if (a[mid] < target) lo = mid + 1;
        else hi = mid - 1;
    }
    return -1;
}

int main(void) {
    int a[] = {2, 5, 8, 12, 16, 23};
    int n = sizeof(a) / sizeof(a[0]);
    printf("%d %d %d\n", linear(a, n, 12), binary(a, n, 12), binary(a, n, 9));
    return 0;   // 3 3 -1
}

버블 정렬은 인접한 요소를 반복 비교하여 순서가 맞지 않는 쌍을 교체합니다. 각 패스 후 가장 큰 값이 "거품처럼" 끝으로 이동합니다.

#include <stdio.h>

int main(void) {
    int a[] = {5, 2, 9, 1, 7};
    int n = sizeof(a) / sizeof(a[0]);
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (a[j] > a[j + 1]) {
                int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
            }
        }
    }
    for (int i = 0; i < n; i++) printf("%d ", a[i]);
    printf("\n");   // 1 2 5 7 9
    return 0;
}

재귀(recursion)는 함수가 자신을 호출하는 것입니다. 멈추기 위한 기본 조건(base case)이 필요하며, 그 조건으로 나아가는 재귀 호출이 필요합니다. 기본 조건이 없으면 영구히 계속됩니다.

#include <stdio.h>

int factorial(int n) {
    if (n <= 1) return 1;          // base case
    return n * factorial(n - 1);   // recursive call
}

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

Common mistakes

• 이진 탐색은 정렬된 배열이 필요하며, 재귀는 기본 조건이 필요합니다.
• 각 재귀 호출은 기본 조건에 가까워져야 하며, 그렇지 않으면 스택 오버플로우가 발생합니다.
• 버블 정렬 및 삽입 정렬은 O(n²)의 복잡도를 가집니다: 학습용으로는 적합하지만 대량 데이터에서는 느립니다.

fopen은 파일 포인터를 반환하며, 모드 문자열은 동작을 지정합니다 — "w"는 쓰기, "r"는 읽기, "a"는 추가(append). 쓰기는 fprintf로, 읽기는 fscanf로, 작업 완료 시 항상 fclose을 수행하십시오.

#include <stdio.h>

int main(void) {
    FILE *out = fopen("scores.txt", "w");   // open for writing
    fprintf(out, "Alice 80\nBob 95\n");
    fclose(out);

    FILE *in = fopen("scores.txt", "r");    // open for reading
    char name[20];
    int score;
    while (fscanf(in, "%s %d", name, &score) == 2) {
        printf("%s -> %d\n", name, score);
    }
    fclose(in);
    return 0;
}

C는 예외 handling이 없습니다. 대신 함수는 반환 코드로 실패를 알립니다 — 관례상 0은 성공, 비영번호는 오류를 의미합니다. 호출자는 결과에 신뢰하기 전에 코드를 확인해야 합니다. (fopen도 동일한 원리를 따릅니다: 실패 시 NULL를 반환합니다.)

#include <stdio.h>

// returns 0 on success, -1 if the divisor is 0
int safe_divide(int a, int b, int *result) {
    if (b == 0) return -1;          // error code
    *result = a / b;
    return 0;                       // success
}

int main(void) {
    int r;
    if (safe_divide(10, 2, &r) == 0)
        printf("10 / 2 = %d\n", r);          // 10 / 2 = 5
    if (safe_divide(10, 0, &r) != 0)
        printf("cannot divide by zero\n");   // error reported
    return 0;
}

Common mistakes

• 읽거나 쓰기 전에 fopen가 NULL을 반환하지 않았는지 확인하십시오.
• 작업이 완료되면 파일을 반드시 fclose하십시오.
• 호출자에게 오류를 알리기 위해 main에서 비영번호 코드를 반환하십시오.

A bit 位 is a single 0 or 1; numbers are stored in binary 二进制. Bitwise 按位 operators work on the bits directly: & AND, | OR, ^ XOR, << shift left (×2 each step), >> shift right (÷2).

#include <stdio.h>

int main(void) {
    int a = 12;              // 1100
    int b = 10;              // 1010
    printf("%d\n", a & b);   // 8   AND  -> 1000
    printf("%d\n", a | b);   // 14  OR   -> 1110
    printf("%d\n", a ^ b);   // 6   XOR  -> 0110
    printf("%d\n", a << 1);  // 24  left shift
    printf("%d\n", a >> 1);  // 6   right shift
    return 0;
}

Hexadecimal 十六进制 (base 16) writes binary compactly: one hex digit is exactly four bits. Write hex literals with 0x; print with %x:

#include <stdio.h>

int main(void) {
    printf("%d\n", 0xFF);   // 255  (0x marks a hex literal)
    printf("%x\n", 255);    // ff
    printf("%x\n", 12);     // c
    return 0;
}

Run-length encoding (RLE) is a simple compression 压缩 method: replace each run 游程 of repeated characters with a count and the character. It is lossless 无损 — the original is fully recoverable.

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

int main(void) {
    char *s = "aaabbc";
    int n = strlen(s);
    for (int i = 0; i < n; ) {
        char c = s[i];
        int run = 0;
        while (i < n && s[i] == c) { run++; i++; }
        printf("%d%c", run, c);     // 3a2b1c
    }
    printf("\n");
    return 0;
}

Common mistakes

• & is bitwise AND and && is logical AND — do not confuse them.
• A left shift << 1 doubles a value; a right shift >> 1 halves it.
• Bit n has value 1 << n (C has no ** power operator); check a bit with (x >> n) & 1.

전预处理(preprocessor)는 컴파일 전에 실행됩니다. #define은 매크로를 생성하여 전역에서 plain text를 교체합니다. const은 변경할 수 없는 상수를 만듭니다. 함수 내부의 static는 호출 간 변수 값을 유지합니다. enum(열거형)은 0부터 시작하는 일련의 정수에 이름을 부여합니다.

#include <stdio.h>

#define MAX 100                     // macro: text replaced before compiling

enum Color { RED, GREEN, BLUE };    // named integers 0, 1, 2

int next_id(void) {
    static int count = 0;           // keeps its value between calls
    count++;
    return count;
}

int main(void) {
    const double PI = 3.14;         // cannot be changed
    printf("%d %.2f\n", MAX, PI);            // 100 3.14
    printf("%d %d %d\n", RED, GREEN, BLUE);  // 0 1 2
    int a = next_id();
    int b = next_id();
    printf("%d %d\n", a, b);                 // 1 2
    return 0;
}

더 큰 프로그램은 여러 파일로 나뉩니다: 선언문은 헤더 파일(mine.h)에 placing하며, #include "mine.h"으로 포함합니다. 따옴표(quotes)는 사용자 정의 파일을 의미하고, < >는 표준 라이브러리를 의미합니다. Include guard(#ifndef MINE_H / #define MINE_H / #endif)는 헤더 파일이 두 번 포함되는 것을 방지합니다.

Common mistakes

• #define은 타입 체크 없이 plain text 교체를 수행하므로, 매크로 본체와 인자를 괄호로 감싸십시오.
• const 값은 설정된 후 변경할 수 없습니다.
• static 로컬 변수는 함수 호출 간 값을 유지합니다.