MENU
  1. ホーム
  2. C++
  3. C++メタプログラミングで実現する型安全なコンテナの実装方法

C++メタプログラミングで実現する型安全なコンテナの実装方法

C++

C++メタプログラミングを用いた型安全なコンテナの実装は、ソフトウェアの信頼性と安全性を向上させる重要な技術です。メタプログラミングは、コードの再利用性を高め、コンパイル時にエラーを検出することで、実行時のバグを減少させます。本記事では、型安全なコンテナの実装方法を具体的な例を交えながら解説し、C++の高度な技術を使いこなすための知識を提供します。

目次

メタプログラミングとは

メタプログラミングとは、プログラムが他のプログラムを生成、変換、または操作する技法のことです。C++では、テンプレートメタプログラミング（TMP）が広く使われており、コンパイル時にコードを生成することで、効率的かつ柔軟なプログラムを実現します。メタプログラミングを利用することで、型安全性を確保しながら複雑なロジックをコンパイル時にチェックすることが可能になります。

型安全なコンテナとは

型安全なコンテナとは、コンパイル時に格納される要素の型を厳密にチェックすることで、実行時の型エラーを防ぐデータ構造のことです。これにより、異なる型の要素が混在することなく、意図しない型変換やキャストによるバグを未然に防ぐことができます。型安全なコンテナは、C++の強力な型システムを活用し、プログラムの健全性と安全性を高めるために重要な役割を果たします。

テンプレートを用いた実装

C++におけるテンプレートは、型に依存しない汎用的なコードを記述するための強力な機能です。テンプレートを用いることで、型安全なコンテナを実装することができます。以下は、基本的なテンプレートを使用した型安全なコンテナの実装例です。

基本テンプレートの定義

まず、テンプレートを用いて、任意の型を受け取るコンテナを定義します。

template <typename T>
class SafeContainer {
private:
    std::vector<T> elements;
public:
    void add(const T& element) {
        elements.push_back(element);
    }

    T get(int index) const {
        return elements.at(index);
    }

    size_t size() const {
        return elements.size();
    }
};

この例では、SafeContainerクラスは任意の型Tを受け取り、その型の要素を格納するためのstd::vectorを内部に保持します。addメソッドで要素を追加し、getメソッドで要素を取得することができます。

テンプレートの利用例

次に、上記のテンプレートクラスを利用して型安全なコンテナを作成し、使用する例を示します。

SafeContainer<int> intContainer;
intContainer.add(10);
intContainer.add(20);
std::cout << intContainer.get(0) << std::endl; // 出力: 10
std::cout << intContainer.get(1) << std::endl; // 出力: 20

SafeContainer<std::string> stringContainer;
stringContainer.add("Hello");
stringContainer.add("World");
std::cout << stringContainer.get(0) << std::endl; // 出力: Hello
std::cout << stringContainer.get(1) << std::endl; // 出力: World

このように、テンプレートを使用することで、型安全なコンテナを簡単に実装し、利用することができます。テンプレートの力を借りることで、汎用性と型安全性を両立したコードを作成できます。

SFINAEとコンセプト

SFINAE（Substitution Failure Is Not An Error）とコンセプトは、C++メタプログラミングにおいて重要な技術です。これらを利用することで、より高度な型安全性と柔軟性を実現することができます。

SFINAEの基本概念

SFINAEは、テンプレートの特化を利用して型チェックを行う技術です。特定の条件を満たさないテンプレートはコンパイル時に無視されるため、意図しない型の誤使用を防ぎます。以下は、SFINAEを使用した例です。

#include <type_traits>

template <typename T>
typename std::enable_if<std::is_integral<T>::value, void>::type
printIntegral(T value) {
    std::cout << "Integral value: " << value << std::endl;
}

template <typename T>
typename std::enable_if<!std::is_integral<T>::value, void>::type
printIntegral(T value) {
    std::cout << "Non-integral value" << std::endl;
}

この例では、printIntegral関数が整数型の場合と非整数型の場合で異なる処理を行います。std::enable_ifとstd::is_integralを使って、型に応じた関数選択を行っています。

コンセプトの利用

C++20から導入されたコンセプトは、テンプレート引数の型制約を明示的に記述するための機能です。これにより、コードの可読性とエラーメッセージの明確性が向上します。以下は、コンセプトを使用した例です。

