MENU
  1. ホーム
  2. C言語
  3. 基礎構文
  4. 型
  5. 構造体
  6. [C言語] 構造体とポインタの基本と活用法

[C言語] 構造体とポインタの基本と活用法

構造体

C言語における構造体は、異なるデータ型をまとめて扱うためのデータ構造です。

構造体を定義することで、関連するデータを一つの単位として管理できます。

ポインタはメモリ上のアドレスを指す変数で、構造体と組み合わせることで効率的なメモリ操作が可能です。

構造体のポインタを使うと、構造体全体をコピーすることなく、メモリ上のデータを直接操作できます。

これにより、関数間で構造体を渡す際のオーバーヘッドを減らし、プログラムのパフォーマンスを向上させることができます。

構造体ポインタを使う際は、メンバーアクセス演算子->を用いてメンバーにアクセスします。

この記事でわかること
  • 構造体の基本的な定義方法とメンバーへのアクセス方法
  • ポインタの宣言、初期化、メモリアクセス、演算の基礎
  • 構造体とポインタを組み合わせた効率的なデータ操作方法
  • 構造体ポインタを用いたリンクリストやバイナリツリーの実装例
  • 動的メモリ確保を利用した柔軟なデータ管理方法

目次から探す

構造体の基本

構造体とは何か

構造体は、C言語におけるデータ構造の一つで、異なる型のデータを一つのまとまりとして扱うことができます。

これにより、関連するデータを一つの単位として管理しやすくなります。

例えば、学生の情報を管理する場合、名前、年齢、成績などを一つの構造体としてまとめることができます。

構造体の定義方法

構造体はstructキーワードを用いて定義します。

以下に、学生情報を管理する構造体の例を示します。

#include <stdio.h>
// 学生情報を表す構造体の定義
struct Student {
    char name[50];  // 名前
    int age;        // 年齢
    float grade;    // 成績
};

この例では、Studentという構造体を定義し、名前、年齢、成績の3つのメンバーを持たせています。

構造体のメンバーへのアクセス

構造体のメンバーにアクセスするには、ドット演算子.を使用します。

以下に、構造体のメンバーにアクセスする例を示します。

#include <stdio.h>
struct Student {
    char name[50];
    int age;
    float grade;
};
int main() {
    struct Student student1;
    // メンバーへのアクセスと値の代入
    student1.age = 20;
    student1.grade = 3.5;
    snprintf(student1.name, sizeof(student1.name), "Taro");
    // メンバーの値を出力
    printf("Name: %s\n", student1.name);
    printf("Age: %d\n", student1.age);
    printf("Grade: %.2f\n", student1.grade);
    return 0;
}
Name: Taro
Age: 20
Grade: 3.50

このプログラムでは、student1という構造体変数を作成し、そのメンバーに値を代入しています。

snprintf関数を使って文字列を代入することで、バッファオーバーフローを防いでいます。

構造体の初期化

構造体は定義と同時に初期化することができます。

以下に、構造体の初期化の例を示します。

#include <stdio.h>
struct Student {
    char name[50];
    int age;
    float grade;
};
int main() {
    // 構造体の初期化
    struct Student student1 = {"Taro", 20, 3.5};
    // メンバーの値を出力
    printf("Name: %s\n", student1.name);
    printf("Age: %d\n", student1.age);
    printf("Grade: %.2f\n", student1.grade);
    return 0;
}
Name: Taro
Age: 20
Grade: 3.50

この例では、student1を定義すると同時に、名前、年齢、成績を初期化しています。

構造体の初期化は、メンバーの順番に従って値を指定します。

ポインタの基本

ポインタとは何か

ポインタは、メモリ上のアドレスを格納するための変数です。

C言語では、ポインタを使用することで、変数の値そのものではなく、その変数が格納されているメモリのアドレスを操作することができます。

これにより、関数間でのデータの受け渡しや、動的メモリ管理が効率的に行えます。

ポインタの宣言と初期化

ポインタは、データ型の後にアスタリスク*を付けて宣言します。

以下に、ポインタの宣言と初期化の例を示します。

