MENU
  1. ホーム
  2. C++
  3. 基礎構文
  4. クラス
  5. [C++] 既存のクラスに新しいメンバ関数を追加する方法

[C++] 既存のクラスに新しいメンバ関数を追加する方法

C++で既存のクラスに新しいメンバ関数を追加するには、クラス定義を修正して新しい関数を宣言し、その実装を提供します。

クラス定義内で関数を宣言し、クラス外で定義することも可能です。

例えば、クラス内でvoid newFunction();と宣言し、クラス外でvoid ClassName::newFunction() {}と実装します。

既存のクラスを変更できない場合は、継承を使って派生クラスに新しいメンバ関数を追加することもできます。

この記事でわかること
  • 既存クラスにメンバ関数を追加する方法
  • 継承を利用した機能の拡張
  • 名前空間を使ったクラスの整理
  • 動的にメンバ関数を追加する手法
  • 標準ライブラリの拡張方法

目次から探す

既存のクラスにメンバ関数を追加する基本的な方法

クラス定義の修正

既存のクラスに新しいメンバ関数を追加するには、まずそのクラスの定義を修正する必要があります。

クラスの定義は通常、ヘッダファイルに記述されています。

以下の例では、MyClassというクラスにnewFunctionというメンバ関数を追加します。

#include <iostream>
class MyClass {
public:
    void existingFunction() {
        std::cout << "既存の関数です。" << std::endl;
    }
    // 新しいメンバ関数を追加
    void newFunction() {
        std::cout << "新しい関数です。" << std::endl;
    }
};
int main() {
    MyClass obj;
    obj.existingFunction();
    obj.newFunction(); // 新しい関数を呼び出す
    return 0;
}
既存の関数です。
新しい関数です。

クラス内でのメンバ関数の宣言

メンバ関数を追加する際は、クラス内でその関数を宣言します。

宣言はpublic、protected、privateのいずれかのアクセス修飾子の下に行います。

これにより、関数のアクセスレベルを制御できます。

クラス外でのメンバ関数の定義

メンバ関数の定義は、クラスの外で行うことができます。

クラス名とスコープ解決演算子::を使用して、関数を定義します。

以下の例では、newFunctionの定義をクラス外で行っています。

#include <iostream>
class MyClass {
public:
    void existingFunction();
    void newFunction(); // 宣言
};
// クラス外での定義
void MyClass::existingFunction() {
    std::cout << "既存の関数です。" << std::endl;
}
void MyClass::newFunction() {
    std::cout << "新しい関数です。" << std::endl;
}
int main() {
    MyClass obj;
    obj.existingFunction();
    obj.newFunction(); // 新しい関数を呼び出す
    return 0;
}
既存の関数です。
新しい関数です。

メンバ関数のアクセス修飾子

メンバ関数には、public、protected、privateのアクセス修飾子を設定できます。

これにより、関数の可視性を制御し、クラスの外部からのアクセスを制限できます。

以下の表に、各修飾子の特徴を示します。

スクロールできます
アクセス修飾子説明
publicクラスの外部からもアクセス可能
protected派生クラスからアクセス可能
privateクラスの内部からのみアクセス可能

コンストラクタやデストラクタとの関係

新しいメンバ関数を追加する際、コンストラクタやデストラクタとの関係も考慮する必要があります。

特に、リソースの管理や初期化が必要な場合、これらの関数を適切に定義することが重要です。

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

#include <iostream>
class MyClass {
private:
    int value;
public:
    MyClass(int v) : value(v) {} // コンストラクタ
    ~MyClass() {} // デストラクタ
    void displayValue() {
        std::cout << "値: " << value << std::endl;
    }
};
int main() {
    MyClass obj(10);
    obj.displayValue(); // 値を表示
    return 0;
}
値: 10

このように、既存のクラスにメンバ関数を追加する際は、クラス定義の修正、メンバ関数の宣言と定義、アクセス修飾子、コンストラクタやデストラクタとの関係を考慮することが重要です。

クラス外でのメンバ関数の定義方法

クラス名とスコープ解決演算子の使用

クラス外でメンバ関数を定義する際は、クラス名とスコープ解決演算子::を使用します。

これにより、どのクラスに属する関数であるかを明示的に示すことができます。

