MENU
  1. ホーム
  2. C++
  3. C++の型推論と標準ライブラリ（STL）の効果的な活用方法

C++の型推論と標準ライブラリ（STL）の効果的な活用方法

C++

C++は、高いパフォーマンスと柔軟性を兼ね備えたプログラミング言語として広く知られています。その中でも、型推論と標準ライブラリ（STL）の効果的な活用は、開発効率を大幅に向上させる重要な技術です。本記事では、C++の型推論の基本概念から応用までを詳しく解説し、STLとの組み合わせによる具体的なコード例を通して、実際の開発に役立つ知識を提供します。特に、C++11以降に導入された新しい機能や、STLのコンテナやアルゴリズムの効果的な使用方法についても触れ、プログラムの品質向上と開発効率の最適化を目指します。

目次

型推論とは何か

C++の型推論（type inference）は、プログラマが明示的に型を指定する必要がなく、コンパイラが文脈から変数の型を自動的に推測する機能です。この機能により、コードの可読性が向上し、開発効率が上がります。特に、複雑な型やテンプレートを扱う際に非常に便利です。

型推論の利点

型推論の主な利点は以下の通りです：

コードの簡潔さ

型推論を用いることで、冗長な型宣言を省略でき、コードが簡潔になります。

メンテナンスの容易さ

型を明示する必要がないため、コードのメンテナンスが容易になります。特に、コードの修正時に型宣言を変更する手間が省けます。

エラーの減少

コンパイラが型を推論することで、型に関するエラーを減少させることができます。特に、複雑なテンプレートを使用する際に有効です。

autoキーワードの使用例

C++におけるautoキーワードは、変数の型を自動的に推論するために使用されます。これにより、コードの可読性が向上し、プログラムの冗長性が減少します。

基本的な使用例

autoキーワードを使用すると、変数の型を明示的に指定する必要がなくなります。以下に基本的な使用例を示します。

#include <iostream>
#include <vector>

int main() {
    // 通常の型宣言
    int a = 5;

    // autoを使用した型推論
    auto b = 10; // int型と推論される

    std::vector<int> vec = {1, 2, 3, 4, 5};

    // autoを使用したループ
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << std::endl;
    }

    return 0;
}

関数の戻り値の型推論

autoキーワードは、関数の戻り値の型推論にも使用できます。以下の例では、関数の戻り値の型が自動的に推論されます。

#include <iostream>

// 関数の戻り値をautoで推論
auto add(int a, int b) {
    return a + b; // 戻り値の型はintと推論される
}

int main() {
    auto result = add(5, 3);
    std::cout << "Result: " << result << std::endl; // Output: Result: 8

    return 0;
}

コンテナとアルゴリズムでの使用

STLのコンテナやアルゴリズムと組み合わせることで、autoキーワードは特に便利です。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {5, 3, 9, 1, 7};

    // autoを使用してイテレータの型を推論
    auto it = std::find(numbers.begin(), numbers.end(), 9);

    if (it != numbers.end()) {
        std::cout << "Found number: " << *it << std::endl;
    } else {
        std::cout << "Number not found" << std::endl;
    }

    return 0;
}

decltypeキーワードの活用方法

decltypeキーワードは、式の型を推論するために使用されます。これにより、変数の型を式の結果から動的に決定することができます。特に、関数の戻り値の型推論やテンプレートメタプログラミングで有効です。

基本的な使用例

decltypeを使うと、任意の式の型を取得できます。以下に基本的な使用例を示します。

#include <iostream>

int main() {
    int x = 5;
    decltype(x) y = 10; // yの型はintと推論される

    std::cout << "x: " << x << ", y: " << y << std::endl; // Output: x: 5, y: 10
    return 0;
}

関数の戻り値の型推論

decltypeは、関数の戻り値の型を推論する際にも有用です。以下の例では、decltypeを使用して関数の戻り値の型を決定しています。

#include <iostream>

int add(int a, int b) {
    return a + b;
}

auto addWithDecltype(int a, int b) -> decltype(a + b) {
    return a + b;
}

int main() {
    int result1 = add(5, 3);
    auto result2 = addWithDecltype(5, 3);

    std::cout << "Result1: " << result1 << std::endl; // Output: Result1: 8
    std::cout << "Result2: " << result2 << std::endl; // Output: Result2: 8
    return 0;
}

テンプレートと`decltype`

テンプレートメタプログラミングにおいて、decltypeは特に強力です。以下の例では、テンプレート関数の戻り値の型をdecltypeを使用して決定しています。

#include <iostream>
#include <vector>