template <typename T>
concept Integral = std::is_integral_v<T>;

template <Integral T>
void printValue(T value) {
    std::cout << "Integral value: " << value << std::endl;
}

template <typename T>
void printValue(T value) requires (!Integral<T>) {
    std::cout << "Non-integral value" << std::endl;
}

この例では、Integralコンセプトを定義し、テンプレート関数printValueに適用しています。コンセプトを使うことで、SFINAEよりも簡潔で明確な型制約を記述できます。

SFINAEとコンセプトの利点

SFINAEとコンセプトを利用することで、次のような利点があります。

  1. 型安全性の向上: テンプレート引数の型を厳密に制約することで、意図しない型の使用を防止できます。
  2. コードの可読性向上: コンセプトを利用することで、コードの意図を明確に示すことができ、メンテナンス性が向上します。
  3. コンパイル時エラーの明確化: コンセプトを使用することで、エラーメッセージがより明確になり、デバッグが容易になります。

SFINAEとコンセプトを駆使することで、C++メタプログラミングの強力な機能を最大限に引き出し、型安全で柔軟なコードを実現できます。

コンパイル時の型チェック

コンパイル時の型チェックは、C++メタプログラミングにおける重要な技術であり、実行時エラーを防ぎ、プログラムの安全性を高めるために不可欠です。ここでは、型チェックを実現するための技法をいくつか紹介します。

型特性を利用したチェック

型特性（type traits）を使用することで、コンパイル時に型の特性を確認し、適切な処理を選択することができます。C++標準ライブラリには、多くの型特性が含まれており、これを活用することで、型安全なプログラムを構築できます。

#include <type_traits>
#include <iostream>

template <typename T>
void checkType(T value) {
    if constexpr (std::is_integral<T>::value) {
        std::cout << "Integral type" << std::endl;
    } else if constexpr (std::is_floating_point<T>::value) {
        std::cout << "Floating point type" << std::endl;
    } else {
        std::cout << "Other type" << std::endl;
    }
}

この例では、std::is_integralやstd::is_floating_pointなどの型特性を用いて、与えられた型が整数型か浮動小数点型かをコンパイル時にチェックし、適切なメッセージを表示します。

静的アサーション

静的アサーション（static_assert）は、コンパイル時に条件をチェックし、条件が満たされない場合にはコンパイルエラーを発生させる機能です。これにより、型に関する誤りを早期に検出することができます。

template <typename T>
void ensureIntegral() {
    static_assert(std::is_integral<T>::value, "T must be an integral type");
}

int main() {
    ensureIntegral<int>(); // 問題なし
    // ensureIntegral<double>(); // コンパイルエラー: T must be an integral type
}

この例では、static_assertを使用して、テンプレート引数Tが整数型であることをコンパイル時に保証しています。整数型でない場合にはコンパイルエラーが発生します。

コンセプトによる型制約

C++20で導入されたコンセプトを利用することで、テンプレート引数に対する型制約を明示的に記述できます。これにより、テンプレートの使用をより安全かつ直感的に行うことができます。

template <typename T>
concept Integral = std::is_integral_v<T>;

template <Integral T>
void processIntegral(T value) {
    std::cout << "Processing integral type: " << value << std::endl;
}

int main() {
    processIntegral(42); // 問題なし
    // processIntegral(3.14); // コンパイルエラー
}

この例では、Integralコンセプトを定義し、テンプレート関数processIntegralに適用しています。これにより、整数型以外の引数を渡すとコンパイルエラーが発生します。

コンパイル時型チェックの利点

コンパイル時に型チェックを行うことで、次のような利点があります。

  1. 早期エラーチェック: 実行前にエラーを検出できるため、バグの発見と修正が容易になります。
  2. 型安全性の向上: 型に関する誤りを未然に防ぐことで、プログラムの安全性と信頼性が向上します。
  3. パフォーマンスの向上: コンパイル時にチェックを行うことで、実行時のオーバーヘッドを削減し、パフォーマンスを向上させることができます。

これらの技術を活用することで、C++プログラムの型安全性を高め、信頼性の高いソフトウェアを構築することが可能になります。

カスタムアロケータの導入

