[C言語] アロー演算子の使い方と構造体ポインタの操作

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 構造体の定義
typedef struct {
    int id;
    char name[50];
} Student;
int main() {
    // 構造体のインスタンスを動的に確保
    Student *studentPtr = (Student *)malloc(sizeof(Student));
    // アロー演算子を使ってメンバにアクセス
    studentPtr->id = 1;
    strcpy(studentPtr->name, "Taro Yamada");
    // 結果を表示
    printf("ID: %d, Name: %s\n", studentPtr->id, studentPtr->name);
    // メモリの解放
    free(studentPtr);
    return 0;
}

ID: 1, Name: Taro Yamada

#include <stdio.h>
typedef struct {
    int age;
    float height;
} Person;
void printPersonDetails(Person *p) {
    // アロー演算子を使ってメンバにアクセス
    printf("Age: %d, Height: %.2f\n", p->age, p->height);
}
int main() {
    Person person = {25, 175.5};
    printPersonDetails(&person);
    return 0;
}

Age: 25, Height: 175.50

#include <stdio.h>
typedef struct {
    char title[100];
    int pages;
} Book;
void printBookInfo(Book *b) {
    // アロー演算子を使ってメンバにアクセス
    printf("Title: %s, Pages: %d\n", b->title, b->pages);
}
int main() {
    Book myBook = {"C Programming Language", 279};
    printBookInfo(&myBook);
    return 0;
}

Title: C Programming Language, Pages: 279

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 構造体の定義
typedef struct {
    int id;
    char name[50];
} Employee;
int main() {
    // メモリの動的確保
    Employee *empPtr = (Employee *)malloc(sizeof(Employee));
    if (empPtr == NULL) {
        printf("メモリの確保に失敗しました。\n");
        return 1;
    }
    // メンバの設定
    empPtr->id = 101;
    strcpy(empPtr->name, "Hanako Suzuki");
    // 結果の表示
    printf("ID: %d, Name: %s\n", empPtr->id, empPtr->name);
    // メモリの解放
    free(empPtr);
    return 0;
}

ID: 101, Name: Hanako Suzuki

#include <stdio.h>
#include <stdlib.h>
typedef struct {
    int age;
    float salary;
} Worker;
Worker* initializeWorker(int age, float salary) {
    // メモリの動的確保
    Worker *workerPtr = (Worker *)malloc(sizeof(Worker));
    if (workerPtr != NULL) {
        // メンバの初期化
        workerPtr->age = age;
        workerPtr->salary = salary;
    }
    return workerPtr;
}
int main() {
    Worker *worker = initializeWorker(30, 50000.0);
    if (worker != NULL) {
        printf("Age: %d, Salary: %.2f\n", worker->age, worker->salary);
        free(worker);
    }
    return 0;
}

Age: 30, Salary: 50000.00

#include <stdio.h>
typedef struct {
    char name[50];
    int score;
} Player;
void updateScore(Player *p, int newScore) {
    // スコアの更新
    p->score = newScore;
}
int main() {
    Player player = {"Satoshi", 85};
    printf("Before update: %s, Score: %d\n", player.name, player.score);
    // 関数にポインタを渡してスコアを更新
    updateScore(&player, 95);
    printf("After update: %s, Score: %d\n", player.name, player.score);
    return 0;
}

Before update: Satoshi, Score: 85
After update: Satoshi, Score: 95

#include <stdio.h>
#include <stdlib.h>
// ノードの定義
typedef struct Node {
    int data;
    struct Node *next;
} Node;
// ノードの追加
void append(Node **head, int newData) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    Node *last = *head;
    newNode->data = newData;
    newNode->next = NULL;
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    while (last->next != NULL) {
        last = last->next;
    }
    last->next = newNode;
}
// リストの表示
void printList(Node *node) {
    while (node != NULL) {
        printf("%d -> ", node->data);
        node = node->next;
    }
    printf("NULL\n");
}
int main() {
    Node *head = NULL;
    append(&head, 10);
    append(&head, 20);
    append(&head, 30);
    printList(head);
    return 0;
}

10 -> 20 -> 30 -> NULL

#include <stdio.h>
#include <stdlib.h>
// ノードの定義
typedef struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;
// 新しいノードの作成
TreeNode* newNode(int data) {
    TreeNode *node = (TreeNode *)malloc(sizeof(TreeNode));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}
// 中間順巡回
void inorderTraversal(TreeNode *root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("%d ", root->data);
        inorderTraversal(root->right);
    }
}
int main() {
    TreeNode *root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    printf("Inorder traversal: ");
    inorderTraversal(root);
    printf("\n");
    return 0;
}

Inorder traversal: 4 2 5 1 3

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 学生の定義
typedef struct Student {
    int id;
    char name[50];
    struct Student *next;
} Student;
// 新しい学生の追加
void addStudent(Student **head, int id, const char *name) {
    Student *newStudent = (Student *)malloc(sizeof(Student));
    newStudent->id = id;
    strcpy(newStudent->name, name);
    newStudent->next = *head;
    *head = newStudent;
}
// 学生情報の表示
void printStudents(Student *student) {
    while (student != NULL) {
        printf("ID: %d, Name: %s\n", student->id, student->name);
        student = student->next;
    }
}
int main() {
    Student *head = NULL;
    addStudent(&head, 1, "Taro");
    addStudent(&head, 2, "Jiro");
    addStudent(&head, 3, "Saburo");
    printStudents(head);
    return 0;
}

ID: 3, Name: Saburo
ID: 2, Name: Jiro
ID: 1, Name: Taro