template <typename T1, typename T2>
auto multiply(T1 a, T2 b) -> decltype(a * b) {
    return a * b;
}

int main() {
    int a = 5;
    double b = 3.5;
    auto result = multiply(a, b); // resultの型はdoubleと推論される

    std::cout << "Result: " << result << std::endl; // Output: Result: 17.5
    return 0;
}

C++11以降の型推論機能

C++11以降、多くの型推論機能が導入され、プログラムの簡潔性と可読性が大幅に向上しました。これらの機能は、複雑な型を扱う際に特に有効です。

autoキーワードの拡張

C++11以降、autoキーワードが導入され、変数の宣言時に型を自動的に推論できるようになりました。この機能により、コードがシンプルかつ直感的になります。

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // autoキーワードを使用してイテレータの型を推論
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

decltypeキーワード

decltypeキーワードは、式の型を推論するために使用されます。これにより、テンプレートや関数の戻り値の型を動的に決定できます。

#include <iostream>

int main() {
    int x = 0;
    decltype(x) y = 1; // yの型はxと同じint

    std::cout << "x: " << x << ", y: " << y << std::endl;
    return 0;
}

ラムダ式と型推論

C++11では、ラムダ式も導入され、型推論と組み合わせて強力な機能を提供します。ラムダ式内でのキャプチャ変数や戻り値の型も自動的に推論されます。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // autoを使用してラムダ式を定義
    auto print = [](int n) { std::cout << n << " "; };
    std::for_each(vec.begin(), vec.end(), print);

    std::cout << std::endl;
    return 0;
}

テンプレートの型推論

C++14以降、テンプレートの引数型も推論できるようになり、関数テンプレートの使用がさらに簡単になりました。

#include <iostream>

template <typename T1, typename T2>
auto add(T1 a, T2 b) -> decltype(a + b) {
    return a + b;
}

int main() {
    auto result = add(5, 3.2); // resultの型はdouble
    std::cout << "Result: " << result << std::endl; // Output: Result: 8.2
    return 0;
}

STLの基本的な使い方

標準テンプレートライブラリ（STL）は、C++プログラムの効率と生産性を向上させるための強力なツールです。STLには、多くのコンテナ、アルゴリズム、およびイテレータが含まれており、これらを使用することでコーディングが簡単になります。

STLコンテナの基本

STLコンテナは、データを格納するための標準化されたクラスです。主なコンテナには、vector、list、deque、set、mapなどがあります。これらのコンテナを使用することで、データ構造の管理が容易になります。

#include <vector>
#include <list>
#include <set>
#include <map>
#include <iostream>

int main() {
    // ベクター（動的配列）
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (auto v : vec) {
        std::cout << v << " ";
    }
    std::cout << std::endl;

    // リスト（双方向リスト）
    std::list<int> lst = {5, 4, 3, 2, 1};
    for (auto l : lst) {
        std::cout << l << " ";
    }
    std::cout << std::endl;

    // セット（重複のない集合）
    std::set<int> st = {3, 1, 4, 1, 5, 9, 2};
    for (auto s : st) {
        std::cout << s << " ";
    }
    std::cout << std::endl;

    // マップ（連想配列）
    std::map<std::string, int> mp = {{"one", 1}, {"two", 2}, {"three", 3}};
    for (auto m : mp) {
        std::cout << m.first << ": " << m.second << " ";
    }
    std::cout << std::endl;

    return 0;
}

STLアルゴリズムの基本

STLには、多数のアルゴリズムが用意されており、データの操作や計算を効率的に行うことができます。sort、find、accumulateなどのアルゴリズムを使用して、データのソート、検索、集計などを行うことができます。

#include <vector>
#include <algorithm>
#include <numeric>
#include <iostream>

int main() {
    std::vector<int> vec = {5, 3, 8, 6, 2};

    // ソート
    std::sort(vec.begin(), vec.end());
    for (auto v : vec) {
        std::cout << v << " ";
    }
    std::cout << std::endl;

    // 検索
    auto it = std::find(vec.begin(), vec.end(), 3);
    if (it != vec.end()) {
        std::cout << "Found: " << *it << std::endl;
    } else {
        std::cout << "Not Found" << std::endl;
    }

    // 集計
    int sum = std::accumulate(vec.begin(), vec.end(), 0);
    std::cout << "Sum: " << sum << std::endl;

    return 0;
}

コンテナとアルゴリズム

STLのコンテナとアルゴリズムは、データの管理と操作を効率化するための基本ツールです。それぞれのコンテナとアルゴリズムは、特定の用途に適しています。