カスタムアロケータを使用することで、メモリ管理を効率化し、パフォーマンスの向上や特定のメモリ管理要件に対応することができます。C++標準ライブラリでは、アロケータをテンプレート引数として受け取ることができるため、カスタムアロケータを容易に導入できます。

カスタムアロケータの基本構造

まず、カスタムアロケータの基本構造を示します。ここでは、メモリアロケーションとデアロケーションのカスタマイズ方法を紹介します。

#include <memory>
#include <iostream>

template <typename T>
class CustomAllocator {
public:
    using value_type = T;

    CustomAllocator() = default;

    template <typename U>
    CustomAllocator(const CustomAllocator<U>&) {}

    T* allocate(std::size_t n) {
        std::cout << "Allocating " << n << " element(s)" << std::endl;
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* p, std::size_t n) {
        std::cout << "Deallocating " << n << " element(s)" << std::endl;
        ::operator delete(p);
    }
};

template <typename T, typename U>
bool operator==(const CustomAllocator<T>&, const CustomAllocator<U>&) { return true; }

template <typename T, typename U>
bool operator!=(const CustomAllocator<T>&, const CustomAllocator<U>&) { return false; }

この例では、CustomAllocatorクラスは、allocateメソッドでメモリを割り当て、deallocateメソッドでメモリを解放します。アロケータは、テンプレートの特定の型に対してメモリ管理を行います。

カスタムアロケータの使用方法

次に、カスタムアロケータを使用して標準ライブラリのコンテナを作成する方法を示します。ここでは、std::vectorを例にとります。

#include <vector>

int main() {
    std::vector<int, CustomAllocator<int>> vec;
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);

    for (const auto& elem : vec) {
        std::cout << elem << std::endl;
    }

    return 0;
}

この例では、std::vectorにカスタムアロケータを指定することで、メモリアロケーションとデアロケーションのログが出力されます。カスタムアロケータを使用することで、特定のメモリ管理要件に応じた動作を実現できます。

カスタムアロケータの利点

カスタムアロケータを使用することで、次のような利点があります。

  1. メモリ管理の柔軟性: アプリケーションの特定のメモリ管理要件に応じたカスタムアロケータを設計することができます。
  2. パフォーマンスの向上: カスタムアロケータを使用することで、メモリアロケーションの効率を向上させ、パフォーマンスを最適化できます。
  3. デバッグとプロファイリング: メモリアロケーションとデアロケーションのログを取ることで、メモリ使用状況のデバッグとプロファイリングを容易に行うことができます。

カスタムアロケータを導入することで、C++プログラムのメモリ管理をより効率的かつ柔軟に行うことができ、特定のパフォーマンス要件やメモリ使用制約に対応することが可能になります。

実装例：型安全なベクトル

型安全なベクトルは、テンプレートを使用して汎用的なデータ構造を実現しつつ、格納する要素の型を厳密にチェックすることで、型安全性を保証します。ここでは、型安全なベクトルの実装例を示します。

型安全なベクトルの定義

まず、型安全なベクトルの基本的な定義を示します。以下の例では、テンプレートを使用して、任意の型の要素を格納できるベクトルクラスを実装します。

#include <iostream>
#include <vector>

template <typename T>
class SafeVector {
private:
    std::vector<T> data;
public:
    void add(const T& value) {
        data.push_back(value);
    }

    T get(size_t index) const {
        if (index >= data.size()) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }

    size_t size() const {
        return data.size();
    }

    void remove(size_t index) {
        if (index >= data.size()) {
            throw std::out_of_range("Index out of range");
        }
        data.erase(data.begin() + index);
    }
};

このクラスSafeVectorは、内部にstd::vectorを保持し、基本的な操作（要素の追加、取得、サイズの取得、削除）を提供します。インデックスの範囲外アクセスには例外を投げることで、安全性を確保しています。

型安全なベクトルの利用例

次に、型安全なベクトルの使用例を示します。以下のコードは、整数型と文字列型のベクトルを作成し、それぞれに要素を追加・取得・削除する例です。