以下の例では、MyClassのメンバ関数newFunctionをクラス外で定義しています。

#include <iostream>
class MyClass {
public:
    void existingFunction();
    void newFunction(); // 宣言
};
// クラス外での定義
void MyClass::existingFunction() {
    std::cout << "既存の関数です。" << std::endl;
}
void MyClass::newFunction() {
    std::cout << "新しい関数です。" << std::endl;
}
int main() {
    MyClass obj;
    obj.existingFunction();
    obj.newFunction(); // 新しい関数を呼び出す
    return 0;
}
既存の関数です。
新しい関数です。

インライン関数として定義する場合

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

インライン関数は、クラス内で定義することが一般的ですが、クラス外でもinlineキーワードを使用して定義することができます。

以下の例では、inlineを使ってinlineFunctionを定義しています。

#include <iostream>
class MyClass {
public:
    void existingFunction() {
        std::cout << "既存の関数です。" << std::endl;
    }
    // インライン関数の定義
    inline void inlineFunction() {
        std::cout << "インライン関数です。" << std::endl;
    }
};
int main() {
    MyClass obj;
    obj.existingFunction();
    obj.inlineFunction(); // インライン関数を呼び出す
    return 0;
}
既存の関数です。
インライン関数です。

ヘッダファイルと実装ファイルの分離

C++では、クラスの定義とメンバ関数の実装を別々のファイルに分けることが一般的です。

これにより、コードの可読性が向上し、コンパイル時間が短縮されます。

通常、クラスの定義はヘッダファイル.hまたは.hppに、メンバ関数の実装はソースファイル.cppに記述します。

以下の例では、MyClassの定義と実装を分けています。

#ifndef MYCLASS_H
#define MYCLASS_H
class MyClass {
public:
    void existingFunction();
    void newFunction(); // 宣言
};
#endif // MYCLASS_H
#include <iostream>
#include "MyClass.h"
void MyClass::existingFunction() {
    std::cout << "既存の関数です。" << std::endl;
}
void MyClass::newFunction() {
    std::cout << "新しい関数です。" << std::endl;
}
#include <iostream>
#include "MyClass.h"
int main() {
    MyClass obj;
    obj.existingFunction();
    obj.newFunction(); // 新しい関数を呼び出す
    return 0;
}
既存の関数です。
新しい関数です。

このように、クラス外でのメンバ関数の定義方法には、スコープ解決演算子の使用、インライン関数の定義、ヘッダファイルと実装ファイルの分離が含まれます。

これらの手法を使うことで、コードの構造を整理し、可読性を向上させることができます。

継承を使ったメンバ関数の追加

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

C++の継承は、基本クラス(親クラス)から派生クラス(子クラス)が特性や機能を引き継ぐ仕組みです。

派生クラスは基本クラスのメンバ関数やメンバ変数を利用できるため、コードの再利用が可能になります。

以下の例では、BaseClassが基本クラスで、DerivedClassがその派生クラスです。

#include <iostream>
class BaseClass {
public:
    void baseFunction() {
        std::cout << "基本クラスの関数です。" << std::endl;
    }
};
class DerivedClass : public BaseClass {
    // 派生クラスは基本クラスのメンバを利用できる
};
int main() {
    DerivedClass obj;
    obj.baseFunction(); // 基本クラスの関数を呼び出す
    return 0;
}
基本クラスの関数です。

派生クラスでの新しいメンバ関数の追加

派生クラスでは、基本クラスから継承したメンバ関数に加えて、新しいメンバ関数を追加することができます。

以下の例では、DerivedClassにderivedFunctionという新しいメンバ関数を追加しています。

#include <iostream>
class BaseClass {
public:
    void baseFunction() {
        std::cout << "基本クラスの関数です。" << std::endl;
    }
};
class DerivedClass : public BaseClass {
public:
    void derivedFunction() {
        std::cout << "派生クラスの関数です。" << std::endl;
    }
};
int main() {
    DerivedClass obj;
    obj.baseFunction();      // 基本クラスの関数を呼び出す
    obj.derivedFunction();    // 新しい関数を呼び出す
    return 0;
}
基本クラスの関数です。
派生クラスの関数です。

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