#include <stdio.h>
int main() {
    int value = 10;
    int *pointer = &value;  // ポインタの宣言と初期化
    printf("Value: %d\n", value);
    printf("Pointer Address: %p\n", (void*)pointer);
    printf("Pointer Value: %d\n", *pointer);
    return 0;
}
Value: 10
Pointer Address: 0x7ffee4bff6ac
Pointer Value: 10

この例では、valueという整数変数を宣言し、そのアドレスをpointerというポインタに格納しています。

&演算子を使って変数のアドレスを取得し、ポインタを初期化しています。

ポインタによるメモリアクセス

ポインタを使うと、変数のアドレスを通じてその値にアクセスできます。

以下に、ポインタを使ったメモリアクセスの例を示します。

#include <stdio.h>
int main() {
    int value = 10;
    int *pointer = &value;
    // ポインタを使って値を変更
    *pointer = 20;
    printf("Value: %d\n", value);
    printf("Pointer Value: %d\n", *pointer);
    return 0;
}
Value: 20
Pointer Value: 20

この例では、ポインタを使ってvalueの値を変更しています。

*pointerとすることで、ポインタが指すアドレスの値にアクセスし、変更することができます。

ポインタの演算

ポインタは、整数を加算または減算することで、メモリ上の次の要素や前の要素を指すように変更できます。

以下に、ポインタの演算の例を示します。

#include <stdio.h>
int main() {
    int array[3] = {10, 20, 30};
    int *pointer = array;  // 配列の先頭を指すポインタ
    printf("First Element: %d\n", *pointer);
    pointer++;  // 次の要素を指す
    printf("Second Element: %d\n", *pointer);
    pointer++;  // 次の要素を指す
    printf("Third Element: %d\n", *pointer);
    return 0;
}
First Element: 10
Second Element: 20
Third Element: 30

この例では、arrayの各要素をポインタ演算を使って順にアクセスしています。

ポインタに++を適用することで、次のメモリ位置を指すようにしています。

ポインタ演算は、ポインタが指すデータ型のサイズに基づいて行われます。

構造体とポインタの組み合わせ

構造体ポインタの宣言

構造体ポインタは、構造体のアドレスを格納するためのポインタです。

構造体ポインタを宣言するには、構造体の型名の後にアスタリスク*を付けます。

以下に、構造体ポインタの宣言の例を示します。

#include <stdio.h>
struct Student {
    char name[50];
    int age;
    float grade;
};
int main() {
    struct Student student1;
    struct Student *studentPtr;  // 構造体ポインタの宣言
    return 0;
}

この例では、Student構造体のポインタであるstudentPtrを宣言しています。

構造体ポインタの初期化

構造体ポインタを初期化するには、構造体変数のアドレスを取得してポインタに代入します。

以下に、構造体ポインタの初期化の例を示します。

#include <stdio.h>
struct Student {
    char name[50];
    int age;
    float grade;
};
int main() {
    struct Student student1 = {"Taro", 20, 3.5};
    struct Student *studentPtr = &student1;  // 構造体ポインタの初期化
    return 0;
}

この例では、student1のアドレスをstudentPtrに代入することで、構造体ポインタを初期化しています。

構造体ポインタを使ったメンバーアクセス

構造体ポインタを使ってメンバーにアクセスするには、アロー演算子->を使用します。

以下に、構造体ポインタを使ったメンバーアクセスの例を示します。

#include <stdio.h>
struct Student {
    char name[50];
    int age;
    float grade;
};
int main() {
    struct Student student1 = {"Taro", 20, 3.5};
    struct Student *studentPtr = &student1;
    // 構造体ポインタを使ったメンバーアクセス
    printf("Name: %s\n", studentPtr->name);
    printf("Age: %d\n", studentPtr->age);
    printf("Grade: %.2f\n", studentPtr->grade);
    return 0;
}
Name: Taro
Age: 20
Grade: 3.50

この例では、studentPtrを使ってstudent1のメンバーにアクセスしています。

アロー演算子を使うことで、ポインタが指す構造体のメンバーに直接アクセスできます。

構造体ポインタの利点