int main() {
    // 整数型のSafeVectorの使用例
    SafeVector<int> intVector;
    intVector.add(10);
    intVector.add(20);
    intVector.add(30);

    std::cout << "Integer vector:" << std::endl;
    for (size_t i = 0; i < intVector.size(); ++i) {
        std::cout << intVector.get(i) << std::endl;
    }

    intVector.remove(1);
    std::cout << "After removal:" << std::endl;
    for (size_t i = 0; i < intVector.size(); ++i) {
        std::cout << intVector.get(i) << std::endl;
    }

    // 文字列型のSafeVectorの使用例
    SafeVector<std::string> stringVector;
    stringVector.add("Hello");
    stringVector.add("World");

    std::cout << "String vector:" << std::endl;
    for (size_t i = 0; i < stringVector.size(); ++i) {
        std::cout << stringVector.get(i) << std::endl;
    }

    return 0;
}

この例では、SafeVector<int>とSafeVector<std::string>を作成し、それぞれに整数と文字列を追加しています。また、要素の削除操作も行い、その結果を表示しています。

型安全なベクトルの利点

型安全なベクトルを使用することで、次のような利点があります。

  1. 型安全性の確保: テンプレートを使用して、格納する要素の型を厳密にチェックすることで、型安全性を確保します。
  2. 柔軟性の向上: 任意の型に対応する汎用的なデータ構造を実現し、さまざまな用途に対応できます。
  3. 安全なインデックス操作: インデックスの範囲外アクセスには例外を投げることで、実行時エラーを防ぎます。

このように、型安全なベクトルを実装することで、C++プログラムの安全性と柔軟性を向上させることができます。

実装例：型安全なリスト

型安全なリストは、テンプレートを使用して任意の型の要素を格納できるリンクリスト構造を実現します。ここでは、型安全なシングルリンクリストの実装例を示します。

型安全なリストの定義

まず、型安全なシングルリンクリストの基本的な定義を示します。以下の例では、テンプレートを使用して、任意の型の要素を格納できるリンクリストクラスを実装します。

#include <iostream>
#include <memory>

template <typename T>
class Node {
public:
    T data;
    std::shared_ptr<Node<T>> next;

    Node(const T& value) : data(value), next(nullptr) {}
};

template <typename T>
class SafeList {
private:
    std::shared_ptr<Node<T>> head;

public:
    SafeList() : head(nullptr) {}

    void add(const T& value) {
        std::shared_ptr<Node<T>> newNode = std::make_shared<Node<T>>(value);
        if (!head) {
            head = newNode;
        } else {
            std::shared_ptr<Node<T>> current = head;
            while (current->next) {
                current = current->next;
            }
            current->next = newNode;
        }
    }

    void remove(const T& value) {
        if (!head) return;

        if (head->data == value) {
            head = head->next;
            return;
        }

        std::shared_ptr<Node<T>> current = head;
        while (current->next && current->next->data != value) {
            current = current->next;
        }

        if (current->next) {
            current->next = current->next->next;
        }
    }

    bool contains(const T& value) const {
        std::shared_ptr<Node<T>> current = head;
        while (current) {
            if (current->data == value) {
                return true;
            }
            current = current->next;
        }
        return false;
    }

    void print() const {
        std::shared_ptr<Node<T>> current = head;
        while (current) {
            std::cout << current->data << " -> ";
            current = current->next;
        }
        std::cout << "nullptr" << std::endl;
    }
};

このクラスSafeListは、ノードを表すNodeクラスを内部に持ち、リストの要素を格納します。要素の追加、削除、検索、印刷の機能を提供します。

型安全なリストの利用例

次に、型安全なリストの使用例を示します。以下のコードは、整数型と文字列型のリストを作成し、それぞれに要素を追加・削除・検索する例です。

int main() {
    // 整数型のSafeListの使用例
    SafeList<int> intList;
    intList.add(1);
    intList.add(2);
    intList.add(3);

    std::cout << "Integer list:" << std::endl;
    intList.print();

    intList.remove(2);
    std::cout << "After removal:" << std::endl;
    intList.print();

    std::cout << "Contains 3: " << intList.contains(3) << std::endl;
    std::cout << "Contains 2: " << intList.contains(2) << std::endl;

    // 文字列型のSafeListの使用例
    SafeList<std::string> stringList;
    stringList.add("Hello");
    stringList.add("World");

    std::cout << "String list:" << std::endl;
    stringList.print();

    return 0;
}

この例では、SafeList<int>とSafeList<std::string>を作成し、それぞれに整数と文字列を追加しています。また、要素の削除操作や検索操作も行い、その結果を表示しています。

