MENU
  1. ホーム
  2. C++
  3. 基礎構文
  4. クラス
  5. [C++] 実用的なクラスの書き方を初心者向けに紹介

[C++] 実用的なクラスの書き方を初心者向けに紹介

C++で実用的なクラスを書く際には、基本的な構造を理解することが重要です。

クラスはデータ(メンバ変数)とそのデータを操作する関数(メンバ関数)をまとめたものです。

まず、クラス名を定義し、メンバ変数やメンバ関数を public や private でアクセス制御します。

コンストラクタで初期化を行い、必要に応じてデストラクタでリソースの解放を行います。

メンバ関数はクラス外で定義することも可能です。

この記事でわかること
  • C++のクラスの基本構造と使い方
  • 継承とポリモーフィズムの概念
  • 演算子オーバーロードの実装方法
  • シングルトンやテンプレートの応用例
  • スマートポインタによるリソース管理

目次から探す

クラスとは何か？基本の理解

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

クラスを使うことで、プログラムの構造をより明確にし、再利用性を高めることができます。

クラスとオブジェクトの違い

  • クラス: オブジェクトの設計図やテンプレート。

データとメソッドを定義します。

  • オブジェクト: クラスから生成された実体。

クラスのインスタンスとも呼ばれます。

メンバ変数とメンバ関数の役割

スクロールできます
メンバ変数メンバ関数
クラス内で定義される変数。オブジェクトの状態を保持します。クラス内で定義される関数。オブジェクトの動作を定義します。

アクセス修飾子(public, private, protected)の使い方

  • public: 外部からアクセス可能。

クラスの外部からも利用できます。

  • private: クラス内からのみアクセス可能。

外部からは利用できません。

  • protected: 基底クラスと派生クラスからアクセス可能。

外部からは利用できません。

コンストラクタとデストラクタの基本

  • コンストラクタ: オブジェクトが生成される際に呼び出される特別なメソッド。

初期化処理を行います。

  • デストラクタ: オブジェクトが破棄される際に呼び出される特別なメソッド。

リソースの解放を行います。

インスタンス化の方法

クラスを使ってオブジェクトを生成することを「インスタンス化」と言います。

以下はその例です。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    MyClass(int v) { // コンストラクタ
        value = v;
    }
};
int main() {
    MyClass obj(10); // インスタンス化
    cout << "オブジェクトの値: " << obj.value << endl; // メンバ変数へのアクセス
    return 0;
}
オブジェクトの値: 10

この例では、MyClassというクラスを定義し、コンストラクタを使ってオブジェクトを生成しています。

インスタンス化により、objというオブジェクトが作成され、そのメンバ変数valueにアクセスしています。

実用的なクラスの基本構造

C++でクラスを作成する際の基本的な構造について解説します。

クラスの宣言、定義、メンバ変数の初期化、メンバ関数の実装、コンストラクタやデストラクタの使い方を理解することで、実用的なクラスを作成できるようになります。

クラスの宣言と定義

クラスは、classキーワードを使って宣言します。

クラスの宣言では、メンバ変数やメンバ関数のプロトタイプを定義します。

以下はクラスの宣言と定義の例です。

#include <iostream>
using namespace std;
class MyClass { // クラスの宣言
public:
    int value; // メンバ変数
    void display(); // メンバ関数のプロトタイプ
};
// メンバ関数の定義
void MyClass::display() {
    cout << "値: " << value << endl;
}
int main() {
    MyClass obj; // オブジェクトの生成
    obj.value = 5; // メンバ変数へのアクセス
    obj.display(); // メンバ関数の呼び出し
    return 0;
}
値: 5

メンバ変数の初期化

メンバ変数は、コンストラクタを使って初期化することが一般的です。

以下の例では、コンストラクタ内でメンバ変数を初期化しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    MyClass(int v) { // コンストラクタ
        value = v; // メンバ変数の初期化
    }
};
int main() {
    MyClass obj(10); // インスタンス化
    cout << "オブジェクトの値: " << obj.value << endl;
    return 0;
}
オブジェクトの値: 10

メンバ関数の定義と実装

メンバ関数は、クラス内で定義され、クラスのオブジェクトに対して操作を行います。

以下の例では、メンバ関数を使ってメンバ変数の値を変更しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    MyClass(int v) {
        value = v;
    }
    void setValue(int v) { // メンバ関数の定義
        value = v; // メンバ変数の更新
    }
};
int main() {
    MyClass obj(5);
    obj.setValue(20); // メンバ関数の呼び出し
    cout << "更新された値: " << obj.value << endl;
    return 0;
}
更新された値: 20