オーバーライドとオーバーロードは、C++における関数の多様性を提供する2つの異なる概念です。

オーバーライドは、派生クラスが基本クラスのメンバ関数を再定義することを指し、オーバーロードは同じ名前の関数を異なる引数リストで定義することを指します。

以下の表に、両者の違いを示します。

スクロールできます
特徴オーバーライドオーバーロード
定義基本クラスの関数を再定義同名の関数を異なる引数で定義
使用目的ポリモーフィズムを実現するため同じ機能を異なる方法で提供するため
引数の数・型同じでなければならない異なる引数の数や型を持つことができる

仮想関数とポリモーフィズムの活用

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

これにより、ポリモーフィズムを実現し、同じインターフェースで異なる動作を持つオブジェクトを扱うことができます。

以下の例では、BaseClassに仮想関数virtualFunctionを定義し、DerivedClassでオーバーライドしています。

#include <iostream>
class BaseClass {
public:
    virtual void virtualFunction() { // 仮想関数
        std::cout << "基本クラスの仮想関数です。" << std::endl;
    }
};
class DerivedClass : public BaseClass {
public:
    void virtualFunction() override { // オーバーライド
        std::cout << "派生クラスの仮想関数です。" << std::endl;
    }
};
void callFunction(BaseClass* obj) {
    obj->virtualFunction(); // ポリモーフィズムを利用
}
int main() {
    BaseClass baseObj;
    DerivedClass derivedObj;
    callFunction(&baseObj);    // 基本クラスの関数を呼び出す
    callFunction(&derivedObj);  // 派生クラスの関数を呼び出す
    return 0;
}
基本クラスの仮想関数です。
派生クラスの仮想関数です。

このように、継承を使ったメンバ関数の追加は、基本クラスと派生クラスの関係を利用し、新しいメンバ関数を追加したり、オーバーライドやポリモーフィズムを活用することで、柔軟で再利用可能なコードを実現します。

テンプレートクラスにメンバ関数を追加する方法

テンプレートクラスの基本構造

C++のテンプレートクラスは、型に依存しないクラスを定義するための機能です。

これにより、異なるデータ型に対して同じクラスの機能を再利用できます。

テンプレートクラスは、templateキーワードを使用して定義されます。

以下の例では、MyTemplateClassというテンプレートクラスを定義しています。

#include <iostream>
template <typename T>
class MyTemplateClass {
private:
    T value; // テンプレート型のメンバ変数
public:
    MyTemplateClass(T v) : value(v) {} // コンストラクタ
    void displayValue() {
        std::cout << "値: " << value << std::endl;
    }
};
int main() {
    MyTemplateClass<int> intObj(10); // int型のインスタンス
    intObj.displayValue();
    MyTemplateClass<double> doubleObj(3.14); // double型のインスタンス
    doubleObj.displayValue();
    return 0;
}
値: 10
値: 3.14

テンプレートクラスに新しいメンバ関数を追加する手順

テンプレートクラスに新しいメンバ関数を追加する手順は、通常のクラスと同様です。

クラス内で関数を宣言し、必要に応じてクラス外で定義します。

以下の例では、MyTemplateClassにgetValueという新しいメンバ関数を追加しています。

#include <iostream>
template <typename T>
class MyTemplateClass {
private:
    T value; // テンプレート型のメンバ変数
public:
    MyTemplateClass(T v) : value(v) {} // コンストラクタ
    void displayValue() {
        std::cout << "値: " << value << std::endl;
    }
    // 新しいメンバ関数を追加
    T getValue() {
        return value;
    }
};
int main() {
    MyTemplateClass<int> intObj(10);
    std::cout << "取得した値: " << intObj.getValue() << std::endl; // 新しい関数を呼び出す
    return 0;
}
取得した値: 10

テンプレートクラスの特殊化とメンバ関数の追加

テンプレートクラスは、特定の型に対して異なる動作を持たせるために特殊化することができます。

特殊化を使用すると、特定の型に対して異なるメンバ関数を定義することが可能です。

以下の例では、MyTemplateClassをint型に対して特殊化し、displayValueメンバ関数を変更しています。

