[C言語] 可変長配列を持つ構造体を定義・実装する方法を解説

#include <stdio.h>
// 人の情報を格納する構造体
struct Person {
    char name[50]; // 名前
    int age;       // 年齢
};
int main() {
    struct Person person1;
    // 構造体メンバーに値を代入
    person1.age = 30;
    snprintf(person1.name, sizeof(person1.name), "Taro");
    printf("名前: %s, 年齢: %d\n", person1.name, person1.age);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
// 可変長配列を持つ構造体
struct FlexibleArray {
    int size;      // 配列のサイズ
    int data[];    // 可変長配列
};
int main() {
    int n = 5;
    // 構造体のサイズと配列のサイズを考慮してメモリを確保
    struct FlexibleArray *fa = malloc(sizeof(struct FlexibleArray) + n * sizeof(int));
    fa->size = n;
    // 配列に値を代入
    for (int i = 0; i < fa->size; i++) {
        fa->data[i] = i * 10;
    }
    // 配列の内容を表示
    for (int i = 0; i < fa->size; i++) {
        printf("data[%d] = %d\n", i, fa->data[i]);
    }
    // メモリを解放
    free(fa);
    return 0;
}

#include <stdlib.h>
// 構造体の定義
struct FlexibleArray {
    int size;      // 配列のサイズ
    int data[];    // 可変長配列
};
// メモリの動的確保
struct FlexibleArray* allocateFlexibleArray(int n) {
    return malloc(sizeof(struct FlexibleArray) + n * sizeof(int));
}

#include <stdio.h>
// 構造体の初期化
void initializeFlexibleArray(struct FlexibleArray* fa, int n) {
    fa->size = n;
    for (int i = 0; i < n; i++) {
        fa->data[i] = 0; // 初期値を設定
    }
}

#include <string.h>
// 配列要素の追加
struct FlexibleArray* addElement(struct FlexibleArray* fa, int newElement) {
    int newSize = fa->size + 1;
    struct FlexibleArray* newFa = realloc(fa, sizeof(struct FlexibleArray) + newSize * sizeof(int));
    if (newFa != NULL) {
        newFa->data[newFa->size] = newElement;
        newFa->size = newSize;
    }
    return newFa;
}

// メモリの解放
void freeFlexibleArray(struct FlexibleArray* fa) {
    free(fa);
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 構造体の定義
struct FlexibleArray {
    int size;
    int data[];
};
// メモリの動的確保
struct FlexibleArray* allocateFlexibleArray(int n) {
    return malloc(sizeof(struct FlexibleArray) + n * sizeof(int));
}
// 構造体の初期化
void initializeFlexibleArray(struct FlexibleArray* fa, int n) {
    fa->size = n;
    for (int i = 0; i < n; i++) {
        fa->data[i] = 0;
    }
}
// 配列要素の追加
struct FlexibleArray* addElement(struct FlexibleArray* fa, int newElement) {
    int newSize = fa->size + 1;
    struct FlexibleArray* newFa = realloc(fa, sizeof(struct FlexibleArray) + newSize * sizeof(int));
    if (newFa != NULL) {
        newFa->data[newFa->size] = newElement;
        newFa->size = newSize;
    }
    return newFa;
}
// メモリの解放
void freeFlexibleArray(struct FlexibleArray* fa) {
    free(fa);
}
int main() {
    int initialSize = 3;
    struct FlexibleArray* fa = allocateFlexibleArray(initialSize);
    initializeFlexibleArray(fa, initialSize);
    // 要素を追加
    fa = addElement(fa, 100);
    // 配列の内容を表示
    for (int i = 0; i < fa->size; i++) {
        printf("data[%d] = %d\n", i, fa->data[i]);
    }
    // メモリを解放
    freeFlexibleArray(fa);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// レコードを表す構造体
struct Record {
    int fieldCount;   // フィールドの数
    char *fields[];   // 可変長配列でフィールドを格納
};
// レコードの作成
struct Record* createRecord(int fieldCount, char *fieldValues[]) {
    struct Record* record = malloc(sizeof(struct Record) + fieldCount * sizeof(char*));
    record->fieldCount = fieldCount;
    for (int i = 0; i < fieldCount; i++) {
        record->fields[i] = strdup(fieldValues[i]); // フィールドをコピー
    }
    return record;
}
// レコードの解放
void freeRecord(struct Record* record) {
    for (int i = 0; i < record->fieldCount; i++) {
        free(record->fields[i]);
    }
    free(record);
}
int main() {
    char *fields[] = {"ID: 001", "Name: Taro", "Age: 30"};
    struct Record* record = createRecord(3, fields);
    // レコードの内容を表示
    for (int i = 0; i < record->fieldCount; i++) {
        printf("%s\n", record->fields[i]);
    }
    // メモリを解放
    freeRecord(record);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
// リストを表す構造体
struct DynamicList {
    int count;    // 要素数
    int items[];  // 可変長配列で要素を格納
};
// リストの作成
struct DynamicList* createList(int initialSize) {
    struct DynamicList* list = malloc(sizeof(struct DynamicList) + initialSize * sizeof(int));
    list->count = 0;
    return list;
}
// 要素の追加
struct DynamicList* addItem(struct DynamicList* list, int item) {
    int newSize = list->count + 1;
    struct DynamicList* newList = realloc(list, sizeof(struct DynamicList) + newSize * sizeof(int));
    if (newList != NULL) {
        newList->items[newList->count] = item;
        newList->count = newSize;
    }
    return newList;
}
// リストの解放
void freeList(struct DynamicList* list) {
    free(list);
}
int main() {
    struct DynamicList* list = createList(2);
    // 要素を追加
    list = addItem(list, 10);
    list = addItem(list, 20);
    // リストの内容を表示
    for (int i = 0; i < list->count; i++) {
        printf("Item %d: %d\n", i, list->items[i]);
    }
    // メモリを解放
    freeList(list);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 文字列を表す構造体
struct DynamicString {
    int length;   // 文字列の長さ
    char str[];   // 可変長配列で文字列を格納
};
// 文字列の作成
struct DynamicString* createString(const char* initialStr) {
    int len = strlen(initialStr);
    struct DynamicString* dStr = malloc(sizeof(struct DynamicString) + (len + 1) * sizeof(char));
    dStr->length = len;
    strcpy(dStr->str, initialStr);
    return dStr;
}
// 文字列の解放
void freeString(struct DynamicString* dStr) {
    free(dStr);
}
int main() {
    struct DynamicString* dStr = createString("Hello, World!");
    // 文字列の内容を表示
    printf("String: %s\n", dStr->str);
    // メモリを解放
    freeString(dStr);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
// ツリーノードを表す構造体
struct TreeNode {
    int value;          // ノードの値
    int childCount;     // 子ノードの数
    struct TreeNode* children[]; // 可変長配列で子ノードを格納
};
// ノードの作成
struct TreeNode* createTreeNode(int value, int childCount) {
    struct TreeNode* node = malloc(sizeof(struct TreeNode) + childCount * sizeof(struct TreeNode*));
    node->value = value;
    node->childCount = childCount;
    return node;
}
// ノードの解放
void freeTreeNode(struct TreeNode* node) {
    for (int i = 0; i < node->childCount; i++) {
        freeTreeNode(node->children[i]);
    }
    free(node);
}
int main() {
    struct TreeNode* root = createTreeNode(1, 2);
    root->children[0] = createTreeNode(2, 0);
    root->children[1] = createTreeNode(3, 0);
    // ツリーの内容を表示
    printf("Root: %d\n", root->value);
    for (int i = 0; i < root->childCount; i++) {
        printf("Child %d: %d\n", i, root->children[i]->value);
    }
    // メモリを解放
    freeTreeNode(root);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// パケットを表す構造体
struct NetworkPacket {
    int length;   // パケットの長さ
    char data[];  // 可変長配列でパケットデータを格納
};
// パケットの作成
struct NetworkPacket* createPacket(const char* payload) {
    int len = strlen(payload);
    struct NetworkPacket* packet = malloc(sizeof(struct NetworkPacket) + len * sizeof(char));
    packet->length = len;
    memcpy(packet->data, payload, len);
    return packet;
}
// パケットの解放
void freePacket(struct NetworkPacket* packet) {
    free(packet);
}
int main() {
    struct NetworkPacket* packet = createPacket("Hello, Network!");
    // パケットの内容を表示
    printf("Packet Length: %d\n", packet->length);
    printf("Packet Data: %s\n", packet->data);
    // メモリを解放
    freePacket(packet);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
// ゲームオブジェクトを表す構造体
struct GameObject {
    int id;        // オブジェクトのID
    int componentCount; // コンポーネントの数
    void* components[]; // 可変長配列でコンポーネントを格納
};
// オブジェクトの作成
struct GameObject* createGameObject(int id, int componentCount) {
    struct GameObject* obj = malloc(sizeof(struct GameObject) + componentCount * sizeof(void*));
    obj->id = id;
    obj->componentCount = componentCount;
    return obj;
}
// オブジェクトの解放
void freeGameObject(struct GameObject* obj) {
    free(obj);
}
int main() {
    struct GameObject* obj = createGameObject(1, 3);
    // オブジェクトの内容を表示
    printf("GameObject ID: %d\n", obj->id);
    printf("Component Count: %d\n", obj->componentCount);
    // メモリを解放
    freeGameObject(obj);
    return 0;
}