コンストラクタでの初期化リストの使い方

初期化リストを使うことで、メンバ変数をより効率的に初期化できます。

以下の例では、初期化リストを使用しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    MyClass(int v) : value(v) { // 初期化リスト
        // 追加の初期化処理があればここに記述
    }
};
int main() {
    MyClass obj(15); // インスタンス化
    cout << "オブジェクトの値: " << obj.value << endl;
    return 0;
}
オブジェクトの値: 15

デストラクタでのリソース管理

デストラクタは、オブジェクトが破棄される際に呼び出され、リソースの解放を行います。

以下の例では、デストラクタを使ってメモリを解放する方法を示します。

#include <iostream>
using namespace std;
class MyClass {
public:
    int* data;
    MyClass(int size) { // コンストラクタ
        data = new int[size]; // メモリの動的確保
    }
    ~MyClass() { // デストラクタ
        delete[] data; // メモリの解放
    }
};
int main() {
    MyClass obj(10); // インスタンス化
    // objがスコープを抜けるとデストラクタが呼ばれ、メモリが解放される
    return 0;
}

この例では、MyClassのデストラクタが呼ばれることで、動的に確保したメモリが解放されます。

これにより、メモリリークを防ぐことができます。

アクセス制御とカプセル化

C++におけるアクセス制御とカプセル化は、オブジェクト指向プログラミングの重要な概念です。

これにより、データの隠蔽と安全な操作が可能になります。

以下では、アクセス修飾子の使い分け、ゲッターとセッターの実装、カプセル化のメリット、フレンド関数とフレンドクラスの使い方について解説します。

public, private, protectedの使い分け

スクロールできます
アクセス修飾子説明
publicクラスの外部からアクセス可能。外部のコードから直接利用できます。
privateクラスの内部からのみアクセス可能。外部からは利用できず、データの隠蔽が可能です。
protected基底クラスと派生クラスからアクセス可能。外部からは利用できません。

ゲッターとセッターの実装

ゲッターとセッターは、クラスのメンバ変数に対するアクセスを制御するためのメソッドです。

以下の例では、ゲッターとセッターを使ってメンバ変数にアクセスしています。

#include <iostream>
using namespace std;
class MyClass {
private:
    int value; // privateメンバ変数
public:
    // ゲッター
    int getValue() {
        return value;
    }
    // セッター
    void setValue(int v) {
        value = v;
    }
};
int main() {
    MyClass obj;
    obj.setValue(10); // セッターを使って値を設定
    cout << "オブジェクトの値: " << obj.getValue() << endl; // ゲッターを使って値を取得
    return 0;
}
オブジェクトの値: 10

カプセル化のメリット

カプセル化には以下のようなメリットがあります。

  • データの隠蔽: 内部の実装を隠すことで、外部からの不正なアクセスを防ぎます。
  • 保守性の向上: 内部の実装を変更しても、外部のコードに影響を与えにくくなります。
  • データの整合性: セッターを通じてのみデータを変更できるため、無効な値の設定を防ぎます。

フレンド関数とフレンドクラスの使い方

フレンド関数やフレンドクラスを使うことで、特定の関数やクラスに対してプライベートメンバにアクセスを許可することができます。

以下の例では、フレンド関数を使ってプライベートメンバにアクセスしています。

#include <iostream>
using namespace std;
class MyClass {
private:
    int value;
public:
    MyClass(int v) : value(v) {}
    // フレンド関数の宣言
    friend void displayValue(MyClass obj);
};
// フレンド関数の定義
void displayValue(MyClass obj) {
    cout << "フレンド関数からの値: " << obj.value << endl; // プライベートメンバにアクセス
}
int main() {
    MyClass obj(30);
    displayValue(obj); // フレンド関数を呼び出し
    return 0;
}
フレンド関数からの値: 30

この例では、displayValueというフレンド関数がMyClassのプライベートメンバvalueにアクセスしています。

フレンド関数を使うことで、特定の関数に対してプライベートメンバへのアクセスを許可することができます。

コンストラクタとデストラクタの詳細

C++におけるコンストラクタとデストラクタは、オブジェクトの生成と破棄に関わる特別なメソッドです。

これらを正しく理解し、使いこなすことで、メモリ管理やリソース管理が効率的に行えます。

以下では、デフォルトコンストラクタ、引数付きコンストラクタ、コピーコンストラクタ、ムーブコンストラクタ、デストラクタ、コンストラクタのオーバーロードについて解説します。

