[C言語] malloc関数を使って動的に配列を生成する方法を解説

2025-04-15更新日: 2025-04-15

C言語では、malloc関数を使用して動的にメモリを確保し、配列を生成することができます。

mallocは標準ライブラリstdlib.hに含まれており、指定したバイト数のメモリをヒープ領域から確保します。

例えば、int型の配列を生成する場合、int *array = (int *)malloc(n * sizeof(int));のように記述します。

確保したメモリは使用後にfree関数で解放する必要があります。

これにより、プログラムの実行時に必要なメモリ量を柔軟に管理できます。

目次から探す

malloc関数を使った配列の生成
malloc関数を使った配列の操作
malloc関数を使った応用例
malloc関数を使う際の注意点
まとめ

malloc関数を使った配列の生成

配列の動的生成の必要性

メモリ効率の向上: 静的配列では、プログラムの実行前にサイズを決定する必要がありますが、動的配列を使用することで、実行時に必要なメモリを確保できます。

これにより、メモリの無駄を減らすことができます。

柔軟性の向上: 動的配列を使用することで、プログラムの実行中に配列のサイズを変更することが可能になります。

これにより、データの追加や削除が容易になります。

大規模データの処理: 動的配列は、非常に大きなデータセットを扱う際に便利です。

必要に応じてメモリを確保することで、システムのメモリ制限を超えないように管理できます。

malloc関数を使った配列の基本的な生成方法

malloc関数は、指定したバイト数のメモリを動的に確保するために使用されます。

以下に、mallocを使って整数型の配列を生成する基本的な方法を示します。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int n = 5; // 配列の要素数
    int *array = (int *)malloc(n * sizeof(int)); // メモリを確保
    if (array == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 配列に値を代入
    for (int i = 0; i < n; i++) {
        array[i] = i * 10;
    }
    // 配列の内容を表示
    for (int i = 0; i < n; i++) {
        printf("array[%d] = %d\n", i, array[i]);
    }
    free(array); // メモリを解放
    return 0;
}

array[0] = 0
array[1] = 10
array[2] = 20
array[3] = 30
array[4] = 40

この例では、mallocを使って整数型の配列を動的に生成し、各要素に値を代入しています。

最後に、free関数を使って確保したメモリを解放しています。

配列のサイズ変更とrealloc関数

realloc関数は、既に確保されたメモリブロックのサイズを変更するために使用されます。

以下に、reallocを使って配列のサイズを変更する方法を示します。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int n = 5;
    int *array = (int *)malloc(n * sizeof(int));
    if (array == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 配列のサイズを10に変更
    n = 10;
    int *temp = (int *)realloc(array, n * sizeof(int));
    if (temp == NULL) {
        printf("メモリの再確保に失敗しました\n");
        free(array);
        return 1;
    }
    array = temp;
    // 新しい要素に値を代入
    for (int i = 5; i < n; i++) {
        array[i] = i * 10;
    }
    // 配列の内容を表示
    for (int i = 0; i < n; i++) {
        printf("array[%d] = %d\n", i, array[i]);
    }
    free(array);
    return 0;
}

array[0] = 0
array[1] = 10
array[2] = 20
array[3] = 30
array[4] = 40
array[5] = 50
array[6] = 60
array[7] = 70
array[8] = 80
array[9] = 90

この例では、reallocを使って配列のサイズを変更し、新しい要素に値を代入しています。

reallocは、元のメモリブロックを拡張または縮小し、新しいサイズに合わせてメモリを再確保します。

メモリの解放とfree関数

free関数は、mallocやreallocで確保したメモリを解放するために使用されます。

メモリを解放しないと、メモリリークが発生し、プログラムのメモリ使用量が増加し続ける可能性があります。

メモリリークの防止: 確保したメモリは、使用が終わったら必ずfree関数で解放する必要があります。
安全なメモリ管理: free関数を使用することで、不要になったメモリをシステムに返し、他のプロセスが使用できるようにします。

以下に、free関数の使用例を示します。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *array = (int *)malloc(5 * sizeof(int));
    if (array == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 配列の使用...
    free(array); // メモリを解放
    return 0;
}

この例では、mallocで確保したメモリをfree関数で解放しています。

メモリを解放することで、メモリリークを防ぎ、システムリソースを効率的に管理できます。

malloc関数を使った配列の操作

配列へのデータの格納

動的に確保した配列にデータを格納する際は、通常の配列と同様にインデックスを使用します。