主要なコンテナの使い方

STLの主要なコンテナには、vector、list、deque、set、mapがあります。これらのコンテナは、異なるデータ構造を提供し、特定の状況で最適なパフォーマンスを発揮します。

vector（ベクター）

vectorは動的配列であり、頻繁に使用されます。要素のランダムアクセスが高速で、末尾への追加と削除が効率的です。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    vec.push_back(6); // 末尾に要素を追加

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

    return 0;
}

list（リスト）

listは双方向連結リストで、頻繁に要素の挿入と削除が行われる場合に適しています。ランダムアクセスはvectorに比べて遅いですが、挿入と削除は高速です。

#include <list>
#include <iostream>

int main() {
    std::list<int> lst = {1, 2, 3, 4, 5};
    lst.push_back(6); // 末尾に要素を追加

    for (const auto& l : lst) {
        std::cout << l << " ";
    }
    std::cout << std::endl;

    return 0;
}

set（セット）

setは重複しない要素の集合を保持し、要素の検索、挿入、削除が効率的です。自動的にソートされます。

#include <set>
#include <iostream>

int main() {
    std::set<int> st = {1, 3, 5, 7, 9};
    st.insert(4); // 要素を追加

    for (const auto& s : st) {
        std::cout << s << " ";
    }
    std::cout << std::endl;

    return 0;
}

map（マップ）

mapはキーと値のペアを格納する連想配列で、キーによるデータの検索、挿入、削除が効率的です。

#include <map>
#include <iostream>

int main() {
    std::map<std::string, int> mp = {{"one", 1}, {"two", 2}, {"three", 3}};
    mp["four"] = 4; // 新しいキーと値のペアを追加

    for (const auto& m : mp) {
        std::cout << m.first << ": " << m.second << std::endl;
    }

    return 0;
}

主要なアルゴリズムの使い方

STLには多くのアルゴリズムが含まれており、sort、find、for_each、accumulateなどがよく使用されます。これらのアルゴリズムを使用することで、データの操作が簡単になります。

ソート（sort）

データを昇順または降順にソートします。

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};
    std::sort(vec.begin(), vec.end());

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

    return 0;
}

検索（find）

特定の要素を検索します。

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};
    auto it = std::find(vec.begin(), vec.end(), 9);

    if (it != vec.end()) {
        std::cout << "Found: " << *it << std::endl;
    } else {
        std::cout << "Not Found" << std::endl;
    }

    return 0;
}

集計（accumulate）

データの集計を行います。

#include <vector>
#include <numeric>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    int sum = std::accumulate(vec.begin(), vec.end(), 0);

    std::cout << "Sum: " << sum << std::endl; // Output: Sum: 15

    return 0;
}

イテレータの活用

イテレータは、STLコンテナを操作するための抽象化されたポインタです。これにより、コンテナの要素を効率的に巡回したり、操作したりすることが可能になります。イテレータは、範囲ベースのforループと組み合わせることで、コードの可読性と効率を向上させます。

イテレータの基本

イテレータは、コンテナの要素にアクセスするためのオブジェクトです。主なイテレータの種類には、入力イテレータ、出力イテレータ、前進イテレータ、双方向イテレータ、ランダムアクセスイテレータがあります。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::vector<int>::iterator it; // ベクターのイテレータを定義

    // イテレータを使用して要素にアクセス
    for (it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

範囲ベースのforループ

C++11以降、範囲ベースのforループが導入され、イテレータを使用したループ処理がさらに簡潔になりました。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 範囲ベースのforループを使用して要素にアクセス
    for (auto& v : vec) {
        std::cout << v << " ";
    }
    std::cout << std::endl;

    return 0;
}

イテレータによるコンテナ操作

イテレータを使用すると、コンテナ内の要素を簡単に操作できます。例えば、要素の挿入、削除、検索などが可能です。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // イテレータを使用して要素を挿入
    std::vector<int>::iterator it = vec.begin();
    vec.insert(it + 2, 10); // 3番目の要素の前に10を挿入

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

    // イテレータを使用して要素を削除
    it = vec.begin();
    vec.erase(it + 1); // 2番目の要素を削除

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

    return 0;
}

イテレータの種類と特性

イテレータにはいくつかの種類があり、それぞれ異なる特性と用途があります。

入力イテレータと出力イテレータ

入力イテレータは、読み取り専用のイテレータで、出力イテレータは、書き込み専用のイテレータです。

前進イテレータと双方向イテレータ

前進イテレータは、前方向にのみ移動できるイテレータで、双方向イテレータは、前後両方向に移動できます。