デフォルトコンストラクタと引数付きコンストラクタ

  • デフォルトコンストラクタ: 引数を持たないコンストラクタで、オブジェクトが生成される際に自動的に呼び出されます。
  • 引数付きコンストラクタ: 引数を持つコンストラクタで、オブジェクトの初期化に必要な値を受け取ります。

以下の例では、デフォルトコンストラクタと引数付きコンストラクタを示しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    // デフォルトコンストラクタ
    MyClass() {
        value = 0; // 初期値を設定
    }
    // 引数付きコンストラクタ
    MyClass(int v) {
        value = v; // 引数で初期化
    }
};
int main() {
    MyClass obj1; // デフォルトコンストラクタを呼び出し
    MyClass obj2(10); // 引数付きコンストラクタを呼び出し
    cout << "obj1の値: " << obj1.value << endl; // 0
    cout << "obj2の値: " << obj2.value << endl; // 10
    return 0;
}
obj1の値: 0
obj2の値: 10

コピーコンストラクタの役割

コピーコンストラクタは、同じクラスの別のオブジェクトから新しいオブジェクトを生成するための特別なコンストラクタです。

デフォルトでは、メンバ変数の値をそのままコピーしますが、動的メモリを扱う場合は独自に実装する必要があります。

以下の例では、コピーコンストラクタを示しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int* data;
    // コンストラクタ
    MyClass(int size) {
        data = new int[size]; // メモリの動的確保
    }
    // コピーコンストラクタ
    MyClass(const MyClass& obj) {
        data = new int[10]; // 新しいメモリを確保
        for (int i = 0; i < 10; i++) {
            data[i] = obj.data[i]; // 値をコピー
        }
    }
    ~MyClass() { // デストラクタ
        delete[] data; // メモリの解放
    }
};
int main() {
    MyClass obj1(10); // オブジェクトの生成
    MyClass obj2 = obj1; // コピーコンストラクタを呼び出し
    return 0;
}

ムーブコンストラクタの使い方

ムーブコンストラクタは、リソースを他のオブジェクトから「ムーブ」するためのコンストラクタです。

これにより、リソースのコピーを避け、効率的なメモリ管理が可能になります。

以下の例では、ムーブコンストラクタを示しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int* data;
    // コンストラクタ
    MyClass(int size) {
        data = new int[size]; // メモリの動的確保
    }
    // ムーブコンストラクタ
    MyClass(MyClass&& obj) noexcept {
        data = obj.data; // リソースをムーブ
        obj.data = nullptr; // 元のオブジェクトのポインタを無効化
    }
    ~MyClass() { // デストラクタ
        delete[] data; // メモリの解放
    }
};
int main() {
    MyClass obj1(10); // オブジェクトの生成
    MyClass obj2 = std::move(obj1); // ムーブコンストラクタを呼び出し
    return 0;
}

デストラクタでのリソース解放

デストラクタは、オブジェクトが破棄される際に呼び出され、リソースの解放を行います。

動的に確保したメモリやファイルハンドルなどを解放するために使用されます。

以下の例では、デストラクタを使ってメモリを解放しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int* data;
    MyClass(int size) {
        data = new int[size]; // メモリの動的確保
    }
    ~MyClass() { // デストラクタ
        delete[] data; // メモリの解放
    }
};
int main() {
    MyClass obj(10); // オブジェクトの生成
    // objがスコープを抜けるとデストラクタが呼ばれ、メモリが解放される
    return 0;
}

コンストラクタのオーバーロード

コンストラクタのオーバーロードを使うことで、異なる引数の組み合わせに応じて複数のコンストラクタを定義できます。

これにより、オブジェクトの初期化を柔軟に行うことができます。

以下の例では、コンストラクタのオーバーロードを示しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    // デフォルトコンストラクタ
    MyClass() : value(0) {}
    // 引数付きコンストラクタ
    MyClass(int v) : value(v) {}
};
int main() {
    MyClass obj1; // デフォルトコンストラクタ
    MyClass obj2(20); // 引数付きコンストラクタ
    cout << "obj1の値: " << obj1.value << endl; // 0
    cout << "obj2の値: " << obj2.value << endl; // 20
    return 0;
}
obj1の値: 0
obj2の値: 20

このように、コンストラクタのオーバーロードを利用することで、異なる初期化方法を提供することができます。

メンバ関数の実装と使い方

C++におけるメンバ関数は、クラスのオブジェクトに対して操作を行うための関数です。

メンバ関数を正しく定義し、使いこなすことで、クラスの機能を効果的に活用できます。