構造体ポインタを使用することで、以下のような利点があります。

  • メモリ効率の向上: 構造体そのものを関数に渡すのではなく、ポインタを渡すことで、メモリの使用量を削減できます。
  • データの直接操作: ポインタを使うことで、関数内で構造体のメンバーを直接操作することができます。
  • 動的メモリ管理: 構造体ポインタを使うことで、動的にメモリを確保し、柔軟にデータを管理することが可能です。

これらの利点により、構造体ポインタは効率的なプログラムを作成するための重要な手段となります。

構造体とポインタの活用法

関数への構造体ポインタの渡し方

構造体を関数に渡す際、構造体そのものを渡すとコピーが作成されるため、メモリ効率が悪くなります。

構造体ポインタを渡すことで、コピーを避け、関数内で元の構造体を直接操作できます。

以下に、構造体ポインタを関数に渡す例を示します。

#include <stdio.h>
struct Student {
    char name[50];
    int age;
    float grade;
};
// 構造体ポインタを受け取る関数
void printStudentInfo(struct Student *studentPtr) {
    printf("Name: %s\n", studentPtr->name);
    printf("Age: %d\n", studentPtr->age);
    printf("Grade: %.2f\n", studentPtr->grade);
}
int main() {
    struct Student student1 = {"Taro", 20, 3.5};
    printStudentInfo(&student1);  // 構造体ポインタを渡す
    return 0;
}
Name: Taro
Age: 20
Grade: 3.50

この例では、printStudentInfo関数にstudent1のアドレスを渡し、関数内で構造体のメンバーを出力しています。

構造体配列とポインタ

構造体の配列を扱う際、ポインタを使うことで効率的に操作できます。

以下に、構造体配列とポインタの例を示します。

#include <stdio.h>
struct Student {
    char name[50];
    int age;
    float grade;
};
int main() {
    struct Student students[2] = {
        {"Taro", 20, 3.5},
        {"Hanako", 22, 3.8}
    };
    struct Student *studentPtr = students;  // 配列の先頭を指すポインタ
    for (int i = 0; i < 2; i++) {
        printf("Name: %s\n", (studentPtr + i)->name);
        printf("Age: %d\n", (studentPtr + i)->age);
        printf("Grade: %.2f\n", (studentPtr + i)->grade);
    }
    return 0;
}
Name: Taro
Age: 20
Grade: 3.50
Name: Hanako
Age: 22
Grade: 3.80

この例では、students配列の先頭を指すポインタを使って、各要素にアクセスしています。

動的メモリ確保と構造体ポインタ

動的メモリ確保を使うことで、実行時に必要なメモリを柔軟に確保できます。

以下に、構造体ポインタを使った動的メモリ確保の例を示します。

#include <stdio.h>
#include <stdlib.h>
struct Student {
    char name[50];
    int age;
    float grade;
};
int main() {
    struct Student *studentPtr = (struct Student *)malloc(sizeof(struct Student));  // メモリ確保
    if (studentPtr == NULL) {
        printf("メモリの確保に失敗しました。\n");
        return 1;
    }
    // メンバーの初期化
    snprintf(studentPtr->name, sizeof(studentPtr->name), "Taro");
    studentPtr->age = 20;
    studentPtr->grade = 3.5;
    // メンバーの出力
    printf("Name: %s\n", studentPtr->name);
    printf("Age: %d\n", studentPtr->age);
    printf("Grade: %.2f\n", studentPtr->grade);
    free(studentPtr);  // メモリの解放
    return 0;
}
Name: Taro
Age: 20
Grade: 3.50

この例では、malloc関数を使ってStudent構造体のメモリを動的に確保し、使用後にfree関数で解放しています。

構造体ポインタを使ったデータ構造の実装

構造体ポインタを使うことで、リンクリストやツリーなどの複雑なデータ構造を実装できます。

以下に、単方向リンクリストのノードを表す構造体の例を示します。

#include <stdio.h>
#include <stdlib.h>
// リンクリストのノードを表す構造体
struct Node {
    int data;
    struct Node *next;
};
// 新しいノードを作成する関数
struct Node* createNode(int data) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("メモリの確保に失敗しました。\n");
        return NULL;
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
int main() {
    struct Node *head = createNode(10);
    head->next = createNode(20);
    head->next->next = createNode(30);
    // リストの出力
    struct Node *current = head;
    while (current != NULL) {
        printf("Data: %d\n", current->data);
        current = current->next;
    }
    // メモリの解放
    current = head;
    while (current != NULL) {
        struct Node *next = current->next;
        free(current);
        current = next;
    }
    return 0;
}
Data: 10
Data: 20
Data: 30