#include <iostream>
template <typename T>
class MyTemplateClass {
private:
    T value; // テンプレート型のメンバ変数
public:
    MyTemplateClass(T v) : value(v) {} // コンストラクタ
    void displayValue() {
        std::cout << "値: " << value << std::endl;
    }
};
// int型に対する特殊化
template <>
void MyTemplateClass<int>::displayValue() {
    std::cout << "整数型の値: " << value << std::endl; // 特殊化されたメンバ関数
}
int main() {
    MyTemplateClass<int> intObj(10);
    intObj.displayValue(); // 特殊化された関数を呼び出す
    MyTemplateClass<double> doubleObj(3.14);
    doubleObj.displayValue(); // 通常の関数を呼び出す
    return 0;
}
整数型の値: 10
値: 3.14

このように、テンプレートクラスにメンバ関数を追加する方法は、基本的なクラスと同様ですが、型に依存しない柔軟性を持っています。

また、特殊化を利用することで、特定の型に対して異なる動作を持たせることができます。

これにより、より汎用的で再利用可能なコードを実現できます。

名前空間とメンバ関数の追加

名前空間の役割

名前空間は、C++において識別子(変数名、関数名、クラス名など)の衝突を避けるための機能です。

特に大規模なプロジェクトやライブラリを開発する際に、異なるモジュールやライブラリで同じ名前の識別子が存在する場合、名前空間を使用することでそれらを区別できます。

以下の例では、MyNamespaceという名前空間を定義しています。

#include <iostream>
namespace MyNamespace {
    void displayMessage() {
        std::cout << "名前空間内のメッセージです。" << std::endl;
    }
}
int main() {
    MyNamespace::displayMessage(); // 名前空間を指定して関数を呼び出す
    return 0;
}
名前空間内のメッセージです。

名前空間内でのクラス定義とメンバ関数の追加

名前空間内でクラスを定義し、そのクラスにメンバ関数を追加することができます。

これにより、同じ名前のクラスが異なる名前空間に存在しても衝突を避けることができます。

以下の例では、MyNamespace内にMyClassというクラスを定義し、メンバ関数を追加しています。

#include <iostream>
namespace MyNamespace {
    class MyClass {
    public:
        void display() {
            std::cout << "MyClassのメンバ関数です。" << std::endl;
        }
    };
}
int main() {
    MyNamespace::MyClass obj; // 名前空間を指定してクラスのインスタンスを作成
    obj.display(); // メンバ関数を呼び出す
    return 0;
}
MyClassのメンバ関数です。

名前空間を使ったクラスの拡張

名前空間を使用することで、既存のクラスを拡張することも可能です。

新しいメンバ関数を追加する際に、同じ名前空間内で新しいクラスを定義することで、既存のクラスの機能を拡張できます。

以下の例では、MyNamespace内にMyClassを拡張したExtendedClassを定義しています。

#include <iostream>
namespace MyNamespace {
    class MyClass {
    public:
        void display() {
            std::cout << "MyClassのメンバ関数です。" << std::endl;
        }
    };
    class ExtendedClass : public MyClass { // MyClassを継承
    public:
        void extendedDisplay() {
            std::cout << "拡張クラスのメンバ関数です。" << std::endl;
        }
    };
}
int main() {
    MyNamespace::ExtendedClass obj; // 拡張クラスのインスタンスを作成
    obj.display(); // 基本クラスのメンバ関数を呼び出す
    obj.extendedDisplay(); // 拡張クラスのメンバ関数を呼び出す
    return 0;
}
MyClassのメンバ関数です。
拡張クラスのメンバ関数です。

このように、名前空間を利用することで、クラスの定義やメンバ関数の追加を行い、識別子の衝突を避けつつ、コードの整理や拡張が可能になります。

名前空間は、特に大規模なプロジェクトにおいて非常に有用な機能です。

応用例：既存のライブラリクラスにメンバ関数を追加する

標準ライブラリクラスにメンバ関数を追加する方法

C++の標準ライブラリクラスにメンバ関数を追加する場合、通常はクラスの継承を利用します。

標準ライブラリのクラスを直接変更することはできませんが、派生クラスを作成することで新しい機能を追加できます。

以下の例では、std::vectorを継承し、sumというメンバ関数を追加しています。