以下では、メンバ関数の定義方法、constメンバ関数、オーバーロードされたメンバ関数、静的メンバ関数、インライン関数について解説します。

メンバ関数の定義方法

メンバ関数は、クラス内で定義され、クラスのオブジェクトに対して操作を行います。

以下の例では、メンバ関数を定義し、オブジェクトから呼び出しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    // メンバ関数の定義
    void setValue(int v) {
        value = v; // メンバ変数の更新
    }
    void display() {
        cout << "値: " << value << endl; // メンバ変数の表示
    }
};
int main() {
    MyClass obj; // オブジェクトの生成
    obj.setValue(10); // メンバ関数の呼び出し
    obj.display(); // メンバ関数の呼び出し
    return 0;
}
値: 10

constメンバ関数の使い方

constメンバ関数は、オブジェクトの状態を変更しないことを保証するために使用されます。

const修飾子を使うことで、メンバ関数がメンバ変数を変更しないことを示します。

以下の例では、constメンバ関数を示しています。

#include <iostream>
using namespace std;
class MyClass {
private:
    int value;
public:
    MyClass(int v) : value(v) {}
    // constメンバ関数
    int getValue() const {
        return value; // メンバ変数を変更しない
    }
};
int main() {
    MyClass obj(20);
    cout << "オブジェクトの値: " << obj.getValue() << endl; // constメンバ関数の呼び出し
    return 0;
}
オブジェクトの値: 20

オーバーロードされたメンバ関数

オーバーロードされたメンバ関数は、同じ名前で異なる引数の組み合わせを持つメンバ関数です。

これにより、同じ操作を異なる方法で実行できます。

以下の例では、オーバーロードされたメンバ関数を示しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    void display(int v) {
        cout << "整数: " << v << endl; // 整数を表示
    }
    void display(double v) {
        cout << "浮動小数点数: " << v << endl; // 浮動小数点数を表示
    }
};
int main() {
    MyClass obj;
    obj.display(10); // 整数のメンバ関数を呼び出し
    obj.display(3.14); // 浮動小数点数のメンバ関数を呼び出し
    return 0;
}
整数: 10
浮動小数点数: 3.14

静的メンバ関数の定義と使い方

静的メンバ関数は、クラスに属するが、特定のオブジェクトに依存しない関数です。

静的メンバ関数は、クラス名を使って呼び出すことができます。

以下の例では、静的メンバ関数を示しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    static int count; // 静的メンバ変数
    MyClass() {
        count++; // オブジェクトが生成されるたびにカウントを増やす
    }
    // 静的メンバ関数
    static void displayCount() {
        cout << "オブジェクトの数: " << count << endl; // 静的メンバ変数を表示
    }
};
// 静的メンバ変数の初期化
int MyClass::count = 0;
int main() {
    MyClass obj1; // オブジェクトの生成
    MyClass obj2; // オブジェクトの生成
    MyClass::displayCount(); // 静的メンバ関数の呼び出し
    return 0;
}
オブジェクトの数: 2

インライン関数の利点と注意点

インライン関数は、関数呼び出しのオーバーヘッドを削減するために使用される関数です。

関数の定義をクラス内に記述することで、コンパイラが関数の呼び出しを展開します。

以下の例では、インライン関数を示しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    // インライン関数
    inline int square(int x) {
        return x * x; // 引数の二乗を返す
    }
};
int main() {
    MyClass obj;
    cout << "5の二乗: " << obj.square(5) << endl; // インライン関数の呼び出し
    return 0;
}
5の二乗: 25

インライン関数の利点

  • パフォーマンス向上: 関数呼び出しのオーバーヘッドを削減できます。
  • コードの可読性: 短い関数をインラインで定義することで、コードがすっきりします。

注意点

  • コードサイズの増加: インライン関数が多くなると、バイナリサイズが大きくなる可能性があります。
  • コンパイラの判断: コンパイラはインライン化を強制することはできず、最適化のためにインライン化しない場合もあります。

演算子のオーバーロード

C++では、演算子オーバーロードを使用することで、ユーザー定義の型に対して演算子を再定義し、直感的に操作できるようにすることができます。

これにより、クラスのオブジェクトをより自然に扱うことが可能になります。

以下では、演算子オーバーロードの基本、二項演算子、単項演算子、入出力演算子のオーバーロード、注意点について解説します。

演算子オーバーロードの基本

演算子オーバーロードは、特定の演算子に対してクラスのメンバ関数またはフレンド関数を定義することで実現します。

演算子オーバーロードを行うことで、クラスのオブジェクトに対して演算子を使った操作が可能になります。