以下に、mallocで確保した配列にデータを格納する例を示します。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int n = 5;
    int *array = (int *)malloc(n * sizeof(int));
    if (array == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 配列にデータを格納
    for (int i = 0; i < n; i++) {
        array[i] = i + 1; // 1から5までの値を格納
    }
    // 配列の内容を表示
    for (int i = 0; i < n; i++) {
        printf("array[%d] = %d\n", i, array[i]);
    }
    free(array);
    return 0;
}

array[0] = 1
array[1] = 2
array[2] = 3
array[3] = 4
array[4] = 5

この例では、mallocで確保した配列に1から5までの整数を格納しています。

forループを使用して、各インデックスにデータを代入しています。

配列の要素へのアクセス

動的に確保した配列の要素にアクセスする方法も、通常の配列と同様です。

インデックスを使用して、特定の要素にアクセスできます。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int n = 5;
    int *array = (int *)malloc(n * sizeof(int));
    if (array == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 配列にデータを格納
    for (int i = 0; i < n; i++) {
        array[i] = i * 2; // 0, 2, 4, 6, 8を格納
    }
    // 特定の要素にアクセス
    printf("array[2] = %d\n", array[2]); // 3番目の要素を表示
    free(array);
    return 0;
}

array[2] = 4

この例では、mallocで確保した配列の3番目の要素にアクセスし、その値を表示しています。

インデックスを使用することで、任意の要素に簡単にアクセスできます。

配列のサイズ変更時の注意点

動的配列のサイズを変更する際には、realloc関数を使用しますが、いくつかの注意点があります。

メモリの再確保: reallocは、元のメモリブロックを拡張できない場合、新しいメモリブロックを確保し、元のデータをコピーします。

そのため、元のポインタは無効になる可能性があります。

データの保持: reallocを使用すると、元のデータは保持されますが、新しい領域には初期化されていないデータが含まれる可能性があります。

必要に応じて初期化を行う必要があります。

エラーチェック: reallocが失敗した場合、NULLを返します。

この場合、元のメモリブロックは解放されないため、エラーチェックを行い、適切にメモリを管理する必要があります。

以下に、reallocを使用する際の注意点を示す例を示します。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int n = 5;
    int *array = (int *)malloc(n * sizeof(int));
    if (array == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 配列にデータを格納
    for (int i = 0; i < n; i++) {
        array[i] = i + 1;
    }
    // 配列のサイズを10に変更
    int newSize = 10;
    int *temp = (int *)realloc(array, newSize * sizeof(int));
    if (temp == NULL) {
        printf("メモリの再確保に失敗しました\n");
        free(array);
        return 1;
    }
    array = temp;
    // 新しい要素を初期化
    for (int i = n; i < newSize; i++) {
        array[i] = 0; // 新しい要素を0で初期化
    }
    // 配列の内容を表示
    for (int i = 0; i < newSize; i++) {
        printf("array[%d] = %d\n", i, array[i]);
    }
    free(array);
    return 0;
}

array[0] = 1
array[1] = 2
array[2] = 3
array[3] = 4
array[4] = 5
array[5] = 0
array[6] = 0
array[7] = 0
array[8] = 0
array[9] = 0

この例では、reallocを使用して配列のサイズを変更し、新しい要素を0で初期化しています。

reallocの結果を一時的なポインタに保存し、エラーチェックを行った後に元のポインタを更新しています。

malloc関数を使った応用例

2次元配列の動的生成

2次元配列を動的に生成するには、まず各行のポインタを格納するための配列を確保し、その後、各行に対してメモリを確保します。

以下に、2次元配列を動的に生成する例を示します。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int rows = 3;
    int cols = 4;
    int **matrix = (int **)malloc(rows * sizeof(int *));
    if (matrix == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
        if (matrix[i] == NULL) {
            printf("メモリの確保に失敗しました\n");
            return 1;
        }
    }
    // 2次元配列にデータを格納
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i * cols + j;
        }
    }
    // 2次元配列の内容を表示
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    // メモリを解放
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);
    return 0;
}

0 1 2 3
4 5 6 7
8 9 10 11

この例では、3行4列の2次元配列を動的に生成し、各要素に値を代入しています。

最後に、各行のメモリを解放し、行ポインタの配列も解放しています。

構造体配列の動的生成

構造体の配列を動的に生成することで、柔軟にデータを管理できます。

以下に、構造体配列を動的に生成する例を示します。