型安全なリストの利点

型安全なリストを使用することで、次のような利点があります。

  1. 型安全性の確保: テンプレートを使用して、格納する要素の型を厳密にチェックすることで、型安全性を確保します。
  2. 動的なサイズ変更: リンクリストの構造を使用することで、動的なサイズ変更が容易になります。
  3. メモリ効率の向上: リンクリストは必要なメモリだけを動的に割り当てるため、メモリ効率が向上します。

このように、型安全なリストを実装することで、C++プログラムの柔軟性と安全性を向上させることができます。

テストとデバッグ

型安全なコンテナを実装する際には、適切なテストとデバッグを行うことが不可欠です。ここでは、型安全なコンテナのテスト方法とデバッグのポイントについて解説します。

ユニットテストの重要性

ユニットテストは、個々の関数やクラスが期待通りに動作することを確認するためのテストです。型安全なコンテナにおいても、各メソッドが正しく動作することを検証するためにユニットテストを実施します。ここでは、Google Testフレームワークを用いたテストの例を示します。

Google Testを用いたユニットテスト

以下に、先に示した型安全なベクトルSafeVectorクラスに対するユニットテストの例を示します。

#include <gtest/gtest.h>
#include "SafeVector.h" // SafeVectorクラスの定義が含まれるヘッダファイル

TEST(SafeVectorTest, AddAndGetElement) {
    SafeVector<int> vec;
    vec.add(10);
    vec.add(20);
    EXPECT_EQ(vec.get(0), 10);
    EXPECT_EQ(vec.get(1), 20);
}

TEST(SafeVectorTest, RemoveElement) {
    SafeVector<int> vec;
    vec.add(10);
    vec.add(20);
    vec.add(30);
    vec.remove(1);
    EXPECT_EQ(vec.size(), 2);
    EXPECT_EQ(vec.get(1), 30);
}

TEST(SafeVectorTest, OutOfRange) {
    SafeVector<int> vec;
    vec.add(10);
    EXPECT_THROW(vec.get(1), std::out_of_range);
}

これらのテストは、Google Testフレームワークを使用してSafeVectorの各メソッドが正しく動作するかを検証しています。EXPECT_EQやEXPECT_THROWを用いることで、期待される結果を明示的に確認できます。

デバッグのポイント

型安全なコンテナのデバッグを行う際には、以下のポイントに注意します。

コンパイル時エラーの確認

型安全なコンテナはコンパイル時に型チェックを行うため、コンパイルエラーの内容が重要です。エラーメッセージを詳細に確認し、どの部分で型の不整合が発生しているかを特定します。

ランタイムエラーの追跡

ランタイムエラーが発生した場合には、デバッガを使用してエラーの原因を特定します。スタックトレースを確認し、どの関数呼び出しが問題を引き起こしているかを調査します。

テストケースの追加

新しい機能を追加するたびに、対応するテストケースを追加します。これにより、既存の機能が壊れていないことを確認できます。

ロギングとアサーションの活用

デバッグの際には、ロギングとアサーションを活用することも有効です。ロギングを使用して実行時の状況を記録し、アサーションを使用して前提条件が満たされていることを確認します。

#include <cassert>
#include <iostream>

void exampleFunction(int value) {
    assert(value >= 0 && "Value must be non-negative");
    std::cout << "Value: " << value << std::endl;
}

この例では、assertを使用してvalueが非負であることを確認しています。条件が満たされない場合には、プログラムが停止し、エラーメッセージが表示されます。

まとめ

適切なテストとデバッグを行うことで、型安全なコンテナの信頼性を確保し、実行時エラーを防ぐことができます。ユニットテストを活用し、コンパイル時およびランタイムエラーを適切に処理することで、堅牢なC++プログラムを実現しましょう。

応用例と演習問題

型安全なコンテナの実装に慣れたら、応用例を通じてさらなる理解を深めましょう。また、学習を促進するための演習問題も提供します。

応用例：型安全なマップ

型安全なマップ（連想配列）は、キーと値のペアを格納し、キーに基づいて値を効率的に検索するデータ構造です。ここでは、型安全なマップの簡単な実装例を示します。

#include <iostream>
#include <map>