以下の例では、演算子オーバーロードの基本的な構文を示しています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    MyClass(int v) : value(v) {}
    // 演算子オーバーロード
    MyClass operator+(const MyClass& obj) {
        return MyClass(value + obj.value); // 新しいオブジェクトを返す
    }
};
int main() {
    MyClass obj1(10);
    MyClass obj2(20);
    MyClass obj3 = obj1 + obj2; // 演算子オーバーロードを使用
    cout << "obj3の値: " << obj3.value << endl; // 30
    return 0;
}
obj3の値: 30

二項演算子のオーバーロード

二項演算子は、2つのオペランドを取る演算子です。

演算子オーバーロードを使用して、二項演算子をクラスに対して定義できます。

以下の例では、加算演算子+をオーバーロードしています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    MyClass(int v) : value(v) {}
    // 加算演算子のオーバーロード
    MyClass operator+(const MyClass& obj) {
        return MyClass(value + obj.value);
    }
};
int main() {
    MyClass obj1(5);
    MyClass obj2(15);
    MyClass obj3 = obj1 + obj2; // 演算子オーバーロードを使用
    cout << "obj3の値: " << obj3.value << endl; // 20
    return 0;
}
obj3の値: 20

単項演算子のオーバーロード

単項演算子は、1つのオペランドを取る演算子です。

単項演算子も同様にオーバーロードすることができます。

以下の例では、単項演算子-をオーバーロードしています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    MyClass(int v) : value(v) {}
    // 単項演算子のオーバーロード
    MyClass operator-() {
        return MyClass(-value); // 値を反転
    }
};
int main() {
    MyClass obj(10);
    MyClass obj2 = -obj; // 単項演算子のオーバーロードを使用
    cout << "obj2の値: " << obj2.value << endl; // -10
    return 0;
}
obj2の値: -10

入出力演算子のオーバーロード

入出力演算子<<と>>をオーバーロードすることで、クラスのオブジェクトを簡単に入出力できるようになります。

これにより、オブジェクトの表示や入力が直感的になります。

以下の例では、入出力演算子をオーバーロードしています。

#include <iostream>
using namespace std;
class MyClass {
public:
    int value;
    MyClass(int v) : value(v) {}
    // 出力演算子のオーバーロード
    friend ostream& operator<<(ostream& os, const MyClass& obj) {
        os << "値: " << obj.value; // 出力形式を定義
        return os;
    }
    // 入力演算子のオーバーロード
    friend istream& operator>>(istream& is, MyClass& obj) {
        is >> obj.value; // 入力形式を定義
        return is;
    }
};
int main() {
    MyClass obj(0);
    cout << obj << endl; // 出力演算子の使用
    cout << "新しい値を入力してください: ";
    cin >> obj; // 入力演算子の使用
    cout << obj << endl; // 新しい値の出力
    return 0;
}
値: 0
新しい値を入力してください: 25
値: 25

演算子オーバーロードの注意点

演算子オーバーロードを行う際には、以下の点に注意する必要があります。

  • 直感的な意味: 演算子のオーバーロードは、直感的に理解できるように行うべきです。

例えば、加算演算子+は、2つのオブジェクトを加算する意味で使うべきです。

  • 副作用の回避: 演算子オーバーロードは、オブジェクトの状態を変更する場合があるため、副作用を避けるように注意が必要です。
  • オーバーロードできない演算子: 一部の演算子(例: ::, .*, .など)はオーバーロードできませんので、注意が必要です。
  • パフォーマンス: 演算子オーバーロードは便利ですが、過度に使用するとパフォーマンスに影響を与える可能性があります。

特に、コピーやムーブが発生する場合は注意が必要です。

これらの注意点を考慮しながら、演算子オーバーロードを適切に使用することで、クラスの使いやすさを向上させることができます。

継承とポリモーフィズム

C++における継承とポリモーフィズムは、オブジェクト指向プログラミングの重要な概念です。

これらを理解することで、コードの再利用性や柔軟性を高めることができます。

以下では、継承の基本、基底クラスと派生クラスの関係、仮想関数と純粋仮想関数、オーバーライドとオーバーロードの違い、ポリモーフィズムの実現方法について解説します。

継承の基本

継承は、既存のクラス(基底クラス)から新しいクラス(派生クラス)を作成する機能です。

派生クラスは基底クラスのメンバ変数やメンバ関数を引き継ぎ、追加の機能を持つことができます。

これにより、コードの再利用が可能になります。

以下の例では、継承の基本を示しています。