ランダムアクセスイテレータ

ランダムアクセスイテレータは、配列のように任意の位置に直接アクセスできるイテレータです。

#include <vector>
#include <iostream>
#include <iterator>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // ランダムアクセスイテレータを使用
    std::vector<int>::iterator it = vec.begin();
    std::advance(it, 3); // イテレータを3つ進める

    std::cout << "4th element: " << *it << std::endl; // Output: 4th element: 4

    return 0;
}

型推論とSTLの組み合わせ

C++の型推論機能と標準テンプレートライブラリ（STL）を組み合わせることで、コードの簡潔さと効率を大幅に向上させることができます。特に、autoとdecltypeを使用することで、STLのコンテナやアルゴリズムをより柔軟に扱うことができます。

autoキーワードとSTLコンテナ

autoキーワードを使用することで、STLコンテナの要素型を明示的に記述する必要がなくなり、コードが簡潔になります。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // autoキーワードを使用してイテレータの型を推論
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

decltypeとSTLアルゴリズム

decltypeキーワードを使用すると、STLアルゴリズムの戻り値の型を自動的に推論できます。これにより、より柔軟なコードを書くことが可能です。

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // decltypeを使用してfindの戻り値の型を推論
    decltype(vec.begin()) it = std::find(vec.begin(), vec.end(), 3);

    if (it != vec.end()) {
        std::cout << "Found: " << *it << std::endl;
    } else {
        std::cout << "Not Found" << std::endl;
    }

    return 0;
}

関数テンプレートと型推論

関数テンプレートと型推論を組み合わせることで、汎用的なコードを書くことができます。autoとdecltypeを活用することで、テンプレート関数の引数や戻り値の型を柔軟に推論できます。

#include <iostream>
#include <vector>
#include <numeric>

template <typename T>
auto sum(const T& container) -> decltype(*container.begin()) {
    return std::accumulate(container.begin(), container.end(), 0);
}

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    auto total = sum(vec);
    std::cout << "Sum: " << total << std::endl; // Output: Sum: 15

    return 0;
}

STLとラムダ式の組み合わせ

ラムダ式を使用すると、STLアルゴリズムにカスタム関数を簡単に渡すことができます。autoとラムダ式を組み合わせることで、さらに柔軟なコードを書くことができます。

#include <vector>
#include <algorithm>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // autoとラムダ式を組み合わせたソート
    std::sort(vec.begin(), vec.end(), [](auto a, auto b) { return a > b; });

    for (const auto& v : vec) {
        std::cout << v << " ";
    }
    std::cout << std::endl; // Output: 5 4 3 2 1

    return 0;
}

実際のコード例

ここでは、型推論とSTLを組み合わせた具体的なコード例をいくつか紹介します。これにより、型推論とSTLの効果的な活用方法を実感できるでしょう。

学生の成績管理プログラム

この例では、学生の成績を管理し、平均点を計算するプログラムを示します。型推論とSTLを使用して、コードを簡潔に保ちながら機能を実装します。

#include <iostream>
#include <vector>
#include <string>
#include <numeric>
#include <algorithm>

struct Student {
    std::string name;
    std::vector<int> scores;
};

int main() {
    std::vector<Student> students = {
        {"Alice", {85, 90, 78}},
        {"Bob", {80, 82, 88}},
        {"Charlie", {92, 85, 91}}
    };

    // 各学生の平均点を計算
    for (const auto& student : students) {
        auto total = std::accumulate(student.scores.begin(), student.scores.end(), 0);
        auto average = static_cast<double>(total) / student.scores.size();
        std::cout << student.name << "'s average score: " << average << std::endl;
    }

    return 0;
}

商品在庫管理プログラム

次の例では、商品の在庫を管理するプログラムを示します。std::mapを使用して商品とその在庫数を管理し、型推論を活用してコードを簡潔にします。

#include <iostream>
#include <map>
#include <string>

int main() {
    std::map<std::string, int> inventory = {
        {"Apple", 50},
        {"Banana", 30},
        {"Orange", 20}
    };

    // 在庫を表示
    for (const auto& item : inventory) {
        std::cout << item.first << ": " << item.second << std::endl;
    }

    // 在庫の更新
    inventory["Apple"] += 10;
    inventory["Banana"] -= 5;

    // 更新後の在庫を表示
    std::cout << "\nUpdated Inventory:\n";
    for (const auto& item : inventory) {
        std::cout << item.first << ": " << item.second << std::endl;
    }

    return 0;
}

数値データの統計計算プログラム