この例では、Node構造体を使って単方向リンクリストを実装しています。

createNode関数で新しいノードを作成し、リストを構築しています。

使用後は、各ノードのメモリを解放しています。

応用例

リンクリストの実装

リンクリストは、ノードと呼ばれる要素が連結されたデータ構造です。

各ノードはデータと次のノードへのポインタを持ちます。

以下に、単方向リンクリストの実装例を示します。

#include <stdio.h>
#include <stdlib.h>
// リンクリストのノードを表す構造体
struct Node {
    int data;
    struct Node *next;
};
// 新しいノードを作成する関数
struct Node* createNode(int data) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    if (newNode == NULL) {
        printf("メモリの確保に失敗しました。\n");
        return NULL;
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
// リストの出力
void printList(struct Node *head) {
    struct Node *current = head;
    while (current != NULL) {
        printf("Data: %d\n", current->data);
        current = current->next;
    }
}
int main() {
    struct Node *head = createNode(10);
    head->next = createNode(20);
    head->next->next = createNode(30);
    printList(head);
    // メモリの解放
    struct Node *current = head;
    while (current != NULL) {
        struct Node *next = current->next;
        free(current);
        current = next;
    }
    return 0;
}
Data: 10
Data: 20
Data: 30

この例では、Node構造体を使ってリンクリストを実装し、createNode関数でノードを作成しています。

printList関数でリストの内容を出力し、使用後にメモリを解放しています。

バイナリツリーの実装

バイナリツリーは、各ノードが最大で2つの子ノードを持つ階層的なデータ構造です。

以下に、バイナリツリーの実装例を示します。

#include <stdio.h>
#include <stdlib.h>
// バイナリツリーのノードを表す構造体
struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
};
// 新しいノードを作成する関数
struct TreeNode* createTreeNode(int data) {
    struct TreeNode *newNode = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    if (newNode == NULL) {
        printf("メモリの確保に失敗しました。\n");
        return NULL;
    }
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}
// 中間順巡回でツリーを出力
void inorderTraversal(struct TreeNode *root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("Data: %d\n", root->data);
        inorderTraversal(root->right);
    }
}
int main() {
    struct TreeNode *root = createTreeNode(10);
    root->left = createTreeNode(5);
    root->right = createTreeNode(15);
    root->left->left = createTreeNode(3);
    root->left->right = createTreeNode(7);
    inorderTraversal(root);
    // メモリの解放は省略(実際の実装では必要)
    return 0;
}
Data: 3
Data: 5
Data: 7
Data: 10
Data: 15

この例では、TreeNode構造体を使ってバイナリツリーを実装し、createTreeNode関数でノードを作成しています。

inorderTraversal関数でツリーを中間順に巡回し、ノードのデータを出力しています。

グラフデータ構造の実装

グラフは、ノード(頂点)とそれらを結ぶエッジ(辺)からなるデータ構造です。

以下に、隣接リストを使ったグラフの実装例を示します。