#include <iostream>
using namespace std;
// 基底クラス
class Animal {
public:
    void speak() {
        cout << "動物の声" << endl;
    }
};
// 派生クラス
class Dog : public Animal {
public:
    void bark() {
        cout << "ワンワン" << endl;
    }
};
int main() {
    Dog dog;
    dog.speak(); // 基底クラスのメンバ関数を呼び出し
    dog.bark();  // 派生クラスのメンバ関数を呼び出し
    return 0;
}
動物の声
ワンワン

基底クラスと派生クラスの関係

基底クラスは、共通の属性やメソッドを持つクラスであり、派生クラスはその基底クラスを拡張したクラスです。

派生クラスは基底クラスのメンバにアクセスでき、独自のメンバを追加することができます。

以下の例では、基底クラスと派生クラスの関係を示しています。

#include <iostream>
using namespace std;
// 基底クラス
class Shape {
public:
    virtual void draw() {
        cout << "図形を描く" << endl;
    }
};
// 派生クラス
class Circle : public Shape {
public:
    void draw() override { // オーバーライド
        cout << "円を描く" << endl;
    }
};
int main() {
    Shape* shape = new Circle(); // 基底クラスのポインタで派生クラスを指す
    shape->draw(); // ポリモーフィズムを利用
    delete shape; // メモリの解放
    return 0;
}
円を描く

仮想関数と純粋仮想関数

仮想関数は、基底クラスで定義され、派生クラスでオーバーライドされる関数です。

仮想関数を使用することで、ポリモーフィズムを実現できます。

純粋仮想関数は、基底クラスで宣言されるが、実装が提供されない関数で、派生クラスで必ずオーバーライドする必要があります。

以下の例では、仮想関数と純粋仮想関数を示しています。

#include <iostream>
using namespace std;
// 基底クラス
class Shape {
public:
    virtual void draw() = 0; // 純粋仮想関数
};
// 派生クラス
class Rectangle : public Shape {
public:
    void draw() override { // オーバーライド
        cout << "長方形を描く" << endl;
    }
};
int main() {
    Shape* shape = new Rectangle(); // 基底クラスのポインタで派生クラスを指す
    shape->draw(); // ポリモーフィズムを利用
    delete shape; // メモリの解放
    return 0;
}
長方形を描く

オーバーライドとオーバーロードの違い

  • オーバーライド: 基底クラスで定義された仮想関数を派生クラスで再定義すること。

ポリモーフィズムを実現するために使用されます。

  • オーバーロード: 同じ名前の関数を異なる引数の組み合わせで定義すること。

関数の呼び出し時に引数の型や数に基づいて適切な関数が選択されます。

以下の例では、オーバーライドとオーバーロードの違いを示しています。

#include <iostream>
using namespace std;
// 基底クラス
class Base {
public:
    virtual void show() {
        cout << "Baseクラスのshow" << endl;
    }
    void display(int x) { // オーバーロード
        cout << "Baseクラスのdisplay: " << x << endl;
    }
};
// 派生クラス
class Derived : public Base {
public:
    void show() override { // オーバーライド
        cout << "Derivedクラスのshow" << endl;
    }
    void display(double x) { // オーバーロード
        cout << "Derivedクラスのdisplay: " << x << endl;
    }
};
int main() {
    Base* b = new Derived();
    b->show(); // オーバーライドされた関数が呼ばれる
    b->display(10); // Baseクラスのdisplayが呼ばれる
    delete b; // メモリの解放
    return 0;
}
Derivedクラスのshow
Baseクラスのdisplay: 10

ポリモーフィズムの実現方法

ポリモーフィズムは、同じインターフェースを持つ異なるクラスのオブジェクトを同一の方法で扱うことを可能にします。

ポリモーフィズムを実現するためには、仮想関数を使用します。

以下の例では、ポリモーフィズムを実現する方法を示しています。

#include <iostream>
using namespace std;
// 基底クラス
class Animal {
public:
    virtual void sound() {
        cout << "動物の声" << endl;
    }
};
// 派生クラス
class Cat : public Animal {
public:
    void sound() override {
        cout << "ニャー" << endl;
    }
};
class Dog : public Animal {
public:
    void sound() override {
        cout << "ワンワン" << endl;
    }
};
int main() {
    Animal* animals[2]; // 基底クラスのポインタ配列
    animals[0] = new Cat(); // Catオブジェクト
    animals[1] = new Dog(); // Dogオブジェクト
    for (int i = 0; i < 2; i++) {
        animals[i]->sound(); // ポリモーフィズムを利用
    }
    // メモリの解放
    for (int i = 0; i < 2; i++) {
        delete animals[i];
    }
    return 0;
}
ニャー
ワンワン