#include <stdio.h>
#include <stdlib.h>
typedef struct {
    int id;
    char name[50];
} Student;
int main() {
    int n = 3;
    Student *students = (Student *)malloc(n * sizeof(Student));
    if (students == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 構造体配列にデータを格納
    for (int i = 0; i < n; i++) {
        students[i].id = i + 1;
        sprintf(students[i].name, "Student%d", i + 1);
    }
    // 構造体配列の内容を表示
    for (int i = 0; i < n; i++) {
        printf("ID: %d, Name: %s\n", students[i].id, students[i].name);
    }
    free(students);
    return 0;
}

ID: 1, Name: Student1
ID: 2, Name: Student2
ID: 3, Name: Student3

この例では、Student構造体の配列を動的に生成し、各要素にデータを格納しています。

sprintfを使用して、名前をフォーマットしています。

文字列の動的生成と操作

文字列を動的に生成することで、可変長の文字列を扱うことができます。

以下に、文字列を動的に生成し、操作する例を示します。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
    char *str = (char *)malloc(50 * sizeof(char));
    if (str == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 文字列にデータを格納
    strcpy(str, "Hello, ");
    strcat(str, "World!");
    // 文字列の内容を表示
    printf("%s\n", str);
    free(str);
    return 0;
}

Hello, World!

この例では、mallocを使用して文字列用のメモリを動的に確保し、strcpyとstrcatを使用して文字列を操作しています。

最後に、free関数でメモリを解放しています。

動的に生成した文字列は、必要に応じてサイズを変更することも可能です。

malloc関数を使う際の注意点

メモリリークの防止

メモリリークは、動的に確保したメモリを解放せずにプログラムが終了することによって発生します。

これにより、システムのメモリが無駄に消費され、最終的にはメモリ不足を引き起こす可能性があります。

メモリリークを防ぐためのポイントは以下の通りです。

確保したメモリは必ず解放する: mallocやreallocで確保したメモリは、使用が終わったら必ずfree関数で解放します。
エラーハンドリングを行う: メモリ確保に失敗した場合の処理を必ず実装し、失敗時には適切にメモリを解放します。
プログラムの終了時に全てのメモリを解放する: プログラムが終了する前に、確保した全てのメモリを解放するようにします。

以下に、メモリリークを防ぐための例を示します。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *array = (int *)malloc(5 * sizeof(int));
    if (array == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 配列の使用...
    free(array); // メモリを解放
    return 0;
}

メモリの初期化

動的に確保したメモリは、初期化されていない状態で提供されます。

そのため、使用する前に必ず初期化を行う必要があります。

初期化を怠ると、予期しない動作やバグの原因となります。

calloc関数の使用: calloc関数は、メモリを確保すると同時にゼロで初期化します。

初期化が必要な場合は、mallocの代わりにcallocを使用することを検討します。

手動での初期化: mallocを使用した場合は、forループなどを用いて手動で初期化を行います。

以下に、callocを使用した初期化の例を示します。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int n = 5;
    int *array = (int *)calloc(n, sizeof(int)); // ゼロで初期化
    if (array == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 配列の内容を表示
    for (int i = 0; i < n; i++) {
        printf("array[%d] = %d\n", i, array[i]);
    }
    free(array);
    return 0;
}

ポインタの安全な使用

ポインタを安全に使用するためには、いくつかの注意点があります。

ポインタの誤用は、プログラムのクラッシュや予期しない動作を引き起こす可能性があります。

NULLポインタのチェック: メモリ確保後、ポインタがNULLでないことを確認します。

NULLの場合は、メモリ確保に失敗しているため、適切なエラーハンドリングを行います。

ダングリングポインタの回避: メモリを解放した後、ポインタをNULLに設定することで、解放済みメモリへのアクセスを防ぎます。
ポインタの範囲外アクセスの防止: ポインタを使用して配列にアクセスする際は、必ず範囲内であることを確認します。

範囲外アクセスは、未定義の動作を引き起こします。

以下に、ポインタの安全な使用の例を示します。

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *array = (int *)malloc(5 * sizeof(int));
    if (array == NULL) {
        printf("メモリの確保に失敗しました\n");
        return 1;
    }
    // 配列の使用...
    free(array);
    array = NULL; // ダングリングポインタを防ぐ
    return 0;
}

この例では、メモリを解放した後にポインタをNULLに設定することで、ダングリングポインタを防いでいます。

ポインタを安全に使用することで、プログラムの信頼性を向上させることができます。