template <typename Key, typename Value>
class SafeMap {
private:
    std::map<Key, Value> data;
public:
    void insert(const Key& key, const Value& value) {
        data[key] = value;
    }

    Value get(const Key& key) const {
        auto it = data.find(key);
        if (it != data.end()) {
            return it->second;
        }
        throw std::out_of_range("Key not found");
    }

    bool contains(const Key& key) const {
        return data.find(key) != data.end();
    }

    void remove(const Key& key) {
        data.erase(key);
    }
};

int main() {
    SafeMap<int, std::string> map;
    map.insert(1, "one");
    map.insert(2, "two");

    std::cout << "Key 1: " << map.get(1) << std::endl; // 出力: one
    std::cout << "Contains key 2: " << map.contains(2) << std::endl; // 出力: 1
    map.remove(1);

    return 0;
}

この例では、SafeMapクラスがstd::mapを内部に保持し、基本的な操作（挿入、取得、存在確認、削除）を提供します。

応用例：型安全なスタック

型安全なスタックは、LIFO（後入れ先出し）方式で要素を管理するデータ構造です。以下は、型安全なスタックの実装例です。

#include <iostream>
#include <vector>
#include <stdexcept>

template <typename T>
class SafeStack {
private:
    std::vector<T> data;
public:
    void push(const T& value) {
        data.push_back(value);
    }

    void pop() {
        if (data.empty()) {
            throw std::out_of_range("Stack is empty");
        }
        data.pop_back();
    }

    T top() const {
        if (data.empty()) {
            throw std::out_of_range("Stack is empty");
        }
        return data.back();
    }

    bool isEmpty() const {
        return data.empty();
    }
};

int main() {
    SafeStack<int> stack;
    stack.push(10);
    stack.push(20);

    std::cout << "Top: " << stack.top() << std::endl; // 出力: 20
    stack.pop();
    std::cout << "Top after pop: " << stack.top() << std::endl; // 出力: 10

    return 0;
}

この例では、SafeStackクラスがstd::vectorを内部に保持し、基本的なスタック操作（プッシュ、ポップ、トップ、空チェック）を提供します。

演習問題

以下の演習問題を解くことで、型安全なコンテナの理解を深めましょう。

  1. 型安全なキューの実装
    • 型安全なキュー（FIFO：先入れ先出し）をテンプレートを使って実装してください。基本的な操作（エンキュー、デキュー、フロント、空チェック）を提供するクラスを作成しましょう。
  2. カスタムアロケータを使ったコンテナ
    • 以前の例で示したカスタムアロケータを使用して、型安全なベクトルやリストを再実装してください。メモリアロケーションとデアロケーションのログを確認し、カスタムアロケータが正しく動作していることを確認してください。
  3. 複雑な型のサポート
    • 型安全なコンテナを使って、複雑な型（例えば、クラスや構造体）を格納する例を作成してください。必要に応じて、コンテナの操作をテストするためのユニットテストを作成してください。
  4. コンセプトを使った制約
    • C++20のコンセプトを使用して、型安全なコンテナに対して型制約を導入してください。例えば、整数型のみを許可するコンテナや、特定のインターフェースを実装するクラスのみを格納するコンテナを作成してください。

これらの演習問題に取り組むことで、型安全なコンテナの実装技術を実践的に学ぶことができます。各問題を解決し、テストとデバッグを行うことで、C++のメタプログラミングに対する理解を深めましょう。

まとめ

C++メタプログラミングを活用して型安全なコンテナを実装することは、プログラムの安全性と信頼性を大幅に向上させるための強力な手段です。本記事では、テンプレート、SFINAE、コンセプト、カスタムアロケータを駆使して、型安全なベクトルやリスト、スタック、マップといったコンテナの実装方法を紹介しました。

これらの技術を適切に組み合わせることで、型安全性を確保しつつ柔軟で効率的なデータ構造を作成できます。また、ユニットテストとデバッグを通じて、実装の正確性と安定性を検証することが重要です。

演習問題を解きながら実践的なスキルを身につけ、さらに高度なC++メタプログラミングの技術を習得しましょう。これにより、堅牢でメンテナンス性の高いソフトウェア開発を実現できるようになります。

C++
コンテナ メタプログラミング 型安全 C++

コメント

コメントする

目次