このように、ポリモーフィズムを利用することで、異なるクラスのオブジェクトを同じインターフェースで扱うことができ、コードの柔軟性と再利用性が向上します。

クラスの応用例

C++のクラスは、さまざまなプログラミングのシナリオで応用できます。

以下では、シングルトンクラス、テンプレートクラス、スマートポインタ、デザインパターン、ファイル操作におけるクラスの実装例を紹介します。

シングルトンクラスの実装

シングルトンパターンは、クラスのインスタンスが1つだけであることを保証するデザインパターンです。

以下の例では、シングルトンクラスを実装しています。

#include <iostream>
using namespace std;
class Singleton {
private:
    static Singleton* instance; // インスタンスのポインタ
    // コンストラクタをプライベートにする
    Singleton() {}
public:
    // インスタンスを取得するための静的メソッド
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }
};
// インスタンスの初期化
Singleton* Singleton::instance = nullptr;
int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();
    if (s1 == s2) {
        cout << "同じインスタンスです。" << endl; // 同じインスタンスであることを確認
    }
    return 0;
}
同じインスタンスです。

テンプレートクラスの作成

テンプレートクラスは、異なるデータ型に対して同じクラスの機能を提供するための方法です。

以下の例では、テンプレートクラスを作成しています。

#include <iostream>
using namespace std;
template <typename T>
class MyArray {
private:
    T* arr;
    int size;
public:
    MyArray(int s) : size(s) {
        arr = new T[size]; // 動的配列の確保
    }
    void setValue(int index, T value) {
        if (index >= 0 && index < size) {
            arr[index] = value; // 値の設定
        }
    }
    T getValue(int index) {
        if (index >= 0 && index < size) {
            return arr[index]; // 値の取得
        }
        return T(); // デフォルト値を返す
    }
    ~MyArray() {
        delete[] arr; // メモリの解放
    }
};
int main() {
    MyArray<int> intArray(5); // int型の配列
    intArray.setValue(0, 10);
    cout << "intArray[0]: " << intArray.getValue(0) << endl;
    MyArray<double> doubleArray(5); // double型の配列
    doubleArray.setValue(0, 3.14);
    cout << "doubleArray[0]: " << doubleArray.getValue(0) << endl;
    return 0;
}
intArray[0]: 10
doubleArray[0]: 3.14

スマートポインタを使ったリソース管理

スマートポインタは、メモリ管理を自動化するためのクラスです。

C++11以降、std::unique_ptrやstd::shared_ptrが提供されています。

以下の例では、std::unique_ptrを使用しています。

#include <iostream>
#include <memory> // スマートポインタのヘッダ
using namespace std;
class MyClass {
public:
    MyClass() {
        cout << "MyClassのコンストラクタ" << endl;
    }
    ~MyClass() {
        cout << "MyClassのデストラクタ" << endl;
    }
};
int main() {
    {
        unique_ptr<MyClass> ptr(new MyClass()); // スマートポインタの使用
    } // スコープを抜けると自動的にメモリが解放される
    return 0;
}
MyClassのコンストラクタ
MyClassのデストラクタ

クラスを使ったデザインパターンの実装

デザインパターンは、特定の問題に対する一般的な解決策です。

以下の例では、ファクトリーパターンを使用してオブジェクトを生成するクラスを実装しています。

#include <iostream>
using namespace std;
// 基底クラス
class Shape {
public:
    virtual void draw() = 0; // 純粋仮想関数
};
// 派生クラス
class Circle : public Shape {
public:
    void draw() override {
        cout << "円を描く" << endl;
    }
};
class Square : public Shape {
public:
    void draw() override {
        cout << "正方形を描く" << endl;
    }
};
// ファクトリークラス
class ShapeFactory {
public:
    static Shape* createShape(const string& shapeType) {
        if (shapeType == "circle") {
            return new Circle();
        } else if (shapeType == "square") {
            return new Square();
        }
        return nullptr;
    }
};
int main() {
    Shape* shape1 = ShapeFactory::createShape("circle");
    shape1->draw(); // 円を描く
    Shape* shape2 = ShapeFactory::createShape("square");
    shape2->draw(); // 正方形を描く
    delete shape1; // メモリの解放
    delete shape2; // メモリの解放
    return 0;
}
円を描く
正方形を描く

クラスを使ったファイル操作の実装

C++のクラスを使用して、ファイルの読み書きを行うことができます。

