C言語の malloc: 動的メモリ確保、free、そして sizeof

ここまでに書いてきた配列は、どれもサイズがコンパイル時に焼き付けられていました。int scores[10]; は、3つ必要でも300必要でも10個の枠を確保します。それはサイズがプログラムの実行中にしか分からないときまでは通用します - ファイルに何行あるか、ユーザーが何件のレコードを入力するか、といった場合です。動的メモリがそれを解決します。必要なバイトを、必要なときに要求し、終わったら返すのです。

道具は <stdlib.h> にあります:

#include <stdlib.h>

ヒープが存在する理由

C言語はプログラムに2つの主要なメモリ領域を与えます。ローカル変数は自動記憶域（スタック）にあり、コンパイラがそのサイズを決め、関数が戻った瞬間に消えます。動的な確保はヒープにあり、サイズは実行時にあなたが決め、明示的に解放するまでブロックは生き続けます。

この2つ目の性質こそが malloc を使う本当の理由です。関数はブロックを確保してポインタを返すことができ、そのメモリは呼び出し側でもまだ有効です - ローカル配列には決してできないことです。2つの領域はスタックとヒープで詳しく比較しています。

malloc: バイトを要求する

malloc はバイト数を取り、その数だけの未初期化メモリを指す void * を返します。失敗した場合は NULL です。

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

int main(void) {
    int n = 5;

    int *scores = malloc(n * sizeof *scores);
    if (scores == NULL) {
        fprintf(stderr, "メモリが足りません\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        scores[i] = (i + 1) * 10;
    }

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

    free(scores);
    scores = NULL;
    return 0;
}

この短いプログラムにある4つのことが、この分野の作法のすべてです:

1. サイズの式は n * sizeof *scores。 「scores が指すものの n 個分」と読みましょう。
2. 結果は使用前に NULL と照合される。
3. ブロックは配列とまったく同じように使われる - インデックス指定はポインタ演算なので scores[i] が動きます。
4. 1回だけ解放され、その後ポインタが NULL に設定される。

戻り値にキャストがないことに注目してください。C言語では void * は任意のオブジェクトポインタに自動変換され、(int *)malloc(...) と書くのはノイズを増やしたうえ <stdlib.h> の include 漏れを隠してしまいます。（C++ ではキャストが必要ですが、C言語では不要です。）

sizeof のイディオム

なぜ sizeof(int) ではなく sizeof *scores なのか。古びることがないからです。

int  *a = malloc(n * sizeof *a);     /* n 個の int、ここでの int が何であれ */
long *b = malloc(n * sizeof *b);     /* 同じ形の行で、正しいサイズ */

/* こわれやすい形 */
long *c = malloc(n * sizeof(int));   /* コンパイルは通るが、確保が足りない */

最後の行は、どのコンパイラも警告してくれない本物のバグです。c は long * なのに確保は int のサイズで行われ、前半を越えるすべての書き込みが末尾からはみ出します。sizeof *c にすれば、サイズは宣言に自動的に追従します。

sizeof *p は p を参照外ししません - sizeof は型だけからコンパイル時に評価されるので、p が未初期化でも NULL でも安全です。

未初期化のメモリ

malloc は渡すものをクリアしません。バイトには以前そこにあったものが入っています。

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

int main(void) {
    int *p = malloc(4 * sizeof *p);
    if (p == NULL) {
        return 1;
    }

    /* 書き込む前に読むのは未定義動作 - なので先に書く */
    for (int i = 0; i < 4; i++) {
        p[i] = 0;
    }

    printf("%d %d %d %d\n", p[0], p[1], p[2], p[3]);

    free(p);
    return 0;
}

ブロックをゼロクリアしてほしいときは、calloc が一手でやってくれます - calloc と reallocを参照してください。

free: 返す

free(p) はブロックをアロケータに返します。ルールは3つ:

• malloc が返したまさにそのポインタを渡すこと。進めたものではいけません。free(p + 1) は未定義動作です。
• 各ブロックをちょうど1回解放すること。2回は二重解放で、アロケータ自身の管理情報を壊します。
• 解放後、そのポインタは無効です。使うとuse-after-free になります。

int *p = malloc(sizeof *p);
free(p);
*p = 5;        /* use-after-free - 未定義動作 */
free(p);       /* 二重解放 - 未定義動作 */

どちらの行もすぐにクラッシュする必要はありません。それこそが危険なところで、プログラムは数分動き続けてから、まったく無関係な場所で落ちることがあります。安上がりな防御はポインタを空にすることです:

free(p);
p = NULL;

free(NULL) は何もしないことが明示的に定義されているので、その後の2回目の free(p) は無害になり、*p は静かな破壊ではなく本当の障害箇所での即座のクラッシュになります。

動的配列を最初から最後まで

実際の確保の形はこうです。実行時にカウントを読み、それをもとにブロックのサイズを決め、使い、解放します。

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

int main(void) {
    int n = 8;   /* 入力やファイルから来たものと想像してください */

    double *values = malloc((size_t)n * sizeof *values);
    if (values == NULL) {
        fprintf(stderr, "%d 個の double の確保に失敗しました\n", n);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        values[i] = 1.0 / (i + 1);
    }

    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        sum += values[i];
    }

    printf("1/1 .. 1/%d の合計 = %f\n", n, sum);
    printf("ブロックは %zu バイトです\n", (size_t)n * sizeof *values);

    free(values);
    values = NULL;
    return 0;
}