#include <iostream>
#include <vector>
template <typename T>
class MyVector : public std::vector<T> {
public:
    T sum() {
        T total = 0;
        for (const auto& value : *this) {
            total += value; // 各要素を加算
        }
        return total;
    }
};
int main() {
    MyVector<int> vec;
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    
    std::cout << "合計: " << vec.sum() << std::endl; // 新しいメンバ関数を呼び出す
    return 0;
}
合計: 6

サードパーティライブラリのクラスにメンバ関数を追加する方法

サードパーティライブラリのクラスにメンバ関数を追加する場合も、基本的には継承を利用します。

ライブラリのクラスを継承し、新しい機能を持つ派生クラスを作成します。

以下の例では、仮想のサードパーティライブラリのクラスThirdPartyClassを継承し、newFunctionを追加しています。

#include <iostream>
class ThirdPartyClass {
public:
    void existingFunction() {
        std::cout << "サードパーティクラスの既存の関数です。" << std::endl;
    }
};
class ExtendedThirdPartyClass : public ThirdPartyClass {
public:
    void newFunction() {
        std::cout << "拡張された関数です。" << std::endl;
    }
};
int main() {
    ExtendedThirdPartyClass obj;
    obj.existingFunction(); // 基本クラスの関数を呼び出す
    obj.newFunction();      // 新しい関数を呼び出す
    return 0;
}
サードパーティクラスの既存の関数です。
拡張された関数です。

クラスの拡張と互換性の維持

既存のクラスを拡張する際には、互換性を維持することが重要です。

特に、既存のコードが新しいクラスを使用する場合、元のインターフェースを変更しないように注意する必要があります。

以下のポイントに留意することで、互換性を維持しつつクラスを拡張できます。

  • オーバーロードを利用する: 新しいメンバ関数を追加する際、既存の関数名を保持しつつ、異なる引数リストで新しい関数を定義することで、既存のコードとの互換性を保つことができます。
  • 仮想関数を使用する: 基本クラスに仮想関数を定義し、派生クラスでオーバーライドすることで、ポリモーフィズムを利用しつつ、元のインターフェースを維持できます。
  • ドキュメントを更新する: 新しい機能や変更点を明確にドキュメント化し、他の開発者が理解しやすいようにすることが重要です。

このように、既存のライブラリクラスにメンバ関数を追加する際は、継承を利用し、互換性を維持するための工夫を行うことで、柔軟で再利用可能なコードを実現できます。

応用例：クラスのメンバ関数を動的に追加する

関数ポインタを使った動的なメンバ関数の追加

C++では、関数ポインタを使用してメンバ関数を動的に追加することができます。

関数ポインタを使うことで、特定の条件に応じて異なるメンバ関数を呼び出すことが可能です。

以下の例では、MyClassに関数ポインタを使ってメンバ関数を動的に追加しています。

#include <iostream>
class MyClass {
public:
    void functionA() {
        std::cout << "Function Aが呼び出されました。" << std::endl;
    }
    void functionB() {
        std::cout << "Function Bが呼び出されました。" << std::endl;
    }
};
int main() {
    MyClass obj;
    void (MyClass::*funcPtr)(); // メンバ関数ポインタの宣言
    // 条件に応じて関数ポインタを設定
    bool condition = true;
    if (condition) {
        funcPtr = &MyClass::functionA; // functionAを指す
    } else {
        funcPtr = &MyClass::functionB; // functionBを指す
    }
    // メンバ関数を呼び出す
    (obj.*funcPtr)(); // ポインタを使ってメンバ関数を呼び出す
    return 0;
}
Function Aが呼び出されました。

std::functionを使った柔軟なメンバ関数の追加

std::functionを使用することで、メンバ関数をより柔軟に扱うことができます。

std::functionは、任意の関数や関数オブジェクトを格納できるため、動的にメンバ関数を追加する際に便利です。

以下の例では、std::functionを使ってメンバ関数を動的に呼び出しています。