以下の例では、テキストファイルにデータを書き込み、読み込むクラスを実装しています。

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
class FileHandler {
private:
    string filename;
public:
    FileHandler(const string& fname) : filename(fname) {}
    void writeToFile(const string& data) {
        ofstream outFile(filename); // 出力ファイルストリーム
        if (outFile.is_open()) {
            outFile << data; // データを書き込む
            outFile.close();
        } else {
            cout << "ファイルを開けませんでした。" << endl;
        }
    }
    void readFromFile() {
        ifstream inFile(filename); // 入力ファイルストリーム
        string line;
        if (inFile.is_open()) {
            while (getline(inFile, line)) {
                cout << line << endl; // データを読み込んで表示
            }
            inFile.close();
        } else {
            cout << "ファイルを開けませんでした。" << endl;
        }
    }
};
int main() {
    FileHandler fileHandler("example.txt");
    fileHandler.writeToFile("Hello, World!\nThis is a test file.");
    fileHandler.readFromFile(); // ファイルからデータを読み込む
    return 0;
}
Hello, World!
This is a test file.

このように、C++のクラスはさまざまな応用が可能であり、プログラムの構造を整理し、再利用性を高めるために非常に有用です。

よくある質問

クラスと構造体の違いは何ですか？

クラスと構造体は、どちらもユーザー定義のデータ型を作成するために使用されますが、いくつかの重要な違いがあります。

  • デフォルトのアクセス修飾子:
  • クラス: デフォルトでprivateです。

つまり、メンバ変数やメンバ関数は、明示的にpublicまたはprotectedと指定しない限り、外部からアクセスできません。

  • 構造体: デフォルトでpublicです。

メンバ変数やメンバ関数は、特に指定しない限り、外部からアクセス可能です。

  • 目的:
  • クラス: 主にオブジェクト指向プログラミングのために設計されており、データとその操作をカプセル化することを目的としています。
  • 構造体: 主にデータの集まりを表現するために使用され、シンプルなデータ構造を作成するために使われます。
  • 継承:
  • クラス: 継承をサポートし、ポリモーフィズムを実現できます。
  • 構造体: 継承はサポートされていませんが、C++では構造体もクラスと同様に継承を使用できます。

なぜゲッターとセッターを使うべきですか？

ゲッターとセッターは、クラスのメンバ変数へのアクセスを制御するためのメソッドです。

これらを使用する理由は以下の通りです。

  • カプセル化: ゲッターとセッターを使用することで、クラスの内部実装を隠蔽し、外部からの不正なアクセスを防ぐことができます。

これにより、データの整合性を保つことができます。

  • データの検証: セッターを使用することで、メンバ変数に設定される値を検証することができます。

無効な値が設定されるのを防ぎ、クラスの状態を常に有効に保つことができます。

  • 将来の変更に対応: クラスの内部実装が変更された場合でも、ゲッターとセッターを通じてアクセスすることで、外部のコードに影響を与えずに変更を行うことができます。

演算子オーバーロードはどのような場合に使うべきですか？

演算子オーバーロードは、ユーザー定義の型に対して演算子を再定義するための機能です。

以下のような場合に使用することが推奨されます。

  • 直感的な操作: クラスのオブジェクトに対して演算子を使った直感的な操作を可能にするために、演算子オーバーロードを使用します。

例えば、数値を表すクラスに対して加算演算子+をオーバーロードすることで、オブジェクト同士の加算を自然に行えるようにします。

  • コードの可読性向上: 演算子オーバーロードを使用することで、コードの可読性が向上します。

特に、数学的な操作や集合の操作を行うクラスでは、演算子をオーバーロードすることで、より明確な表現が可能になります。

  • 一貫性のあるインターフェース: 他の標準的なデータ型と同様のインターフェースを提供することで、クラスの使い方を一貫性のあるものにします。

これにより、他の開発者がクラスを理解しやすくなります。

ただし、演算子オーバーロードは慎重に行うべきであり、直感的でない使い方や副作用を伴う場合は避けるべきです。

まとめ

この記事では、C++のクラスに関する基本的な概念から応用例まで幅広く取り上げました。

クラスの定義やメンバ関数、演算子オーバーロード、継承とポリモーフィズム、さらにはシングルトンパターンやテンプレートクラスの実装方法について詳しく解説しました。

これらの知識を活用することで、より効率的で柔軟なプログラムを作成することが可能になります。

ぜひ、実際のプロジェクトや学習において、これらの概念を積極的に取り入れてみてください。

目次に戻る

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

C言語
C++
Python
HTML
Java
HTTP

関連カテゴリーから探す

クラス
  • URLをコピーしました！

関連記事

目次から探す