クラス

[C++] クラスの配列を扱う方法とメンバのアクセス方法を解説

2025-01-18更新日: 2025-01-18

C++でクラスの配列を扱うには、まずクラスを定義し、そのクラス型の配列を作成します。

クラスの配列は、通常のデータ型の配列と同様に扱えます。

例えば、ClassName arr[10];のように宣言します。

配列の各要素はクラスのインスタンスであり、インデックスを使ってアクセスできます。

メンバへのアクセスは、配列の要素に対してドット演算子を使います。

例えば、arr[0].memberFunction()やarr[1].memberVariableのように、インデックスで指定した要素のメンバ関数やメンバ変数にアクセスします。

目次から探す

クラスの配列を作成する方法
クラスの配列にアクセスする方法
動的メモリ管理とクラスの配列
コンストラクタとデストラクタの動作
クラスの配列を使った応用例
まとめ

クラスの配列を作成する方法

クラスの基本的な定義

C++におけるクラスは、データとそのデータに関連する操作をまとめたユーザー定義の型です。

以下は、基本的なクラスの定義の例です。

#include <iostream>
#include <string>
class Person {
public:
    std::string name; // 名前
    int age;          // 年齢
    // コンストラクタ
    Person(std::string n, int a) : name(n), age(a) {}
};

この例では、Personというクラスを定義し、名前と年齢をメンバ変数として持っています。

コンストラクタを使って、オブジェクトの初期化を行います。

クラス型の配列を宣言する

クラス型の配列を宣言するには、通常の配列と同様に、クラス名の後に配列のサイズを指定します。

以下は、Personクラスの配列を宣言する例です。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    Person people[3]; // Person型の配列を宣言
    return 0;
}

このコードでは、Person型の配列peopleを3つの要素で宣言しています。

コンストラクタを使った配列の初期化

配列の要素を初期化するためには、コンストラクタを使用します。

以下の例では、配列の各要素を初期化しています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    Person people[3] = {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    for (int i = 0; i < 3; i++) {
        std::cout << people[i].name << "は" << people[i].age << "歳です。" << std::endl;
    }
    return 0;
}

山田太郎は25歳です。
鈴木花子は30歳です。
佐藤次郎は22歳です。

このコードでは、Person型の配列peopleを初期化し、各要素の名前と年齢を出力しています。

配列の要素数を指定する方法

配列の要素数は、宣言時に指定する必要があります。

要素数を変数で指定することも可能です。

以下の例では、要素数を変数で指定しています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    const int size = 3; // 配列のサイズを変数で指定
    Person people[size] = {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    for (int i = 0; i < size; i++) {
        std::cout << people[i].name << "は" << people[i].age << "歳です。" << std::endl;
    }
    return 0;
}

山田太郎は25歳です。
鈴木花子は30歳です。
佐藤次郎は22歳です。

動的配列の作成(newを使った方法)

動的配列を作成するには、new演算子を使用します。

以下の例では、動的にPerson型の配列を作成しています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    int size = 3; // 配列のサイズ
    Person* people = new Person[size] {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    for (int i = 0; i < size; i++) {
        std::cout << people[i].name << "は" << people[i].age << "歳です。" << std::endl;
    }
    delete[] people; // メモリの解放
    return 0;
}

山田太郎は25歳です。
鈴木花子は30歳です。
佐藤次郎は22歳です。

このコードでは、newを使って動的にPerson型の配列を作成し、使用後にdelete[]でメモリを解放しています。

クラスの配列にアクセスする方法

配列の要素にアクセスする基本

C++では、配列の要素にアクセスするためにインデックスを使用します。

配列のインデックスは0から始まります。

以下の例では、Person型の配列の要素にアクセスしています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    Person people[3] = {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    // 配列の要素にアクセス
    std::cout << people[0].name << "は" << people[0].age << "歳です。" << std::endl;
    return 0;
}

山田太郎は25歳です。

このコードでは、people配列の最初の要素にアクセスし、その名前と年齢を出力しています。

メンバ変数へのアクセス方法

クラスの配列の要素に含まれるメンバ変数には、ドット演算子を使用してアクセスします。

以下の例では、配列の各要素のメンバ変数にアクセスしています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    Person people[3] = {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    for (int i = 0; i < 3; i++) {
        std::cout << people[i].name << "は" << people[i].age << "歳です。" << std::endl;
    }
    return 0;
}

山田太郎は25歳です。
鈴木花子は30歳です。
佐藤次郎は22歳です。

このコードでは、forループを使って配列の各要素のメンバ変数にアクセスし、出力しています。

メンバ関数へのアクセス方法

クラスの配列の要素に含まれるメンバ関数にも、ドット演算子を使用してアクセスできます。