#include <stdio.h>
#include <stdlib.h>
// グラフのノードを表す構造体
struct GraphNode {
    int vertex;
    struct GraphNode *next;
};
// グラフを表す構造体
struct Graph {
    int numVertices;
    struct GraphNode **adjLists;
};
// 新しいノードを作成する関数
struct GraphNode* createGraphNode(int vertex) {
    struct GraphNode *newNode = (struct GraphNode *)malloc(sizeof(struct GraphNode));
    if (newNode == NULL) {
        printf("メモリの確保に失敗しました。\n");
        return NULL;
    }
    newNode->vertex = vertex;
    newNode->next = NULL;
    return newNode;
}
// グラフを作成する関数
struct Graph* createGraph(int vertices) {
    struct Graph *graph = (struct Graph *)malloc(sizeof(struct Graph));
    graph->numVertices = vertices;
    graph->adjLists = (struct GraphNode **)malloc(vertices * sizeof(struct GraphNode *));
    for (int i = 0; i < vertices; i++) {
        graph->adjLists[i] = NULL;
    }
    return graph;
}
// エッジを追加する関数
void addEdge(struct Graph *graph, int src, int dest) {
    struct GraphNode *newNode = createGraphNode(dest);
    newNode->next = graph->adjLists[src];
    graph->adjLists[src] = newNode;
    // 無向グラフの場合、逆方向のエッジも追加
    newNode = createGraphNode(src);
    newNode->next = graph->adjLists[dest];
    graph->adjLists[dest] = newNode;
}
// グラフを出力する関数
void printGraph(struct Graph *graph) {
    for (int v = 0; v < graph->numVertices; v++) {
        struct GraphNode *temp = graph->adjLists[v];
        printf("\n Vertex %d\n: ", v);
        while (temp) {
            printf("%d -> ", temp->vertex);
            temp = temp->next;
        }
        printf("NULL\n");
    }
}
int main() {
    struct Graph *graph = createGraph(4);
    addEdge(graph, 0, 1);
    addEdge(graph, 0, 2);
    addEdge(graph, 1, 2);
    addEdge(graph, 2, 3);
    printGraph(graph);
    // メモリの解放は省略(実際の実装では必要)
    return 0;
}
Vertex 0
: 2 -> 1 -> NULL
Vertex 1
: 2 -> 0 -> NULL
Vertex 2
: 3 -> 1 -> 0 -> NULL
Vertex 3
: 2 -> NULL

この例では、GraphNodeとGraph構造体を使ってグラフを実装し、createGraphNodeとcreateGraph関数でノードとグラフを作成しています。

addEdge関数でエッジを追加し、printGraph関数でグラフの隣接リストを出力しています。

よくある質問

構造体とポインタを使うメリットは何ですか？

構造体とポインタを組み合わせて使用することには、いくつかのメリットがあります。

  • メモリ効率の向上: 構造体そのものを関数に渡すと、構造体全体がコピーされるため、メモリを多く消費します。

ポインタを渡すことで、コピーを避け、メモリ使用量を削減できます。

  • データの直接操作: ポインタを使うことで、関数内で構造体のメンバーを直接操作することができます。

これにより、データの変更が即座に反映されます。

  • 動的メモリ管理: 構造体ポインタを使うことで、動的にメモリを確保し、実行時に必要なデータ量に応じて柔軟に管理することが可能です。

構造体ポインタを使う際の注意点は？

構造体ポインタを使用する際には、いくつかの注意点があります。

  • メモリ管理: 動的にメモリを確保した場合、使用後に必ずfree関数を使ってメモリを解放する必要があります。

これを怠ると、メモリリークが発生し、プログラムのメモリ使用量が増加します。

  • NULLポインタのチェック: ポインタがNULLでないことを確認してからアクセスするようにしましょう。

NULLポインタを参照すると、プログラムがクラッシュする原因となります。

  • ポインタの不正な操作: ポインタ演算を行う際には、ポインタが指すメモリ領域の範囲を超えないように注意が必要です。

範囲外のメモリにアクセスすると、予期しない動作を引き起こす可能性があります。

構造体のサイズを知る方法は？

構造体のサイズを知るには、sizeof演算子を使用します。

sizeof演算子は、指定したデータ型や変数のメモリサイズをバイト単位で返します。

例：sizeof(struct Student)。

これにより、構造体がメモリ上でどれだけのスペースを占有するかを確認できます。

構造体のサイズは、メンバーの型やアライメントによって異なることがあります。

まとめ

この記事では、C言語における構造体とポインタの基本的な概念から、それらを組み合わせた活用法までを詳しく解説しました。

構造体とポインタを効果的に利用することで、メモリ効率の向上やデータ構造の柔軟な管理が可能になります。

これを機に、実際のプログラムで構造体とポインタを活用し、より効率的なコードを書いてみてはいかがでしょうか。

目次に戻る

当サイトはリンクフリーです。出典元を明記していただければ、ご自由に引用していただいて構いません。

C言語
C++
Python
HTML
Java
HTTP

関連カテゴリーから探す

構造体
  • URLをコピーしました！

関連記事

目次から探す