カウントを size_t にキャストすることは、サイズが大きくなると効いてきます。素の int の n による n * sizeof *values は、掛け算の結果が malloc に届く前にオーバーフローし得て、意図よりはるかに小さいブロックができてしまいます。size_t で掛ければそれを避けられます。

関数の中で確保する

ヒープの生存期間のルールこそが、これを合法にし、そしてローカル配列を返すことを違法にしているものです:

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

/* 返されたブロックは呼び出し側の所有物であり、解放する責任がある */
char *duplicate(const char *text) {
    size_t len = strlen(text);
    char *copy = malloc(len + 1);
    if (copy == NULL) {
        return NULL;
    }
    memcpy(copy, text, len + 1);
    return copy;
}

int main(void) {
    char *greeting = duplicate("hello, heap");
    if (greeting == NULL) {
        fprintf(stderr, "メモリが足りません\n");
        return 1;
    }

    greeting[0] = 'H';
    printf("%s\n", greeting);

    free(greeting);
    return 0;
}

len + 1 はヌル終端の場所を残しています - 文字列のあらゆる場所と同じサイズ計算のルールです。そして関数の上のコメントに注目してください。関数が確保したメモリを返すとき、誰がそれを解放するかはその契約の一部です。それを書き留めることは事務作業ではありません。リークを防ぐ唯一のものなのです。

ヒープ上の構造体

同じイディオムがどんな型にも通用します:

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

struct Point {
    double x;
    double y;
};

int main(void) {
    struct Point *p = malloc(sizeof *p);
    if (p == NULL) {
        return 1;
    }

    p->x = 3.0;
    p->y = 4.0;
    printf("(%.1f, %.1f)\n", p->x, p->y);

    /* それらの配列 */
    int n = 3;
    struct Point *path = malloc((size_t)n * sizeof *path);
    if (path == NULL) {
        free(p);
        return 1;
    }

    for (int i = 0; i < n; i++) {
        path[i].x = i;
        path[i].y = i * i;
    }
    printf("最後の点: (%.1f, %.1f)\n", path[n - 1].x, path[n - 1].y);

    free(path);
    free(p);
    return 0;
}

2つ目の失敗の分岐が、return する前に p を解放していることに注目してください。関数が2つ以上の確保を抱えるようになると、すべてのエラー経路で、すでに取ったものを解放しなければなりません - メモリリークで説明するリークの最もよくある原因です。

チェックリスト

• 最初に使う前に、必ず malloc を NULL と照合すること。
• サイズは n * sizeof *p とし、掛け算は size_t で行うこと。
• C言語では戻り値にキャストを付けないこと。
• malloc のメモリは未初期化。読む前に書くこと。
• 元のポインタでちょうど1回だけ解放し、その後 NULL に設定すること。
• 確保の後のすべてのエラー経路は、すでに抱えているものを解放すること。