以下の例では、メンバ関数を定義し、配列の要素から呼び出しています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
    void introduce() { // 自己紹介のメンバ関数
        std::cout << "私の名前は" << name << "で、" << age << "歳です。" << std::endl;
    }
};
int main() {
    Person people[3] = {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    for (int i = 0; i < 3; i++) {
        people[i].introduce(); // メンバ関数を呼び出す
    }
    return 0;
}

私の名前は山田太郎で、25歳です。
私の名前は鈴木花子で、30歳です。
私の名前は佐藤次郎で、22歳です。

このコードでは、introduceというメンバ関数を定義し、配列の各要素から呼び出しています。

インデックスを使ったアクセスの例

配列のインデックスを使って、特定の要素にアクセスすることができます。

以下の例では、特定のインデックスの要素にアクセスし、その情報を出力しています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    Person people[3] = {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    int index = 1; // アクセスしたいインデックス
    std::cout << people[index].name << "は" << people[index].age << "歳です。" << std::endl;
    return 0;
}

鈴木花子は30歳です。

このコードでは、インデックス1を使ってpeople配列の2番目の要素にアクセスし、その情報を出力しています。

ループを使った配列の操作

配列の要素を操作するために、ループを使用することが一般的です。

以下の例では、配列の各要素の年齢を1歳ずつ増やす操作を行っています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    Person people[3] = {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    for (int i = 0; i < 3; i++) {
        people[i].age++; // 年齢を1歳増やす
    }
    for (int i = 0; i < 3; i++) {
        std::cout << people[i].name << "は" << people[i].age << "歳です。" << std::endl;
    }
    return 0;
}

山田太郎は26歳です。
鈴木花子は31歳です。
佐藤次郎は23歳です。

このコードでは、最初のforループで年齢を1歳増やし、次のforループで更新された年齢を出力しています。

動的メモリ管理とクラスの配列

動的配列の作成と解放

C++では、new演算子を使用して動的に配列を作成することができます。

動的配列を使用する場合、使用後には必ずdelete[]を使ってメモリを解放する必要があります。

以下の例では、動的にPerson型の配列を作成し、使用後に解放しています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    int size = 3; // 配列のサイズ
    Person* people = new Person[size] {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    for (int i = 0; i < size; i++) {
        std::cout << people[i].name << "は" << people[i].age << "歳です。" << std::endl;
    }
    delete[] people; // メモリの解放
    return 0;
}

山田太郎は25歳です。
鈴木花子は30歳です。
佐藤次郎は22歳です。

このコードでは、newを使って動的にPerson型の配列を作成し、使用後にdelete[]でメモリを解放しています。

std::vectorを使ったクラスの配列管理

C++の標準ライブラリには、動的配列を簡単に管理できるstd::vectorがあります。

std::vectorを使用することで、メモリ管理が自動化され、要素の追加や削除も容易になります。

以下の例では、std::vectorを使ってPerson型の配列を管理しています。

#include <iostream>
#include <string>
#include <vector>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    std::vector<Person> people; // std::vectorを使用
    // 要素の追加
    people.push_back(Person("山田太郎", 25));
    people.push_back(Person("鈴木花子", 30));
    people.push_back(Person("佐藤次郎", 22));
    for (const auto& person : people) {
        std::cout << person.name << "は" << person.age << "歳です。" << std::endl;
    }
    return 0;
}

山田太郎は25歳です。
鈴木花子は30歳です。
佐藤次郎は22歳です。

このコードでは、std::vectorを使ってPerson型のオブジェクトを管理し、要素を追加しています。

std::vectorは自動的にメモリを管理してくれるため、手動での解放は不要です。

std::unique_ptrやstd::shared_ptrを使った配列管理

C++11以降、スマートポインタを使用することで、メモリ管理をより安全に行うことができます。

std::unique_ptrやstd::shared_ptrを使うことで、メモリリークを防ぐことができます。

以下の例では、std::unique_ptrを使って動的配列を管理しています。

#include <iostream>
#include <string>
#include <memory> // std::unique_ptrを使用するために必要
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
int main() {
    int size = 3; // 配列のサイズ
    std::unique_ptr<Person[]> people(new Person[size] {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    });
    for (int i = 0; i < size; i++) {
        std::cout << people[i].name << "は" << people[i].age << "歳です。" << std::endl;
    }
    // メモリの解放は不要、unique_ptrが自動で行う
    return 0;
}

山田太郎は25歳です。
鈴木花子は30歳です。
佐藤次郎は22歳です。

このコードでは、std::unique_ptrを使って動的配列を管理しており、スコープを抜けると自動的にメモリが解放されます。

メモリリークを防ぐための注意点

メモリリークを防ぐためには、以下の点に注意することが重要です。

