[C++] 構造体ポインタの使い方と操作方法

#include <iostream>
// 構造体の定義
struct Person {
    std::string name; // 名前
    int age;          // 年齢
};
// 構造体ポインタの宣言
Person* personPtr;

#include <iostream>
struct Person {
    std::string name;
    int age;
};
int main() {
    // 構造体のインスタンスを作成
    Person person = {"Taro", 30};
    // 構造体ポインタを初期化
    Person* personPtr = &person;
    // ポインタを使ってメンバーにアクセス
    std::cout << "Name: " << personPtr->name << ", Age: " << personPtr->age << std::endl;
    return 0;
}

Name: Taro, Age: 30

#include <iostream>
struct Person {
    std::string name;
    int age;
};
int main() {
    // 動的にメモリを確保
    Person* personPtr = new Person{"Hanako", 25};
    // ポインタを使ってメンバーにアクセス
    std::cout << "Name: " << personPtr->name << ", Age: " << personPtr->age << std::endl;
    // メモリを解放
    delete personPtr;
    return 0;
}

Name: Hanako, Age: 25

#include <iostream>
struct Person {
    std::string name;
    int age;
};
int main() {
    Person person = {"Taro", 30}; // 構造体のインスタンス
    Person* personPtr = &person;  // 構造体ポインタ
    // ドット演算子を使用
    std::cout << "Name: " << person.name << ", Age: " << person.age << std::endl;
    // アロー演算子を使用
    std::cout << "Name: " << personPtr->name << ", Age: " << personPtr->age << std::endl;
    return 0;
}

Name: Taro, Age: 30
Name: Taro, Age: 30

#include <iostream>
struct Person {
    std::string name;
    int age;
};
int main() {
    // 構造体ポインタの配列を動的に確保
    Person* people = new Person[2]{{"Taro", 30}, {"Hanako", 25}};
    // 配列の各要素にアクセス
    for (int i = 0; i < 2; ++i) {
        std::cout << "Name: " << people[i].name << ", Age: " << people[i].age << std::endl;
    }
    // メモリを解放
    delete[] people;
    return 0;
}

Name: Taro, Age: 30
Name: Hanako, Age: 25

#include <iostream>
struct Person {
    std::string name;
    int age;
};
// 構造体ポインタを引数に取る関数
void printPersonInfo(const Person* personPtr) {
    std::cout << "Name: " << personPtr->name << ", Age: " << personPtr->age << std::endl;
}
int main() {
    Person person = {"Taro", 30};
    // 関数に構造体ポインタを渡す
    printPersonInfo(&person);
    return 0;
}

Name: Taro, Age: 30

#include <iostream>
// ノードの構造体
struct Node {
    int data;       // データ
    Node* next;     // 次のノードへのポインタ
};
// リストの要素を表示する関数
void printList(Node* head) {
    Node* current = head;
    while (current != nullptr) {
        std::cout << current->data << " ";
        current = current->next;
    }
    std::cout << std::endl;
}
int main() {
    // ノードを動的に作成
    Node* head = new Node{1, nullptr};
    head->next = new Node{2, nullptr};
    head->next->next = new Node{3, nullptr};
    // リストを表示
    printList(head);
    // メモリを解放
    while (head != nullptr) {
        Node* temp = head;
        head = head->next;
        delete temp;
    }
    return 0;
}

1 2 3

#include <iostream>
// ノードの構造体
struct TreeNode {
    int data;            // データ
    TreeNode* left;      // 左の子ノード
    TreeNode* right;     // 右の子ノード
};
// 中間順巡回でツリーを表示する関数
void inorderTraversal(TreeNode* root) {
    if (root != nullptr) {
        inorderTraversal(root->left);
        std::cout << root->data << " ";
        inorderTraversal(root->right);
    }
}
int main() {
    // ノードを動的に作成
    TreeNode* root = new TreeNode{1, nullptr, nullptr};
    root->left = new TreeNode{2, nullptr, nullptr};
    root->right = new TreeNode{3, nullptr, nullptr};
    root->left->left = new TreeNode{4, nullptr, nullptr};
    root->left->right = new TreeNode{5, nullptr, nullptr};
    // ツリーを中間順巡回で表示
    inorderTraversal(root);
    std::cout << std::endl;
    // メモリを解放(省略)
    return 0;
}

4 2 5 1 3

#include <iostream>
#include <vector>
// データの構造体
struct Data {
    int value;  // データの値
};
// データを動的に追加する関数
void addData(std::vector<Data*>& dataList, int value) {
    Data* newData = new Data{value};
    dataList.push_back(newData);
}
int main() {
    std::vector<Data*> dataList;
    // データを追加
    addData(dataList, 10);
    addData(dataList, 20);
    addData(dataList, 30);
    // データを表示
    for (const auto& data : dataList) {
        std::cout << data->value << " ";
    }
    std::cout << std::endl;
    // メモリを解放
    for (auto& data : dataList) {
        delete data;
    }
    return 0;
}

10 20 30

#include <iostream>
struct Person {
    std::string name;
    int age;
};
int main() {
    // メモリを動的に確保
    Person* personPtr = new Person{"Taro", 30};
    // メモリを使用
    std::cout << "Name: " << personPtr->name << ", Age: " << personPtr->age << std::endl;
    // メモリを解放
    delete personPtr;
    return 0;
}

#include <iostream>
#include <memory> // スマートポインタを使用するために必要
struct Person {
    std::string name;
    int age;
    // 10行目の初期化方法ではコンストラクタが必要
    Person(const std::string& name, int age) : name(name), age(age) {}
};
int main() {
    // std::unique_ptrを使用してメモリを管理
    std::unique_ptr<Person> personPtr = std::make_unique<Person>("Taro", 30);
    // メモリを使用
    std::cout << "Name: " << personPtr->name << ", Age: " << personPtr->age
              << std::endl;
    // メモリは自動的に解放される
    return 0;
}

#include <iostream>
#include <memory>
struct Person {
    std::string name;
    int age;
    // コンストラクタ
    Person(const std::string& n, int a) : name(n), age(a) {
        std::cout << "Person created: " << name << std::endl;
    }
    // デストラクタ
    ~Person() {
        std::cout << "Person destroyed: " << name << std::endl;
    }
};
int main() {
    {
        // スコープ内でstd::unique_ptrを使用
        std::unique_ptr<Person> personPtr = std::make_unique<Person>("Taro", 30);
        std::cout << "Name: " << personPtr->name << ", Age: " << personPtr->age << std::endl;
    } // スコープを抜けると自動的にデストラクタが呼ばれる
    return 0;
}

Person created: Taro
Name: Taro, Age: 30
Person destroyed: Taro