#include <iostream>
#include <functional>
class MyClass {
public:
    void functionA() {
        std::cout << "Function Aが呼び出されました。" << std::endl;
    }
    void functionB() {
        std::cout << "Function Bが呼び出されました。" << std::endl;
    }
};
int main() {
    MyClass obj;
    std::function<void()> func; // std::functionの宣言
    // 条件に応じて関数を設定
    bool condition = false;
    if (condition) {
        func = std::bind(&MyClass::functionA, &obj); // functionAを設定
    } else {
        func = std::bind(&MyClass::functionB, &obj); // functionBを設定
    }
    // メンバ関数を呼び出す
    func(); // std::functionを使ってメンバ関数を呼び出す
    return 0;
}
Function Bが呼び出されました。

ラムダ式を使ったメンバ関数の動的追加

C++11以降、ラムダ式を使用することで、メンバ関数を動的に追加することができます。

ラムダ式は、無名関数を簡潔に定義できるため、特定の条件に応じて異なる処理を行う際に非常に便利です。

以下の例では、ラムダ式を使ってメンバ関数を動的に呼び出しています。

#include <iostream>
#include <functional>
class MyClass {
public:
    void functionA() {
        std::cout << "Function Aが呼び出されました。" << std::endl;
    }
    void functionB() {
        std::cout << "Function Bが呼び出されました。" << std::endl;
    }
};
int main() {
    MyClass obj;
    std::function<void()> func; // std::functionの宣言
    // ラムダ式を使ってメンバ関数を設定
    bool condition = true;
    if (condition) {
        func = [&obj]() { obj.functionA(); }; // functionAを呼び出すラムダ式
    } else {
        func = [&obj]() { obj.functionB(); }; // functionBを呼び出すラムダ式
    }
    // メンバ関数を呼び出す
    func(); // ラムダ式を使ってメンバ関数を呼び出す
    return 0;
}
Function Aが呼び出されました。

このように、クラスのメンバ関数を動的に追加する方法には、関数ポインタ、std::function、ラムダ式を使用する方法があります。

これらの手法を活用することで、柔軟で再利用可能なコードを実現できます。

よくある質問

クラスを変更せずにメンバ関数を追加する方法はありますか？

クラスを変更せずにメンバ関数を追加する方法として、以下のアプローチがあります。

  • 継承を利用する: 基本クラスを継承し、派生クラスで新しいメンバ関数を定義することで、元のクラスを変更せずに機能を追加できます。
  • フレンド関数を使用する: フレンド関数を定義することで、クラスのプライベートメンバにアクセスしつつ、追加の機能を提供することができます。
  • 関数ポインタやstd::functionを利用する: 動的に関数を設定することで、特定の条件に応じた処理を行うことが可能です。

メンバ関数を追加するときに注意すべき点は何ですか？

メンバ関数を追加する際には、以下の点に注意することが重要です。

  • アクセス修飾子の設定: 新しいメンバ関数のアクセス修飾子public、protected、privateを適切に設定し、クラスの設計意図を明確にすることが重要です。
  • 既存のインターフェースとの整合性: 既存のメンバ関数との整合性を保ち、クラスの使用方法に混乱を招かないようにすることが大切です。
  • ドキュメントの更新: 新しいメンバ関数の追加に伴い、クラスのドキュメントを更新し、他の開発者が理解しやすいようにすることが重要です。

継承を使わずに既存クラスの機能を拡張する方法はありますか？

継承を使わずに既存クラスの機能を拡張する方法として、以下のアプローチがあります。

  • デコレータパターン: 既存のクラスをラップする新しいクラスを作成し、元のクラスの機能を拡張することができます。
  • コンポジション: 既存のクラスのインスタンスをメンバとして持つ新しいクラスを作成し、必要な機能を追加することができます。
  • フレンド関数: フレンド関数を使用して、既存クラスのプライベートメンバにアクセスし、追加の機能を提供することができます。

これらの方法を活用することで、継承を使わずに既存クラスの機能を拡張することが可能です。

まとめ

この記事では、C++におけるクラスのメンバ関数の追加方法について詳しく解説しました。

具体的には、既存のクラスに新しいメンバ関数を追加する基本的な方法や、継承を利用した拡張、さらにはテンプレートクラスや名前空間を活用した応用例についても触れました。

これらの知識を活かして、実際のプロジェクトにおいてクラスの機能を効果的に拡張し、より柔軟で再利用可能なコードを作成してみてください。

目次に戻る

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

C言語
C++
Python
HTML
Java
HTTP

関連カテゴリーから探す

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

関連記事

目次から探す