ポインタ⑤（動的メモリ割り当て）　解答ページ | Programming Place Plus　Ｃ言語編　第３５章

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

#define NAME_LEN          64        // 名前の最大長
#define PHONE_NUMBER_LEN  16        // 電話番号の最大長

// 個人情報
typedef struct {
    char    name[NAME_LEN];                 // 名前
    char    phone_number[PHONE_NUMBER_LEN]; // 電話番号
} PersonalInfo;

int main(void)
{
    // データ件数を受け取る
    puts("データの件数を入力してください。");
    char buf[40];
    int data_num;
    fgets(buf, sizeof(buf), stdin);
    sscanf(buf, "%d", &data_num);

    // データ件数が 0件以下なら終了
    if (data_num <= 0) {
        return 0;
    }

    // 件数に合わせて、領域を確保する
    PersonalInfo* info_array = malloc(sizeof(PersonalInfo) * data_num);
    if (info_array == NULL) {
        exit(EXIT_FAILURE);
    }

    // データを受け取る
    for (int i = 0; i < data_num; ++i) {
        puts("名前を入力してください。");
        fgets(buf, sizeof(buf), stdin);
        sscanf(buf, "%s", info_array[i].name);

        puts("電話番号を入力してください。");
        fgets(buf, sizeof(buf), stdin);
        sscanf(buf, "%s", info_array[i].phone_number);
    }

    // 特に手を加えないので、領域を解放する
    free(info_array);

    // 結果を出力
    for (int i = 0; i < data_num; ++i) {
        printf("%s: %s\n", info_array[i].name, info_array[i].phone_number);
    }
}

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

void set_sequential_number(int* array, size_t size);
void print_array(int* array, size_t size);

int main(void)
{
    int* values;
    size_t size;


    size = 50;
    values = malloc(sizeof(int) * size);
    set_sequential_number(values, size);
    print_array(values, size);

    size = 100;
    values = calloc(size, sizeof(int));
    set_sequential_number(values, size);
    print_array(values, size);

    free(values);
}

/*
    配列に連番をセットする。
    引数：
        array:  対象配列のメモリアドレス。
        size:   対象配列の要素数。
*/
void set_sequential_number(int* array, size_t size)
{
    for (size_t i = 0; i < size; ++i) {
        array[i] = i;
    }
}

/*
    配列の中身を標準出力へ出力する。
    引数：
        array:  対象配列のメモリアドレス。
        size:   対象配列の要素数。
*/
void print_array(int* array, size_t size)
{
    for (size_t i = 0; i < size; ++i) {
        printf("%d\n", array[i]);
    }
}

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

#define INITIAL_SIZE    2

int main(void)
{
    // 初回確保
    size_t capacity = INITIAL_SIZE;  // 確保されている領域の大きさ
    int* array = malloc(sizeof(int) * capacity);
    size_t size = 0;      // データ総数＝実際に使用されている領域の個数


    while (1) {
        char buf[40];
        int num;

        puts("次のデータを整数で入力してください。負数を入力すると終了します。");
        fgets(buf, sizeof(buf), stdin);
        sscanf(buf, "%ld", &num);

        if (num < 0) {
            break;
        }

        size++;

        // 領域が足りなくなったら、既存の領域の大きさの倍の値で再確保する
        if (size >= capacity) {
            capacity *= 2;
            int* tmp = realloc(array, sizeof(long) * capacity);
            if (tmp == NULL) {
                // realloc関数が失敗した場合、元の領域は解放されずに残されている
                // 自分で free関数を呼び出して終了する
                free(array);
                exit(EXIT_FAILURE);
            }
            array = tmp;
            tmp = NULL;  // 安全策。確保された領域を指すポインタを array だけに限定する
        }

        // 入力されたデータを格納
        array[size-1] = num;
    }

    // 結果を出力
    for (int i = 0; i < size; ++i) {
        printf("%d\n", array[i]);
    }

    free(array);
}

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

#define INPUT_DATA_NUM_MAX  1000    // 入力されるデータの最大数

int main(void)
{
    // 最初に、必要になる可能性がある最大の大きさに合わせて確保しておく
    long* array = malloc(sizeof(long) * INPUT_DATA_NUM_MAX);
    size_t size = 0;      // データ総数＝実際に使用されている領域の個数


    long sum = 0;

    while (1) {
        char buf[40];
        long num;

        puts("次のデータを整数で入力してください。負数を入力すると終了します。");
        fgets(buf, sizeof(buf), stdin);
        sscanf(buf, "%ld", &num);

        if (num < 0) {
            break;
        }

        size++;
        assert(size <= INPUT_DATA_NUM_MAX);    // 想定される以上のデータ数

        // 入力されたデータを格納
        array[size-1] = num;

        // 合計を計算
        sum += num;
    }

    // 実際に使った大きさに切り詰める
    if (size > 0) {
        long* tmp = realloc(array, sizeof(long) * size);
        if (tmp == NULL) {
            // realloc関数が失敗した場合、元の領域は解放されずに残されている
            // 自分で free関数を呼び出して終了する
            free(array);
            exit(EXIT_FAILURE);
        }
        array = tmp;
        tmp = NULL;  // 安全策。確保された領域を指すポインタを array だけに限定する
    }


    // 平均を出力
    if (size > 0) {
        printf("AVERAGE: %ld\n", (long)(sum / size));
    }
    else {
        printf("AVERAGE: %ld\n", 0L);
    }

    free(array);
}

/*
    独自の realloc関数。
    引数：
        ptr:    元の領域のメモリアドレス。
        size:   新たに確保する大きさ。 0 は許可しない。
    戻り値：
        新しい領域のメモリアドレス。
        ヌルポインタが返される可能性はなく、エラー時は exit関数で強制終了する。
*/
void* my_realloc(void* ptr, size_t size)
{
    assert(size > 0);  // size 0 は不正とする

    void* tmp = realloc(ptr, size);
    if (tmp == NULL) {
        free(ptr);
        exit(EXIT_FAILURE);  // 失敗したら強制終了
    }
    return tmp;
}

// ヌルポインタが返されることはあり得ない
array = my_realloc(array, sizeof(long) * size);

char* str_duplicate(const char* s)
{
    char* dup = malloc(strlen(s) + 1);
    strcpy(dup, s);

    return dup;
}

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

char* str_duplicate(const char* s);

int main(void)
{
    char str1[] = "abcde";
    char* str2 = str2 = str_duplicate(str1);

    puts(str2);

    free(str2);
}

/*
    文字列の複製を作る。
    引数
        s：      複製元の文字列。
    戻り値
        複製された文字列のメモリアドレス。
        malloc関数によって領域を確保しているので、外部での解放が必要。
*/
char* str_duplicate(const char* s)
{
    char* dup = malloc(strlen(s) + 1);
    strcpy(dup, s);

    return dup;
}