この例では、数値データのリストから平均値と中央値を計算するプログラムを示します。autoとSTLアルゴリズムを活用して、コードを効率的に書きます。

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int main() {
    std::vector<int> data = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};

    // 平均値の計算
    auto sum = std::accumulate(data.begin(), data.end(), 0);
    auto average = static_cast<double>(sum) / data.size();
    std::cout << "Average: " << average << std::endl;

    // 中央値の計算
    std::sort(data.begin(), data.end());
    auto median = (data.size() % 2 == 0) ?
        (data[data.size() / 2 - 1] + data[data.size() / 2]) / 2.0 :
        data[data.size() / 2];
    std::cout << "Median: " << median << std::endl;

    return 0;
}

これらの例から、型推論とSTLを組み合わせることで、コードがよりシンプルかつ効率的になることがわかります。

効果的なデバッグ方法

C++で型推論とSTLを使用する際、デバッグは非常に重要です。ここでは、デバッグを効率的に行うためのいくつかの方法を紹介します。

デバッグビルドの利用

デバッグビルドを利用すると、デバッグ情報が埋め込まれ、デバッガでコードをステップ実行したり、変数の値を確認したりすることが容易になります。デバッグビルドを有効にするために、コンパイラオプション-gを使用します。

g++ -g -o my_program my_program.cpp

GDB（GNU Debugger）の使用

GDBは、Linux環境で広く使用されるデバッガです。以下は、GDBの基本的な使用方法です。

gdb ./my_program

GDBでプログラムを実行し、ブレークポイントを設定する例：

(gdb) break main
(gdb) run
(gdb) next
(gdb) print variable_name
(gdb) continue

Visual Studioのデバッグ機能

Windows環境であれば、Visual Studioのデバッグ機能が強力です。ブレークポイントの設定、変数のウォッチ、ステップ実行など、直感的にデバッグを行うことができます。

型推論のデバッグ

型推論を使用する場合、型が自動的に決定されるため、意図しない型が推論されることがあります。これを防ぐために、decltypeを使用して型を明示的に確認することが有効です。

#include <iostream>
#include <typeinfo>

int main() {
    auto x = 10;
    std::cout << "Type of x: " << typeid(x).name() << std::endl; // 出力される型情報を確認

    return 0;
}

STLのデバッグ

STLのコンテナやアルゴリズムを使用する際のデバッグポイント：

イテレータの範囲チェック

イテレータが有効な範囲内にあることを常に確認します。範囲外のアクセスは未定義動作を引き起こします。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto it = vec.begin() + 10; // 範囲外アクセスの例

    if (it < vec.end()) {
        std::cout << *it << std::endl;
    } else {
        std::cout << "Iterator out of range" << std::endl;
    }

    return 0;
}

STLアルゴリズムの前提条件の確認

STLアルゴリズムには、前提条件がある場合があります。例えば、std::sortはランダムアクセスイテレータを必要とします。前提条件を満たさない場合、予期しない動作を引き起こします。

#include <list>
#include <algorithm>

int main() {
    std::list<int> lst = {5, 2, 9, 1, 5, 6};

    // std::sortはlistには適用できない（コンパイルエラー）
    // std::sort(lst.begin(), lst.end());

    return 0;
}

ロギングの活用

デバッグのために、ロギングを活用することも有効です。特に大規模なプロジェクトでは、重要な変数の値や処理の流れをログに記録することで、問題の特定が容易になります。

#include <iostream>

#define LOG(x) std::cout << x << std::endl

int main() {
    int a = 5;
    LOG("Value of a: " << a);

    return 0;
}

まとめ

本記事では、C++の型推論と標準ライブラリ（STL）の効果的な活用方法について解説しました。型推論を使用することで、コードの可読性と開発効率を大幅に向上させることができます。また、STLを利用することで、強力で効率的なデータ構造とアルゴリズムを簡単に利用できるようになります。

特に、autoとdecltypeを活用することで、コードの冗長性を減らし、可読性を向上させることができました。STLのコンテナとアルゴリズムを組み合わせることで、日常的なプログラミング作業を効率化できることを実感できたでしょう。

さらに、デバッグ方法についても触れ、型推論とSTLを使用する際のポイントを紹介しました。デバッグビルドやGDB、Visual Studioのデバッグ機能、ロギングなどを駆使して、効果的にバグを検出し修正する方法を学びました。

型推論とSTLの活用により、C++プログラミングがより強力で効率的になることを願っています。これからも、さらなるスキルアップを目指して、積極的にこれらの技術を活用してください。

C++
型推論 C++ STL

コメント

コメントする

目次