手動メモリ管理の際は、必ずdeleteまたはdelete[]を使用する: newで確保したメモリは、必ず解放する必要があります。
スマートポインタを使用する: std::unique_ptrやstd::shared_ptrを使用することで、メモリ管理を自動化し、メモリリークを防ぐことができます。
例外処理を考慮する: 例外が発生した場合でも、メモリが解放されるように設計することが重要です。

スマートポインタを使用することで、例外発生時のメモリ管理が容易になります。

使用後のポインタをNULLに設定する: 手動でメモリを解放した後は、ポインタをNULLに設定することで、ダングリングポインタを防ぐことができます。

コンストラクタとデストラクタの動作

配列の要素ごとのコンストラクタ呼び出し

C++では、クラスの配列を作成すると、各要素に対してコンストラクタが自動的に呼び出されます。

以下の例では、Personクラスの配列を作成し、各要素のコンストラクタが呼び出される様子を示しています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    // コンストラクタ
    Person(std::string n, int a) : name(n), age(a) {
        std::cout << name << "のコンストラクタが呼び出されました。" << std::endl;
    }
};
int main() {
    Person people[3] = {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    return 0;
}

山田太郎のコンストラクタが呼び出されました。
鈴木花子のコンストラクタが呼び出されました。
佐藤次郎のコンストラクタが呼び出されました。

このコードでは、Person型の配列を作成すると、各要素のコンストラクタが呼び出され、メッセージが出力されます。

デストラクタの自動呼び出し

配列の要素がスコープを抜けると、各要素のデストラクタが自動的に呼び出されます。

以下の例では、Personクラスにデストラクタを追加し、配列の要素が解放される際にデストラクタが呼び出される様子を示しています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {
        std::cout << name << "のコンストラクタが呼び出されました。" << std::endl;
    }
    // デストラクタ
    ~Person() {
        std::cout << name << "のデストラクタが呼び出されました。" << std::endl;
    }
};
int main() {
    Person people[3] = {
        Person("山田太郎", 25),
        Person("鈴木花子", 30),
        Person("佐藤次郎", 22)
    };
    return 0;
}

山田太郎のコンストラクタが呼び出されました。
鈴木花子のコンストラクタが呼び出されました。
佐藤次郎のコンストラクタが呼び出されました。
佐藤次郎のデストラクタが呼び出されました。
鈴木花子のデストラクタが呼び出されました。
山田太郎のデストラクタが呼び出されました。

このコードでは、配列の要素がスコープを抜ける際に、各要素のデストラクタが呼び出され、メッセージが出力されます。

デフォルトコンストラクタが必要な場合

配列を作成する際、デフォルトコンストラクタが必要な場合があります。

デフォルトコンストラクタは、引数なしで呼び出されるコンストラクタです。

以下の例では、デフォルトコンストラクタを持つPersonクラスを定義し、配列を作成しています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    // デフォルトコンストラクタ
    Person() : name("無名"), age(0) {
        std::cout << "デフォルトコンストラクタが呼び出されました。" << std::endl;
    }
    // 引数付きコンストラクタ
    Person(std::string n, int a) : name(n), age(a) {
        std::cout << name << "のコンストラクタが呼び出されました。" << std::endl;
    }
};
int main() {
    Person people[3]; // デフォルトコンストラクタが呼び出される
    return 0;
}

デフォルトコンストラクタが呼び出されました。
デフォルトコンストラクタが呼び出されました。
デフォルトコンストラクタが呼び出されました。

このコードでは、Person型の配列を作成すると、デフォルトコンストラクタが呼び出され、メッセージが出力されます。

コピーコンストラクタとムーブコンストラクタの動作

C++では、オブジェクトのコピーや移動を行う際に、コピーコンストラクタやムーブコンストラクタが呼び出されます。

以下の例では、コピーコンストラクタとムーブコンストラクタを持つPersonクラスを定義し、それぞれの動作を示しています。

#include <iostream>
#include <string>
class Person {
public:
    std::string name;
    int age;
    // 引数付きコンストラクタ
    Person(std::string n, int a) : name(n), age(a) {
        std::cout << name << "のコンストラクタが呼び出されました。" << std::endl;
    }
    // コピーコンストラクタ
    Person(const Person& other) : name(other.name), age(other.age) {
        std::cout << name << "のコピーコンストラクタが呼び出されました。" << std::endl;
    }
    // ムーブコンストラクタ
    Person(Person&& other) noexcept : name(std::move(other.name)), age(other.age) {
        std::cout << name << "のムーブコンストラクタが呼び出されました。" << std::endl;
    }
};
int main() {
    Person original("山田太郎", 25); // 引数付きコンストラクタ
    Person copy = original; // コピーコンストラクタ
    Person moved = std::move(original); // ムーブコンストラクタ
    return 0;
}

