コンテンツへスキップ
科目
  • 1 C 基礎
    1.1

    メイン関数、printf & 関数

    すべてのCプログラムは main から始まります。#include <stdio.h> はヘッダーファイルを含めることで、printf を使用して出力できるようになります。関数は名前付きブロックであり、呼び出すことができます;\n は改行を開始します。main は 0 を返すことで「成功」を意味します。

    #include <stdio.h>
    
    void greet(void) {
        printf("Hello, world!\n");
    }
    
    int main(void) {
        greet();
        printf("I am learning C.\n");
        return 0;
    }
    
    ヘッダーファイルを含む後、すべてのCプログラムはmainから実行される
    ヘッダーファイルを含む後、すべてのCプログラムはmainから実行される
    1.2

    変数、型 & 演算

    Cでは変数ごとに型が必要です:int (整数)、double (浮動小数点)、char (文字)。printf は各値に対してフォーマット指定子 — %d, %f, %c — を使用します。/ は2つの整数間の演算で整数除算となり、% は剰余です。

    #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;
    }
    

    フォーマット文字列は出力と入力の両方を制御します:

    指定子 型 例の出力
    %d int 17
    %f double (%.2f = 小数点以下2桁) 3.14
    %c char A
    %s ストリング Mei
    %zu サイズ (sizeof / strlen から) 3
    %x unsigned int, 進数16で出力 ff

    scanf("%d", &n) はアドレスを通じて int を読み取ります(& をご注意ください)。入力形式と出力形式は必ずしも同一ではありません: printf("%f", x) は double を出力しますが、scanf("%lf", &x) は double を読み取ります。入力の %f には float * が必要です。成功した割り当て項目のカウント値を確認してください。親族関数 sscanf は文字列から値を解析します。

    #include <stdio.h>
    
    int main(void) {
        char line[] = "Mei 88";
        char name[20];
        int score;
        if (sscanf(line, "%19s %d", name, &score) != 2) return 1;
        printf("%s scored %d\n", name, score);   // Mei scored 88
        return 0;
    }
    
    1.3

    コメント & スタイリング

    コメントは人間向けの注釈であり、コンパイラは無視します。1行には // を、ブロックには /* ... */ を使用します。適切なインデントと明確な名前はコード読みに役立ちます。

    #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;
    }
    

    ** 一般的なミス **

    • 宣言文および式文は ; で終わります。コンパウンドブロック { ... } に追加のセミコロンは不要です。main は int (return 0; )を返すべきです。
    • printfにはフォーマット文字列が必要です:%dはint用、%fはdouble用、\nは改行用です。
    • %d という誤った形式を double に渡すと未定義動作になるが、単にガレージ出力を印刷するだけとは限らない。引数の型を一致させよ。
  • 2 選択構造
    2.1

    if / else

    if は条件が真のときにブロックを実行します。Cのデフォルトでは実質的な布尔型はありません:0 は偽であり、それ以外の非ゼロ値は真です。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;
    }
    
    ifは真の分支を選択し、elseは偽の分支を選択
    ifは真の分支を選択し、elseは偽の分支を選択
    2.2

    スイッチ

    switch は整数値に基づいて1つの case を選びます。各 case には break が必要で、なければCは次のケースへと"Fall through"します。default は一致するものがない場合に実行されます。

    #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;
    }
    

    ** 一般的なミス **

    • if (x = 5) は代入を行うため常に真です;比較するには == を使用してください。
    • 各switchケースにはbreak;が必要であり、指定しない場合次のケースへ fall through する。
    • 条件式中では0が false、それ以外の非ゼロ値は true とみなされる。
  • 3 ループ
    3.1

    while & for ループ

    ループはブロックを繰り返す。whileループは条件が真である間実行される。forループは初期化、テスト、増分(i++)を1行にまとめ、繰り返しの回数が既知の場合に適している。

    #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;
    }
    
    while は条件をチェック; for はステップでカウント
    while は条件をチェック; for はステップでカウント
    3.2

    蓄積

    一般的なパターン: アキュムレータを0から始め、ループ内で加算する。同じ考え方でアイテム数を数えたり、累計やRunning total を求めたりできる。

    #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;
    }
    
    3.3

    二重ループ & パターン

    ループの中に別のループがあるものを二重ループ(ネストループ)という。外側のループの各ステップに対して内側のループが完全に完了するため、グリッドやパターンの作成に最適である。

    #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;
    }
    

    ** 一般的なミス **

    • for (i = 0; i < n; i++) はn 回実行される;for (...) の直後にセミコロンを置くと空のループになる。
    • 条件が決して false にならないwhile は無限ループとなる。
    • カウンタ(int i) はfor のヘッダーより前または内部に宣言する。
  • 4 関数
    4.1

    パラメータと返り値

    関数はパラメータ(入力)を受け取り、戻り値を返します。戻り型の記述が先に来ます(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;
    }
    
    パラメータは入力;返り値は出力
    パラメータは入力;返り値は出力
    4.2

    プロトタイプとスコープ

    C は上から下へ解釈するため、関数は使用前に定義されている必要がある。プロトタイプ(ヘッダー行+;)で早期に宣言することで、main を先に記述できる。変数のスコープはそれが存在するブロックであり、ローカルであり、ブロック終了と同時に消滅する。

    #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;
    }
    

    ** 一般的なミス **

    • 定義前に使用される関数には、 main の上にプロトタイプ宣言が必要です。
    • 引数は BY VALUE で渡される。関数内部での変更はポインタを渡さなければ呼び出し側には影響しない。
    • 関数内部で宣言された変数はその関数に限定されるローカル変数である。
  • 5 配列
    5.1

    1次元配列

    配列は同一型の複数の値を保持する。インデックスは0 から始める。C は配列の長さを保存しないため、要素数を計算する一般的な手法として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;
    }
    
    配列のスロットは0からインデックス付けされる
    配列のスロットは0からインデックス付けされる
    5.2

    配列アルゴリズム

    max、合計、またはカウントを見つけるために、for ループで配列を走査する。常に0 から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;
    }
    
    5.3

    2次元配列

    2次元配列は行と列のグリッドである:grid[row][col] 。すべてのセル访问するために二重ループを使う。

    #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;
    }
    

    ** 一般的なミス **

    • C は配列の境界チェックを行わない。サイズn の配列でa[n] に書き込むことは未定義動作である。
    • 有効なインデックスは0 からn - 1 までである。
    • ほとんどの式において、配列は先頭要素へのポインタに変換されますが、配列自体はポインタではありません。sizeof(a) は実際の配列に対する総バイトサイズを返します。配列パラメータはポインタに調整されるため、関数内では別途長さの指定が必要です。
  • 6 ポインタ
    6.1

    &, * とポインタ渡し

    ポインタは変数のアドレスを格納する。&x はx のアドレスを与える;*p はポインタを dereference(参照解除)し、そこに格納された値を読み書きする。ポインタを渡すことで、関数は呼び出し側の変数を変更できる(ポインタ渡し)。

    ポインタはアドレスを格納します;dereference すると矢印に沿って値に至ります
    ポインタはアドレスを格納します;dereference すると矢印に沿って値に至ります
    #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;
    }
    

    典型的な用途は swap 関数である。値だけを渡すとコピーされるだけで swap は失われる。ポインタを渡せば、関数は呼び出し側の変数にアクセスできる:

    #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;
    }
    

    配列名は先頭要素へのポインタとして機能し、ポインタ演算では完全な要素単位でステップする:

    #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 は何も指していないポインタ(ヌルポインタ)である。dereference する前に確認すること。

    ** 一般的なミス **

    • &x は x のアドレスです; *p は p に格納された値です。
    • 未初期化またはNULL ポインタに対しては*p を絶対に使わない。クラッシュやメモリ破損の原因となる。
    • 呼び出し側の変数を変更するには、そのアドレスを渡してポインタを通じて書き込む。
  • 7 文字列
    7.1

    Char 配列と nullTerminator

    Cの文字列はcharの配列です。すべての文字列は隠された null終端文字'\0'で終わり、これが終端位置を示します。strlen(頭から<string.h>へ)はその'\0'まで文字を数えます。文字列全体を出力するには%sを、1文字だけ出力するには%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;
    }
    
    Cの文字列は隠れたnullTerminatorで終わるchar配列です
    Cの文字列は隠れたnullTerminatorで終わるchar配列です

    '\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;
    }
    
    7.2

    string.h ライブラリ

    #include <string.h> は日常的な文字列ツールを提供する:

    関数 役割
    strlen(s) 長さ(terminator を含まない)
    strcpy(dst, src) コピー — dstが十分大きいこと
    strcat(dst, src) srcをdstの末尾に追加
    strcmp(a, b) 比較:等しい場合は0、そうでない場合は負/正
    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
        char full[40];
        strcpy(full, "Mei");           // full is now "Mei"
        strcat(full, " Chen");         // append -> "Mei Chen"
        printf("%s (%zu)\n", full, strlen(full));       // Mei Chen (8)
        printf("%d\n", strcmp("apple", "apple") == 0);  // 1 (equal)
        return 0;
    }
    
    • strcmpは等しい場合に0を返すため、テスト式はstrcmp(a, b) == 0とし、a == bとしてはいけません。
    • 目的の配列には結果のためのスペース加上 terminator のスペースが必要である。

    ** 一般的なミス **

    • C文字列には \0 終端マーカーのために追加の1バイトが必要です: 5 文字の単語には char[6] 必要です。
    • 文字列のコピーと比較にはstrcpy / strcmp を使い、= / == を使わない。
    • \0 を忘れるとprintf("%s", ...) がテキストの端を超えて実行される。
  • 8 構造体
    8.1

    struct、typedef、. vs ->

    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;
    }
    

    ** 一般的なミス **

    • structの値には . を、structのポインタには -> を使用します。
    • typedef を使うと宣言時にstruct という語を省略できる。使わない場合はstruct Point p; を書く。
    • 一つのstruct をもう一つに代入すると、すべてのフィールドがコピーされる。
    . はstruct 値用;-> はstruct ポインタ用
    . はstruct 値用;-> はstruct ポインタ用
  • 9 動的メモリ
    9.1

    malloc、free & realloc

    malloc はランタイムでヒープ上のメモリを割り当てて、そこへのポインタを返す。realloc はそのブロックのサイズを変更する。free はそれを返す(解放する)。malloc には対応するfree が必要であり、否则 memory leak Occur。これらは<stdlib.h> にある。

    ローカル変数はスタックに、mallocで確保したメモリはfreeするまでヒープ上に存在します
    ローカル変数はスタックに、mallocで確保したメモリはfreeするまでヒープ上に存在します
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void) {
        int n = 3;
        int *a = malloc(n * sizeof(int));    // room for 3 ints
        if (a == NULL) return EXIT_FAILURE;
        for (int i = 0; i < n; i++) a[i] = i * 10;
    
        int *grown = realloc(a, 4 * sizeof *a); // positive size
        if (grown == NULL) {
            free(a);
            return EXIT_FAILURE;
        }
        a = grown;
        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) は malloc と同様に配列を割り当てるとともに、すべての要素をゼロで初期化します。

    ** 一般的なミス **

    • 各 malloc には対応する free が必要です;freeを忘れるとメモリリークが発生します。
    • free 後のメモリ使用("use-after-free")は深刻なバグです。
    • メモリを使用する前に、malloc が NULL を返していないか確認してください。

    正のサイズに対して、realloc が失敗した場合は NULL を返して古い割り当ては維持されます。唯一のポインタを置き換える前に一時的な結果を確認してください。成功した場合は、古い/新しいバイト数のうち小さい方が保持され、追加されたセルは初期化されていません。この例ではゼロサイズの要求や整数オーバーフローを避けています。通常の非静的ローカル変数は自動格納期間を持ち、通常スタック上に実装されますが、Cではそのレイアウトを必須とはしません。

  • 10 データ構造
    10.1

    リンクリスト

    連結リストはノードの連鎖です。各ノードは値と next ノードへのポインタを持ちます。最後ノードは NULL を指します。配列とは異なり、 malloc でノードを1つずつ拡張します。完了したら必ず free するまで全ノードを確認してください。

    リンクリスト:各ノードは値と次のノードへのポインタを持ち、最後はNULLで終わります
    リンクリスト:各ノードは値と次のノードへのポインタを持ち、最後はNULLで終わります
    #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;
    }
    
    10.2

    スタックとキュー

    スタックは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;
    }
    

    ** 一般的なミス **

    • リンクリストでは、head ポインタを失ってはいけません。そうするとリスト全体にアクセスできなくなります。
    • 完了したら、リストをトレースしながらすべてのノードをfreeしてください。
    • popする前に、リストが空か(NULL ヘッドか)を確認してください。
  • 11 探索、ソート & 再帰
    11.1

    線形探索と二分探索

    線形探索は順に各要素をチェックします。どんな配列でも機能します。二分探索ははるかに高速ですが、並べ替え済みの配列が必要です。中央の値をチェックして半分以上を除外します。どちらも見つかればインデックスを返し、なければ -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
    }
    
    線形探索はすべてチェック;二分探索は並べ替え済み範囲を半分ずつ減らします
    線形探索はすべてチェック;二分探索は並べ替え済み範囲を半分ずつ減らします
    11.2

    ソート

    バブルソートは隣り合う要素を繰り返し比較し、順序が逆のペアを交換します。各パス後、最大の値が「泡」のように末尾に移動します。

    #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;
    }
    
    11.3

    再帰

    再帰は関数が自身を呼び出すことです。停止するための基本ケース(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;
    }
    

    ** 一般的なミス **

    • 二分探索には並べ替え済み配列が必要で、再帰には基本ケースが必要です。
    • 各再帰呼び出しは基本ケースに近づかなければならず、そうでないとスタックオーバーフローになります。
    • バブルソートと挿入ソートはO(n²)です。学習用としては問題ありませんが、大規模データでは遅いです。
  • 12 ファイル & エラー処理
    12.1

    テキストファイル

    fopen はファイルポインタを返します。モード文字列で操作内容を示し、"w" は書き込み、"r" は読み取り、"a" は追加を表します。書き込みは fprintf で、読み取りは fscanf で行い、完了したら必ず fclose してください。

    #include <stdio.h>
    
    int main(void) {
        FILE *out = fopen("scores.txt", "w");   // open for writing
        if (out == NULL) {
            perror("scores.txt");
            return 1;
        }
        fprintf(out, "Alice 80\nBob 95\n");
        fclose(out);
    
        FILE *in = fopen("scores.txt", "r");    // open for reading
        if (in == NULL) {
            perror("scores.txt");
            return 1;
        }
        char name[20];
        int score;
        while (fscanf(in, "%19s %d", name, &score) == 2) {   // %19s leaves room for '\0'
            printf("%s -> %d\n", name, score);
        }
        fclose(in);
        return 0;
    }
    
    fopen → 読み書き → fclose
    fopen → 読み書き → fclose
    12.2

    戻り値によるエラー処理

    C には組み込みの例外がない。関数は返り値を通じて結果を報告することがあります;使用前にその関数のルールを確認すること。以下の例では 0 を成功、-1 を失敗に用いる。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;
    }
    

    ** 一般的なミス **

    • 読み込みや書き込みの前に、fopen が NULL を返していないか確認してください。
    • 使用後は必ずファイルを fclose する。
    • main から非ゼロのコードを返して、呼び出し側にエラーを通知してください。
  • 13 ビット & データ
    13.1

    ビット、バイナリとビット演算子

    ビットは単一の0または1であり、数字はバイナリで保存されます。ビット演算子はビット直接に動作します:& AND、| OR、^ XOR、<< 左シフト(ステップごとに×2)、>> 右シフト(÷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;
    }
    

    十六進数(ベース16)は二進数をコンパクトに表せます:1桁はちょうど4ビットです。十六進リテラルは0xで書き、%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;
    }
    
    ビット演算子は整数のビットに対して動作します
    ビット演算子は整数のビットに対して動作します
    13.2

    ラン長符号化

    ラン長符号化(RLE)は単純な圧縮手法です。連続する同じ文字列を、その回文と文字に置き換えます。無損圧縮であるため、元に戻すことが完全に可能で、元のデータは完全に復元可能です。

    #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;
    }
    

    ** 一般的なミス **

    • & はビットANDであり、&& は論理ANDである——混同しないように注意せよ。
    • 左シフト << 1 は値を倍にします。右シフト >> 1 は値を半分にします。
    • ビット n の値は 1 << n です(Cには ** 乗算演算子はありません)。ビットの確認には (x >> n) & 1 を使います。
  • 14 プリプロセッサ & 修飾子
    14.1

    プリプロセッサ、const、static、enum

    プリプロセッサはコンパイル前に実行されます。#define はマクロを作成し、あらゆる場所で純粋なテキストが置換されます。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)に行われ、#include "mine.h" でincludeします。引用符は自分のファイル、< > は標準ライブラリを意味します。インクルードガード(#ifndef MINE_H / #define MINE_H / #endif)はヘッダーファイルが重複してincludeされるのを防ぎます。

    ** 一般的なミス **

    • #define は型チェックなしの純粋なテキスト置換を行うため、マクロ本体と引数を括弧で囲む必要があります。
    • const の値は設定後に変更できません。
    • static ローカル変数は関数呼び出し間で値を保持します。
    #define, const, enum, staticはコードを明確に保ちます
    #define, const, enum, staticはコードを明確に保ちます

ログインまたはアカウント作成

IGCSE, A-Level & AP