山田太郎のコンストラクタが呼び出されました。
山田太郎のコピーコンストラクタが呼び出されました。
山田太郎のムーブコンストラクタが呼び出されました。

このコードでは、Personオブジェクトをコピーした際にコピーコンストラクタが呼び出され、ムーブした際にはムーブコンストラクタが呼び出される様子を示しています。

クラスの配列を使った応用例

クラスの配列を使ったオブジェクト管理

クラスの配列を使用することで、複数のオブジェクトを効率的に管理できます。

以下の例では、Bookクラスを定義し、書籍の情報を管理するための配列を作成しています。

#include <iostream>
#include <string>
class Book {
public:
    std::string title;
    std::string author;
    Book(std::string t, std::string a) : title(t), author(a) {}
};
int main() {
    Book library[3] = {
        Book("C++プログラミング", "山田太郎"),
        Book("デザインパターン", "鈴木花子"),
        Book("アルゴリズム入門", "佐藤次郎")
    };
    for (const auto& book : library) {
        std::cout << book.title << " by " << book.author << std::endl;
    }
    return 0;
}

C++プログラミング by 山田太郎
デザインパターン by 鈴木花子
アルゴリズム入門 by 佐藤次郎

このコードでは、Book型の配列を作成し、書籍のタイトルと著者を出力しています。

クラスの配列を使ったゲームのキャラクタ管理

ゲーム開発において、キャラクタの情報を管理するためにクラスの配列を使用することが一般的です。

以下の例では、Characterクラスを定義し、ゲーム内のキャラクタを管理しています。

#include <iostream>
#include <string>
class Character {
public:
    std::string name;
    int health;
    Character(std::string n, int h) : name(n), health(h) {}
    void displayStatus() {
        std::cout << name << "のHP: " << health << std::endl;
    }
};
int main() {
    Character party[3] = {
        Character("勇者", 100),
        Character("魔法使い", 80),
        Character("盗賊", 60)
    };
    for (const auto& character : party) {
        character.displayStatus();
    }
    return 0;
}

勇者のHP: 100
魔法使いのHP: 80
盗賊のHP: 60

このコードでは、Character型の配列を作成し、各キャラクタのHPを表示しています。

クラスの配列を使ったデータベースのシミュレーション

クラスの配列を使用して、簡単なデータベースのシミュレーションを行うこともできます。

以下の例では、Studentクラスを定義し、学生の情報を管理しています。

#include <iostream>
#include <string>
class Student {
public:
    std::string name;
    int id;
    Student(std::string n, int i) : name(n), id(i) {}
};
int main() {
    Student database[3] = {
        Student("山田太郎", 1),
        Student("鈴木花子", 2),
        Student("佐藤次郎", 3)
    };
    for (const auto& student : database) {
        std::cout << "名前: " << student.name << ", ID: " << student.id << std::endl;
    }
    return 0;
}

名前: 山田太郎, ID: 1
名前: 鈴木花子, ID: 2
名前: 佐藤次郎, ID: 3

このコードでは、Student型の配列を作成し、各学生の名前とIDを表示しています。

クラスの配列を使ったソートや検索アルゴリズムの実装

クラスの配列を使用して、ソートや検索アルゴリズムを実装することも可能です。

以下の例では、Personクラスを定義し、名前でソートするアルゴリズムを実装しています。

#include <iostream>
#include <string>
#include <algorithm> // std::sortを使用するために必要
class Person {
public:
    std::string name;
    int age;
    Person(std::string n, int a) : name(n), age(a) {}
};
bool compareByName(const Person& a, const Person& b) {
    return a.name < b.name; // 名前で比較
}
int main() {
    Person people[3] = {
        Person("佐藤次郎", 22),
        Person("山田太郎", 25),
        Person("鈴木花子", 30)
    };
    std::sort(people, people + 3, compareByName); // 名前でソート
    for (const auto& person : people) {
        std::cout << person.name << "は" << person.age << "歳です。" << std::endl;
    }
    return 0;
}

鈴木花子は30歳です。
山田太郎は25歳です。
佐藤次郎は22歳です。

このコードでは、std::sortを使用してPerson型の配列を名前でソートし、結果を表示しています。

クラスの配列を使うことで、データの管理や操作が効率的に行えます。

まとめ

この記事では、C++におけるクラスの配列の作成方法やアクセス方法、動的メモリ管理、コンストラクタとデストラクタの動作、さらにはクラスの配列を使ったさまざまな応用例について詳しく解説しました。

クラスの配列を利用することで、オブジェクトの管理やデータの操作が効率的に行えることがわかります。

これを機に、実際のプログラミングにおいてクラスの配列を活用し、より複雑なデータ構造やアルゴリズムの実装に挑戦してみてください。