はい、承知いたしました。C++テンプレートについて、初心者向けに基本から応用、使い方、注意点まで詳細に解説した約5000語の記事を作成します。

C++ Templateとは？初心者向け基本と使い方を徹底解説

はじめに：なぜC++を学ぶのか、そして次なるステップへ

C++を学び始めた皆さん、プログラミングの世界へようこそ！ C++は非常に強力で、様々なアプリケーション開発に利用されています。ゲーム開発、OS、組み込みシステム、高性能サーバー、科学技術計算など、その応用範囲は広大です。

さて、C++の基本的な文法（変数、データ型、制御構造、関数、クラスなど）をマスターし、少しずつコードを書けるようになってきた頃、おそらくあなたは一つの疑問に直面するかもしれません。それは「同じような処理なのに、型が違うだけで毎回同じコードを書き直さなければならないのか？」という問題です。

例えば、二つの整数の最大値を求める関数を書いたとしましょう。

cpp int max_int(int a, int b) { return (a > b) ? a : b; }

これはうまく動きますね。しかし、今度は浮動小数点数の最大値を求めたいとします。

cpp double max_double(double a, double b) { return (a > b) ? a : b; }

さらに、文字列の場合はどうでしょう？（ここでは比較演算子が定義されていると仮定します）

cpp std::string max_string(const std::string& a, const std::string& b) { return (a > b) ? a : b; }

全く同じロジック（a > b なら a を返し、そうでなければ b を返す）なのに、型の数だけ関数を書き直さなければなりません。これは非常に面倒ですし、コードの重複はバグを生みやすく、保守も困難にします。

このような問題に対処し、「どんな型に対しても同じロジックで処理を行いたい」という要求に応えるためにC++に導入されたのが、テンプレート (Template) です。

テンプレートは、ジェネリックプログラミング（Generic Programming、汎用プログラミング）を実現するためのC++の強力な機能です。「ジェネリック」とは「汎用的な」「総称的な」といった意味です。つまり、特定の型に依存しない、汎用的なコードを書くことを可能にします。

この記事では、C++テンプレートの基本的な考え方から、関数テンプレート、クラステンプレートの使い方、その利点・欠点、そしてより高度なテクニックや標準ライブラリでの応用例までを、初心者の方にも分かりやすく丁寧に解説していきます。約5000語というボリュームで、テンプレートの全体像と、実際に使いこなすための知識を網羅することを目指します。

さあ、C++の強力な機能であるテンプレートの世界に踏み込んでいきましょう！

テンプレートがない世界の課題：なぜ汎用性が必要なのか？

テンプレートの便利さを理解するためには、まずテンプレートがない世界でどのような課題があったのかを知ることが重要です。前述のmax関数の例は、その最も単純な形です。

コードの重複と非効率性:
- 同じロジックを異なる型ごとに何度も書く必要があります。これは時間の無駄であり、開発効率を著しく低下させます。
- プログラムの規模が大きくなるにつれて、この問題は深刻になります。例えば、リスト、スタック、キューなどのデータ構造を考えた場合、それらを扱う要素の型がintなのかdoubleなのかstringなのかによって、全く同じロジックのコードを量産することになります。
保守性の低下:
- 同じロジックが複数箇所に散らばっていると、もしそのロジックにバグが見つかった場合、関連する全ての箇所を修正しなければなりません。修正漏れは新たなバグの温床となります。
- 機能改善や仕様変更があった場合も同様に、複数箇所の修正が必要です。
型安全性の問題（旧来の手法の場合）:
- C言語や古いC++では、異なる型のデータを扱うために、void*のような汎用ポインタを使うことがありました。例えば、void*を要素とするリストのようなものです。
- しかし、void*を使う場合、データを利用する際に元の型にキャストする必要があります。このキャストはコンパイラによる型チェックの対象外となるため、誤った型にキャストしてしまう危険性があります。これは型安全性 (Type Safety) を損ない、実行時エラーの原因となります。
- また、void*は通常、動的メモリ確保と組み合わせて使われることが多く、メモリ管理（解放忘れなど）の複雑さも増します。

これらの課題を根本的に解決し、より安全で効率的、かつ保守しやすいコードを書くために、C++テンプレートが誕生しました。テンプレートを使うことで、型に依存しない汎用的なアルゴリズムやデータ構造を一度だけ定義し、様々な型に対して安全に再利用できるようになります。

テンプレートの基本：汎用的なコードの書き方

テンプレートは、特定の型や値をプレースホルダー（仮置き）として定義し、実際のコードがコンパイルされる際にそのプレースホルダーが具体的な型や値に置き換えられる仕組みです。この置き換えのプロセスをテンプレートのインスタンス化 (Instantiation) と呼びます。

テンプレートには主に二つの種類があります。

関数テンプレート (Function Templates): 様々な型の引数に対して同じ処理を実行する汎用関数を定義します。
クラステンプレート (Class Templates): 様々な型のデータを格納・処理する汎用クラスを定義します。

関数テンプレートの基本

関数テンプレートは、関数の定義において、一つ以上の型や値をテンプレートパラメータとして指定することで作成します。基本的な構文は以下の通りです。

cpp template <typename T> return_type function_name(parameter_list) { // T を型として使用した処理 }

template <typename T>: これがテンプレート宣言です。templateキーワードに続き、山括弧< >の中にテンプレートパラメータを記述します。
typename T: テンプレートパラメータの一つです。typenameキーワードは、それに続くTが型名であることを示します。classキーワードも同じ目的で使用できます（例: template <class T>) が、typenameの方がより一般的です。
T: 関数本体や戻り値の型、引数の型リストで、テンプレートパラメータとして指定した型名を使用できます。

それでは、冒頭のmax関数を関数テンプレートとして書き直してみましょう。

“`cpp

include

// 関数テンプレートの定義
template
T max(T a, T b) {
return (a > b) ? a : b;
}

int main() {
// int 型でインスタンス化して呼び出し
int i1 = 5, i2 = 10;
std::cout << “Max of int: ” << max(i1, i2) << std::endl; // T は int と推論される

// double 型でインスタンス化して呼び出し
double d1 = 3.14, d2 = 2.71;
std::cout << "Max of double: " << max(d1, d2) << std::endl; // T は double と推論される

// string 型でインスタンス化して呼び出し
std::string s1 = "hello", s2 = "world";
std::cout << "Max of string: " << max(s1, s2) << std::endl; // T は std::string と推論される

// 異なる型での呼び出しはコンパイルエラー (通常)
// std::cout << max(i1, d1) << std::endl; // エラーになる可能性が高い (T を int にするか double にするか決められない)

return 0;

}
“`

このコードの重要な点は、max関数を一度だけ定義していることです。main関数内でmax関数を呼び出す際、コンパイラは渡された引数の型（int, double, std::string）を見て、自動的にテンプレートパラメータTをその型に置き換えた（インスタンス化した）関数を生成します。

max(i1, i2) の呼び出しでは、T は int に置き換えられ、int max(int a, int b) という関数が生成されます。
max(d1, d2) の呼び出しでは、T は double に置き換えられ、double max(double a, double b) という関数が生成されます。
max(s1, s2) の呼び出しでは、T は std::string に置き換えられ、std::string max(const std::string& a, const std::string& b) という関数が生成されます（実際には引数は値渡しなので std::string max(std::string a, std::string b) となりますが、ここでは比較のために参照にしました。値渡しの場合はコピーコストが発生します）。

この自動的にテンプレート引数を決定する仕組みをテンプレート引数推論 (Template Argument Deduction) と呼びます。多くの場合はこの推論に頼ることができます。

しかし、テンプレート引数推論がうまくいかない場合や、意図的に特定の型でインスタンス化したい場合は、明示的にテンプレート引数を指定することも可能です。

“`cpp
// 明示的なテンプレート引数の指定
std::cout << “Max of int (explicit): ” << max(i1, i2) << std::endl;
std::cout << “Max of double (explicit): ” << max(d1, d2) << std::endl;
std::cout << “Max of string (explicit): ” << max(s1, s2) << std::endl;

// 異なる型でも明示的に指定すれば可能だが、比較可能である必要がある
std::cout << “Max of int and double (explicit double): ” << max(i1, d1) << std::endl; // i1 (int) が double に変換されて比較される
“`

max<int>(i1, i2) のように、関数名の直後に< >で囲んでテンプレートパラメータを指定します。この場合、引数の型推論よりも明示的な指定が優先されます。

複数のテンプレート引数

関数テンプレートは、複数のテンプレートパラメータを持つことも可能です。

“`cpp
template
void print_pair(T1 first, T2 second) {
std::cout << “First: ” << first << “, Second: ” << second << std::endl;
}

int main() {
print_pair(10, 3.14); // T1=int, T2=double と推論
print_pair(“hello”, 100); // T1=const char*, T2=int と推論
print_pair(“world”, 200); // 明示的に指定
return 0;
}
“`

非型テンプレート引数 (Non-type Template Parameters)

テンプレートパラメータには、型だけでなく、コンパイル時に決定できる定数値を指定することもできます。これを非型テンプレート引数と呼びます。非型テンプレート引数として使用できるのは、整数型、列挙型、ポインタ型、参照型、std::nullptr_tなどです。浮動小数点数やクラスオブジェクトは非型テンプレート引数にはできません（C++20以降は一部のクラス型が可能になりましたが、ここでは基本に留めます）。

“`cpp
template
void print_array_size(T (&arr)[Size]) {
std::cout << “Array size is: ” << Size << std::endl;
for (int i = 0; i < Size; ++i) {
std::cout << arr[i] << (i == Size – 1 ? “” : “, “);
}
std::cout << std::endl;
}

int main() {
int my_int_array[] = {1, 2, 3, 4, 5};
print_array_size(my_int_array); // T=int, Size=5 と推論される

double my_double_array[] = {1.1, 2.2};
print_array_size(my_double_array); // T=double, Size=2 と推論される

// std::string my_string_array[] = {"a", "b", "c"};
// print_array_size(my_string_array); // T=std::string, Size=3 と推論される

return 0;

}
“`

この例では、配列を関数に渡すことで、配列のサイズを非型テンプレート引数Sizeとしてコンパイル時に取得しています。C++の普通の関数では、配列を引数として渡すと先頭要素へのポインタに劣化してしまうため、このような方法で配列サイズをコンパイル時に取得することはできません（実行時に別途サイズを渡す必要がある）。非型テンプレート引数は、このようにコンパイル時の情報を使ってコードを生成するのに役立ちます。

関数のオーバーロードとテンプレート

関数テンプレートは、通常の関数と同様にオーバーロードすることができます。また、非テンプレート関数や、異なるテンプレートパラメータを持つ関数テンプレート間でもオーバーロードの関係を構築できます。

コンパイラが関数呼び出しを解決する際、最も適切な関数（または関数テンプレートのインスタンス）を選択します。この選択ルールは少し複雑ですが、一般的には以下の優先順位で行われます。

完全に一致する非テンプレート関数
部分的に特殊化された関数テンプレート（後述）
一般的な関数テンプレート（引数推論によって最も一致するもの）

“`cpp
// (1) 非テンプレート関数
void print_value(int value) {
std::cout << “Non-template int: ” << value << std::endl;
}

// (2) 関数テンプレート
template
void print_value(T value) {
std::cout << “Template: ” << value << std::endl;
}

int main() {
print_value(10); // 非テンプレートの print_value(int) が呼ばれる (完全一致のため)
print_value(3.14); // 関数テンプレートがインスタンス化され、print_value(double) が呼ばれる
print_value(“hello”); // 関数テンプレートがインスタンス化され、print_value(const char*) が呼ばれる

// 明示的にテンプレートを指定することも可能
print_value<int>(20); // 関数テンプレートがインスタンス化され、print_value(int) が呼ばれる
return 0;

}
“`

この例では、print_value(10) の呼び出しに対して、int型の引数を取る非テンプレート関数が完全に一致するため、そちらが優先されます。他の型の場合は、非テンプレート関数が存在しないため、関数テンプレートがインスタンス化されます。

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

クラステンプレートは、クラスの定義において、一つ以上の型や値をテンプレートパラメータとして指定することで作成します。データ構造の実装など、格納する要素の型に依存しないクラスを定義するのに非常に有用です。

基本的な構文は以下の通りです。

“`cpp
template
class ClassName {
public:
// T を型として使用したメンバ変数やメンバ関数
T data;

ClassName(T value) : data(value) {}

void print() const {
    std::cout << "Data: " << data << std::endl;
}

};
“`

関数テンプレートと同様に、template <typename T>でテンプレート宣言を行います。クラス定義の中で、テンプレートパラメータとして指定した型名Tをメンバ変数やメンバ関数の引数、戻り値、あるいは内部的な型として使用できます。

クラステンプレートを使用（インスタンス化）する際は、必ず明示的にテンプレート引数を指定する必要があります。

“`cpp

include

include // std::vector もクラステンプレート

// 簡単なクラステンプレートの定義 (値を一つ保持するクラス)
template
class Box {
private:
T value;
public:
Box(T v) : value(v) {}
T get_value() const { return value; }
void set_value(T v) { value = v; }
};

int main() {
// int 型でインスタンス化
Box int_box(100);
std::cout << “Int box value: ” << int_box.get_value() << std::endl;

// double 型でインスタンス化
Box<double> double_box(3.14159);
std::cout << "Double box value: " << double_box.get_value() << std::endl;

// string 型でインスタンス化
Box<std::string> string_box("Hello, Template!");
std::cout << "String box value: " << string_box.get_value() << std::endl;

// std::vector もクラステンプレートの代表例
std::vector<int> numbers = {1, 2, 3};
std::vector<std::string> words = {"apple", "banana"};

return 0;

}
“`

クラステンプレートの場合、使用する際に<int>, <double>, <std::string>のように明示的にテンプレート引数を指定しています。

メンバ関数の定義（クラステンプレートの場合）

クラステンプレートのメンバ関数をクラス本体の外部で定義する場合、少し特別な構文が必要です。メンバ関数の定義の前に、そのクラスがクラステンプレートであることを示すテンプレート宣言を記述し、関数名の前に「クラステンプレート名<テンプレート引数>::」というスコープ解決演算子を付けます。

“`cpp
template
class MyClass {
public:
T data;
MyClass(T d); // コンストラクタの宣言
void print() const; // メンバ関数の宣言
};

// コンストラクタの定義 (クラス本体の外)
template
MyClass::MyClass(T d) : data(d) {
std::cout << “MyClass<” << typeid(T).name() << “> constructor called with: ” << data << std::endl;
}

// メンバ関数の定義 (クラス本体の外)
template
void MyClass::print() const {
std::cout << “Data from MyClass<” << typeid(T).name() << “>: ” << data << std::endl;
}

include // typeid を使うために必要

int main() {
MyClass mc_int(123);
mc_int.print();

MyClass<double> mc_double(4.56);
mc_double.print();

return 0;

}
“`

typeid(T).name()は、コンパイル時に決定された型Tの実行時での名前を取得するもので、ここではデバッグや説明のために使用しています。

クラステンプレートと非型テンプレート引数

クラステンプレートも非型テンプレート引数を持つことができます。標準ライブラリのstd::arrayが良い例です。std::arrayは、要素の型と配列のサイズをテンプレート引数として取ります。

“`cpp

include

int main() {
// 要素型 int, サイズ 5 の配列
std::array int_arr = {1, 2, 3, 4, 5};
std::cout << “Size of int_arr: ” << int_arr.size() << std::endl;
std::cout << “First element: ” << int_arr[0] << std::endl;

// 要素型 string, サイズ 3 の配列
std::array<std::string, 3> string_arr = {"apple", "banana", "cherry"};
std::cout << "Size of string_arr: " << string_arr.size() << std::endl;
std::cout << "Second element: " << string_arr[1] << std::endl;

return 0;

}
“`

std::array<int, 5> の <int, 5> の部分がクラステンプレートのインスタンス化です。intが型テンプレート引数、5が非型テンプレート引数です。非型テンプレート引数によって、配列のサイズがコンパイル時に固定され、スタック上に効率的にメモリを確保することができます（動的な配列であるstd::vectorとは異なります）。

デフォルトテンプレート引数 (C++11, クラステンプレート / C++20, 関数テンプレート)

テンプレート引数にはデフォルト値を指定することも可能です。クラステンプレートではC++11から、関数テンプレートではC++20から利用できます。

“`cpp
// クラステンプレートでのデフォルトテンプレート引数 (C++11以降)
template
class MyContainer {
T data[Size]; // 非型テンプレート引数を使用

public:
MyContainer() {
// デフォルトコンストラクタで何か初期化…
std::cout << “MyContainer<” << typeid(T).name() << “, ” << Size << “> created.” << std::endl;
}
// …他のメンバ関数…
};

int main() {
MyContainer<> c1; // T=int, Size=10 (デフォルト値を使用)
MyContainer c2; // T=double, Size=10 (Tのみ指定、Sizeはデフォルト値)
MyContainer c3; // T=char, Size=20 (両方指定)
// MyContainer<, 5> c4; // エラー: T を省略する場合は <> のように全ての引数を省略する必要がある
// MyContainer c5; // C++11ではエラー。C++14からは許可される。

return 0;

}
“`

クラステンプレートでは、MyContainer<> のようにテンプレート引数を全て省略した場合に限り、全てのデフォルト引数が適用されます。一部だけデフォルト引数を適用したい場合は、省略せずに指定する必要があります（C++14からは後続のデフォルト引数を省略可能になりました）。

関数テンプレートのデフォルトテンプレート引数はC++20からの機能です。

“`cpp
// 関数テンプレートでのデフォルトテンプレート引数 (C++20以降)
template
T add(T a, T b) {
return a + b;
}

int main() {
std::cout << add(1.0, 2.0) << std::endl; // T=double (引数推論により double が選ばれる)
std::cout << add(1, 2) << std::endl; // T=int (引数推論により int が選ばれる)
std::cout << add<>(1.0, 2.0) << std::endl; // T=double (明示的に <> でデフォルトを使用)
std::cout << add(1.0, 2.0) << std::endl; // T=int (明示的に int を指定、引数は int に変換される)

return 0;

}
“`

関数テンプレートの場合、引数推論が優先されるため、デフォルト引数が使用されるのは add<>() のように明示的にテンプレート引数を空で指定した場合、または引数推論に失敗した場合です。

クラステンプレート引数推論 (Class Template Argument Deduction – CTAD) (C++17)

C++17からは、クラステンプレートのインスタンス化においても、コンストラクタの引数からテンプレート引数を推論できるようになりました。

“`cpp

include // C++17 から std::vector の CTAD が可能に

include

// CTAD が有効なクラステンプレート (C++17 以降)
template
class AnotherBox {
T value;
public:
AnotherBox(T v) : value(v) {}
T get_value() const { return value; }
};

int main() {
AnotherBox int_box(100); // CTAD: T は int と推論される
AnotherBox double_box(3.14159); // CTAD: T は double と推論される
AnotherBox string_box(“Hello”); // CTAD: T は const char* と推論される (注意が必要な場合もある)

// std::vector も CTAD の恩恵を受ける
std::vector vec = {1, 2, 3}; // CTAD: std::vector<int> と推論される
// std::vector vec2 = {"a", "b", "c"}; // CTAD: std::vector<const char*> と推論される

return 0;

}
“`

CTADにより、Box<int> int_box(100); と書く代わりに AnotherBox int_box(100); と書けるようになり、コードが簡潔になりました。ただし、推論ルールには注意が必要です。例えば、文字列リテラル "Hello" は const char* 型として推論されるため、AnotherBox<const char*> string_box となります。std::stringにしたい場合は、AnotherBox string_box(std::string("Hello")); とするか、明示的に AnotherBox<std::string> string_box("Hello"); と指定する必要があります。

テンプレートの利点と欠点

ここまでテンプレートの基本的な使い方を見てきました。テンプレートがなぜ強力で便利なのか、その利点を改めて整理しましょう。しかし、どんな強力な機能にもトレードオフがあります。テンプレートを使う上での欠点や注意点も理解しておくことが重要です。

テンプレートの利点

コードの再利用性と生産性の向上:
- 異なる型に対して同じロジックを一度書くだけで済みます。これは開発時間の大幅な短縮につながります。
- データ構造やアルゴリズムを汎用的に実装できるため、様々な場面でそのまま利用できます。STL（Standard Template Library）が良い例です。
型安全性:
- テンプレートはコンパイル時に型が決定されます。これにより、誤った型での操作をコンパイル時に検出できます。void*を使った古い手法と異なり、実行時エラーのリスクを減らします。
パフォーマンス:
- テンプレートはコンパイル時に展開（インスタンス化）されるため、実行時の型情報の参照や動的なディスパッチ（仮想関数呼び出しなど）に伴うオーバーヘッドがありません。
- コンパイラはインスタンス化された特定の型のコードに対して、より積極的な最適化（例えばインライン化など）を適用できます。
- 非型テンプレート引数でサイズを固定したstd::arrayのように、コンパイル時の情報を使って効率的なメモリ管理やアクセスを実現できます。
柔軟性:
- テンプレートは、特定の型に縛られない柔軟なライブラリやフレームワークを設計するための基盤となります。ユーザーは独自の型に対しても、既存のテンプレートを利用できます。
コンパイル時処理（メタプログラミング）:
- テンプレートはコンパイル時にコードを生成するだけでなく、コンパイル時に計算や条件分岐を行う高度なテクニック（テンプレートメタプログラミング）にも利用できます。これは、実行時コストをゼロにしたい計算や、複雑な型操作などに使われます。

テンプレートの欠点と注意点

コンパイル時間の増加:
- コンパイラは、使用される各型に対してテンプレートをインスタンス化する必要があります。同じテンプレートでも異なる型で複数回使用すると、それぞれの型に対応するコードが生成されます。テンプレートの使用箇所が多い、あるいはテンプレート自体が複雑な場合、コンパイル時間が長くなる傾向があります。
実行ファイルのサイズ増加（コードブロート）:
- 異なる型でインスタンス化されたテンプレートは、それぞれ独立した関数やクラスとしてコンパイルされます。同じテンプレートでも、インスタンス化された型の数だけコードのコピーが生成されることになります。これにより、実行ファイルのサイズが増加する可能性があります。全ての型に対してコードが生成されるわけではなく、実際に使用された型についてのみ生成されますが、それでも非テンプレート関数を共有する場合よりはサイズが大きくなりがちです。
エラーメッセージが難解:
- テンプレートを使用するコードでエラーが発生した場合、コンパイラが出力するエラーメッセージは非常に長く、複雑になることが多いです。特に、テンプレートが別のテンプレートを使用しているようなネストされた構造になっている場合、エラーの根本原因を特定するのが難しくなります。これは、初心者にとってテンプレートを学ぶ上で最もつまずきやすい点の一つです。
学習曲線:
- テンプレートの概念自体、特にテンプレートのインスタンス化、特殊化、SFINAE、コンセプトといった高度な機能は、初心者にとって理解が難しい場合があります。独特な構文や、コンパイル時の挙動に関する深い理解が必要になります。
定義と宣言の分離（少し特殊）:
- 通常の関数やクラスは、ヘッダーファイルに宣言、.cppファイルに定義を記述することで、コンパイル単位を分け、コンパイル時間を短縮したり、循環参照を避けたりします。しかし、テンプレートの定義（実装）は、通常、使用する側のコンパイル単位から見えている必要があります。なぜなら、コンパイラがテンプレートをインスタンス化するためには、その定義全体が必要だからです。このため、関数テンプレートやクラステンプレートのメンバ関数の定義は、.cppファイルではなく、ヘッダーファイルに直接記述するのが一般的です。ただし、明示的なインスタンス化やexportキーワード（あまり使われない）などの例外的な方法もあります。

この欠点を理解し、適切に対処することが、テンプレートを効果的に活用する上で重要です。特に、エラーメッセージの読解力は、テンプレートを使いこなす上で必須のスキルとなります。

より高度なテンプレートの概念

テンプレートの基本的な使い方をマスターしたら、さらに強力な機能を学ぶことで、より柔軟で表現力豊かなコードを書けるようになります。ここでは、テンプレートの特殊化、非型テンプレート引数、デフォルトテンプレート引数、エイリアステンプレート、可変長引数テンプレート、SFINAE、そしてC++20で導入されたコンセプトについて解説します。

テンプレートの特殊化 (Template Specialization)

テンプレートの特殊化とは、特定の型（または特定のパターン）に対して、汎用的なテンプレートの実装とは異なる、特別な実装を提供することです。これは、特定の型に対してだけ異なる最適化を行いたい場合や、汎用実装では対応できない型（例えば、ポインタ型など）を扱いたい場合に役立ちます。

特殊化には、完全特殊化 (Full Specialization) と部分特殊化 (Partial Specialization) があります。関数テンプレートは完全特殊化のみが可能で、クラステンプレートは完全特殊化と部分特殊化の両方が可能です。

完全特殊化 (Full Specialization)

全てのテンプレート引数を具体的な型で指定して、特別な実装を提供します。

“`cpp
// 汎用関数テンプレート
template
void process(T value) {
std::cout << “Processing generic type: ” << value << std::endl;
}

// int 型に対する完全特殊化
template <> // 特殊化であることを示す <>
void process(int value) { // 全てのテンプレート引数を具体的に指定
std::cout << “Processing specialized int: ” << value * 2 << std::endl;
}

// const char 型に対する完全特殊化
template <>
void process(const char value) {
std::cout << “Processing specialized const char*: ” << value << std::endl;
}

int main() {
process(10); // int の完全特殊化が呼ばれる
process(3.14); // 汎用テンプレートが double でインスタンス化される
process(“hello”); // const char* の完全特殊化が呼ばれる
return 0;
}
“`

template <> は、続く宣言がテンプレートの特殊化であることを示します。関数名（またはクラス名）の後の < > 内に、特殊化する具体的な型を指定します。

クラステンプレートの完全特殊化も同様に行います。

“`cpp
// 汎用クラステンプレート
template
class Container {
public:
Container(T val) {
std::cout << “Generic Container created with value: ” << val << std::endl;
}
};

// int 型に対する完全特殊化
template <>
class Container { // int 型に特殊化
public:
Container(int val) {
std::cout << “Specialized Container created with value: ” << val * 10 << std::endl;
}
// 特殊化されたクラスは、汎用テンプレートとは全く異なるメンバを持つことも可能
};

int main() {
Container cd(1.1); // 汎用テンプレートを使用
Container ci(2); // int の完全特殊化を使用
return 0;
“`

完全特殊化されたクラスContainer<int>は、汎用テンプレートContainer<T>とは完全に独立したクラスとして扱われます。メンバ変数やメンバ関数も、汎用テンプレートとは異なっていても構いません。

部分特殊化 (Partial Specialization)

テンプレート引数の一部だけを指定したり、特定のパターン（例えばポインタ型、参照型、配列型など）に対して特殊化を行ったりするのが部分特殊化です。関数テンプレートは部分特殊化できません。クラステンプレートのみが部分特殊化可能です。

“`cpp
// 汎用クラステンプレート (2つのテンプレート引数を持つ)
template
class Pair {
public:
Pair(T1 v1, T2 v2) {
std::cout << “Generic Pair created: (” << v1 << “, ” << v2 << “)” << std::endl;
}
};

// T1 が int である場合の部分特殊化
template // T2 は依然としてテンプレートパラメータ
class Pair { // T1 を int に固定
public:
Pair(int v1, T2 v2) {
std::cout << “Partial specialization Pair created: (” << v1 * 10 << “, ” << v2 << “)” << std::endl;
}
};

// T1 と T2 が同じ型である場合の部分特殊化
template // 新しいテンプレートパラメータ T
class Pair { // T1 と T2 の両方を同じ型 T に固定
public:
Pair(T v1, T v2) {
std::cout << “Partial specialization Pair created: (” << v1 << “, ” << v2 << “). Both elements are the same type.” << std::endl;
}
};

int main() {
Pair p1(1.1, 2); // 汎用テンプレートを使用
Pair p2(3, 4.4); // Pair の部分特殊化を使用
Pair p3(‘a’, 5); // Pair の部分特殊化を使用 (T2=int)
Pair p4(5.5, 6.6); // Pair の部分特殊化を使用 (T=double)。 Pair よりもこちらが優先される（より特殊化されているため）
Pair p5(7, 8); // Pair の部分特殊化を使用 (T=int)。 Pair よりもこちらが優先される。
return 0;
}
“`

クラステンプレートの部分特殊化は、オリジナルのテンプレート宣言に続く < > の中で、元のテンプレート引数のパターンを指定することで行います。特殊化されたクラスのメンバは、汎用テンプレートとは独立して定義できます。コンパイラは、インスタンス化の要求に対して、最も特殊化されたテンプレートを選択します。

関数テンプレートの部分特殊化はC++の仕様にはありませんが、同様の目的は関数オーバーロードや、後述するSFINAE、コンセプトなどによって実現できます。

エイリアステンプレート (Alias Templates) (C++11)

エイリアステンプレートは、using宣言を使って型エイリアス（typedefのようなもの）をテンプレート化したものです。複雑なテンプレート型の記述を簡潔にしたり、特定の目的でテンプレート型の別名を与えたりするのに役立ちます。

“`cpp

include

// 型エイリアス (テンプレートではない)
typedef std::map StringIntMap;

// エイリアステンプレート
template
using VecOfString = std::vector; // T はアロケータ型などを想定

template
using StringMap = std::map, Key>; // KeyはComparer型などを想定

template
using Pointer = T*; // T 型へのポインタ型エイリアス

int main() {
StringIntMap my_map; // typedef を使用

// エイリアステンプレートを使用
VecOfString<std::allocator<std::string>> my_vec; // std::vector<std::string, std::allocator<std::string>> と同じ

// std::less<std::string> はデフォルトなので省略可能
StringMap<std::less<std::string>, int> user_scores; // std::map<std::string, int, std::less<std::string>, std::allocator<std::pair<const std::string, int>>> と同じ

// Pointer を使用
int value = 10;
Pointer<int> ptr = &value; // int* ptr = &value; と同じ

return 0;

}
“`

エイリアステンプレートは、既存のクラステンプレートに新しい名前を付けたり、一部のテンプレート引数を固定した新しいテンプレート型を作成したりするのに便利です。STLなどでよく利用されています。

可変長引数テンプレート (Variadic Templates) (C++11)

可変長引数テンプレートは、任意個数のテンプレート引数を受け取ることができるテンプレートです。これにより、任意個数の引数を取る関数や、任意個数の要素を持つデータ構造などを型安全に定義できます。

構文では、テンプレートパラメータリストや関数パラメータリストで ... を使用します。これはパラメータパック (Parameter Pack) と呼ばれます。

“`cpp

include

// 可変長引数関数テンプレートの例：任意の数の引数を出力する

// 終端条件となる基底関数
void print() {
std::cout << std::endl;
}

// 可変長引数を受け取るテンプレート関数
template // T は最初の引数の型、Args は残りの引数の型パック
void print(T first_arg, Args… other_args) { // first_arg は最初の引数、other_args は残りの引数のパック
std::cout << first_arg << ” “;
print(other_args…); // パックを展開して再帰呼び出し
}

int main() {
print(1, 2.5, “hello”, ‘A’); // テンプレート引数は int, double, const char*, char と推論される
print(100); // 基底関数 print() が呼ばれる
print(); // 基底関数 print() が呼ばれる
return 0;
}
“`

この例では、print関数テンプレートが再帰的に呼び出されることで、全ての引数を出力しています。Args... はゼロ個以上の型を表すパラメータパック、other_args... はゼロ個以上の変数引数を表すパラメータパックです。other_args... のように、パラメータパック名の後ろに ... を付けることでパックを展開できます。

C++17からは、畳み込み式 (Fold Expressions) を使うことで、再帰を使わずにパラメータパックを処理できる場合があります。

“`cpp
// C++17 畳み込み式の例
template
auto sum(Args… args) {
return (… + args); // ((((arg1 + arg2) + arg3) …) + argN) のように展開される (左畳み込み)
// return (args + …); // (arg1 + (arg2 + (arg3 + (… + argN)))) (右畳み込み)
// return (0 + … + args); // 初期値付き左畳み込み
// return (args + … + 0); // 初期値付き右畳み込み
}

int main() {
std::cout << sum(1, 2, 3, 4, 5) << std::endl; // 15
std::cout << sum(1.1, 2.2, 3.3) << std::endl; // 6.6
std::cout << sum() << std::endl; // 初期値付きの場合: 0, 初期値なしの場合: コンパイルエラー
return 0;
}
“`

畳み込み式は、パラメータパック内の要素に対して、指定された演算子を順次適用する便利な構文です。

可変長引数テンプレートは、コンテナクラスのコンストラクタ（例えばstd::tupleやstd::pairのコンストラクタ）や、ファクトリ関数などで非常に強力な機能を提供します。

SFINAE (Substitution Failure Is Not An Error)

SFINAEは「Substitution Failure Is Not An Error」の略で、「（テンプレートパラメータの）置き換えの失敗はエラーではない」という意味です。これは、コンパイラがテンプレートをインスタンス化しようとした際に、テンプレートパラメータの置き換え（Substitution）が失敗した場合、それは即座にコンパイルエラーとなるのではなく、そのテンプレート候補が無効として無視される、というC++テンプレートの振る舞いを指します。

このSFINAEの特性を利用すると、特定の型だけが使えるテンプレート関数を作成したり、型の能力（特定のメンバ関数を持っているかなど）に基づいて異なるテンプレート実装を選択したりするといった、コンパイル時の条件分岐を実現できます。

SFINAEを意図的に利用するための代表的な方法が、std::enable_if（C++11/14）です。std::enable_ifは、テンプレートパラメータの条件付き有効化に使われます。

“`cpp

include

include // std::enable_if_t が定義されているヘッダー

// std::enable_if_t を使用した関数テンプレートの条件付き有効化
// T が整数型の場合にのみこの関数テンプレートは有効になる
template ::value>* = nullptr>
void process_number(T value) {
std::cout << “Processing integer: ” << value << std::endl;
}

// T が浮動小数点型の場合にのみこの関数テンプレートは有効になる
template ::value>* = nullptr>
void process_number(T value) {
std::cout << “Processing floating point: ” << value << std::endl;
}

int main() {
process_number(10); // std::is_integral::value は true なので、最初のテンプレートが有効化され選択される
process_number(3.14); // std::is_floating_point::value は true なので、二番目のテンプレートが有効化され選択される
// process_number(“hello”); // std::is_integral::value も std::is_floating_point::value も false なので、どちらのテンプレートも有効化されず、コンパイルエラーになる
return 0;
}
“`

std::enable_if_t<Condition>::value は、Conditionがtrueの場合はvoid型を、falseの場合は何も型を定義しない（SFINAEを引き起こす）メタ関数です。上記の例では、std::enable_if_t<...>* という形でテンプレート引数のデフォルト値として使用しています。Conditionがfalseの場合、std::enable_if_tは型を定義しないため、デフォルト引数の typename std::enable_if_t<...>* の部分で置換失敗が発生し、そのテンプレート候補は無視されます。

SFINAEとstd::enable_ifは非常に強力ですが、構文がやや複雑で、エラーメッセージも難解になりがちです。

コンセプト (Concepts) (C++20)

C++20で導入されたコンセプトは、SFINAEに代わる、より分かりやすく意図を明確に記述できるテンプレートの制約メカニズムです。テンプレートパラメータが満たすべき要件（特定の式が有効である、特定の型に変換可能である、特定のメンバ関数を持っているなど）を明示的に記述できます。

コンセプトを使うことで、テンプレートのユーザビリティが向上し、コンパイルエラーメッセージが格段に分かりやすくなります。

“`cpp

include

include // std::integral, std::floating_point などが定義されているヘッダー

// コンセプトの定義例：加算と出力が可能な型を要求する
template
concept AddableAndPrintable = requires(T a, T b) {
{ a + b } -> std::convertible_to; // a + b が有効で、T に変換可能であること
{ std::cout << a }; // std::cout << a が有効であること
};

// コンセプトを使用した関数テンプレート
// パラメータ T は AddableAndPrintable コンセプトを満たす必要がある
template
void process_item(T value1, T value2) {
std::cout << “Processing with concept: “;
std::cout << value1 + value2 << std::endl;
}

// 標準ライブラリのコンセプトを使用
// T は整数型である必要がある
template
void process_integral(T value) {
std::cout << “Processing integral with concept: ” << value << std::endl;
}

int main() {
process_item(10, 20); // int は AddableAndPrintable を満たす
process_item(3.14, 2.71); // double は AddableAndPrintable を満たす
process_item(std::string(“hello “), std::string(“world”)); // std::string は AddableAndPrintable を満たす (operator+, operator<< が定義されているため)

process_integral(100);   // int は std::integral を満たす
// process_integral(3.14); // double は std::integral を満たさないため、コンパイルエラーになる。
                        // エラーメッセージは SFINAE よりずっと分かりやすい。

// process_item({1, 2}, {3, 4}); // std::vector は AddableAndPrintable を満たさない (operator+ が定義されていないため)、コンパイルエラー
return 0;

}
“`

コンセプトはテンプレート引数リストの <typename T> を <ConceptName T> のように置き換えるか、requires節を使ってテンプレートパラメータに制約を課します。これにより、テンプレートの意図（どのような型の利用を想定しているか）がコード上で明確になり、要件を満たさない型でテンプレートを使おうとした際には、より適切なコンパイルエラーが報告されます。C++20以降でテンプレートを使う場合は、積極的にコンセプトの利用を検討すべきです。

標準ライブラリにおけるテンプレート

C++標準ライブラリ（特にSTL – Standard Template Library）は、テンプレート機能の最も代表的かつ大規模な応用例です。STLは、様々なデータ構造（コンテナ）、アルゴリズム、ユーティリティなどを、特定の型に依存しない汎用的な形で提供しています。

コンテナ (Containers):
- std::vector<T>: 可変長配列
- std::list<T>: 双方向リンクリスト
- std::deque<T>: 両端キュー
- std::set<T>, std::map<Key, Value>: ソート済みコンテナ（赤黒木などに基づく）
- std::unordered_set<T>, std::unordered_map<Key, Value>: ハッシュテーブルに基づくコンテナ
- std::stack<T, Container>, std::queue<T, Container>: アダプタコンテナ
- std::array<T, Size>: 固定長配列（非型テンプレート引数を使用）
これらのコンテナは、格納する要素の型T（やキー/値の型Key, Valueなど）をテンプレート引数として受け取るクラステンプレートとして実装されています。
アルゴリズム (Algorithms):
- std::sort(first, last): 範囲をソート
- std::find(first, last, value): 範囲から値を検索
- std::copy(first, last, dest): 範囲をコピー
- std::for_each(first, last, func): 範囲の各要素に関数を適用
これらのアルゴリズムは、特定のコンテナ型や要素型に縛られず、イテレータ（後述）の概念を使って汎用的に定義された関数テンプレートです。任意のイテレータのペア（範囲を示す）と、要素に対する操作を行う関数オブジェクトなどをテンプレート引数として受け取ります。
イテレータ (Iterators):
- コンテナ内の要素を指し示し、順次アクセスするための抽象化された概念です。ポインタのように振る舞いますが、コンテナの種類（配列、リスト、木など）に応じた適切なアクセス方法を提供します。アルゴリズムはイテレータを通じてコンテナの要素にアクセスするため、同じアルゴリズムを様々なコンテナに適用できます。イテレータ自身もテンプレートに深く関連しています。
ファンクタ / 関数オブジェクト (Functors / Function Objects):
- 関数のように呼び出し可能なオブジェクト (operator() をオーバーロードしたクラスのインスタンス) です。STLアルゴリズムなどに、特定の操作（比較、変換、条件判定など）を渡すために使われます。std::plus<T>, std::less<T>などの標準ファンクタや、ラムダ式も概念的にはこれに含まれます。std::functionは、任意の呼び出し可能なエンティティ（関数ポインタ、関数オブジェクト、ラムダ式）を型安全に保持できるクラステンプレートです。
スマートポインタ (Smart Pointers):
- std::unique_ptr<T>, std::shared_ptr<T> などは、メモリ管理を自動化するクラステンプレートです。管理するオブジェクトの型Tをテンプレート引数として受け取ります。
型特性 (Type Traits):
- <type_traits> ヘッダーで提供されるクラステンプレートやエイリアステンプレート群です。コンパイル時に型の情報（整数型か、ポインタ型か、クラスか、コピー可能かなど）を調べたり、型を変換したりするために使われます。SFINAEやコンセプトと組み合わせて、テンプレートの条件付きコンパイルによく利用されます。

STLを使いこなすことは、すなわちC++テンプレートの応用例を学ぶことでもあります。STLのヘッダーファイルを覗いてみると、様々なテンプレートが定義されていることが分かります。

テンプレートのデバッグ：難解なエラーとの戦い方

テンプレートを使ったコードを書く上で避けて通れないのが、コンパイルエラーです。特にテンプレート関連のエラーメッセージは非常に長く、慣れないうちはどこから手をつけて良いか分からないかもしれません。しかし、いくつかのポイントを押さえれば、エラーメッセージを読み解くスキルを身につけることができます。

エラーメッセージの読み方:
- コンパイラは通常、最初に見つけたエラーから順番に報告します。多くの場合、最初のエラーが根本原因であり、それに続くエラーは最初の連鎖反応によるものです。まずは最初の（または最も早い行番号の）エラーメッセージに注目しましょう。
- テンプレートのエラーメッセージは、テンプレートがインスタンス化された具体的な型とその呼び出し箇所、そしてテンプレートのどの部分で問題が発生したか（どの行の式が有効でないかなど）を詳細に報告します。
- エラーメッセージの中に、あなたが書いたコードのファイル名と行番号が含まれているはずです。まずはその箇所を確認します。
- テンプレートのインスタンス化によって生成された「内部的な名前」のようなものが表示されることがありますが、これは最初は無視して構いません。重要なのは、エラーが発生した「テンプレートの元の定義場所」と「そのテンプレートがどの型でインスタンス化されようとしていたか」の情報です。
例：max(i1, d1) のように異なる型でmaxテンプレート関数を呼び出した場合（かつ、異なる型での比較が定義されていない場合）。
error: no matching function for call to 'max(int&, double&)' note: candidate template ignored: deduced conflicting types for parameter 'T' ('int' vs 'double')
このメッセージは、「max(int&, double&) に一致する関数がない」こと、そして「テンプレート候補が無視された理由」として「パラメータTに対して異なる型（intとdouble）が推論されて競合したため」と明確に述べています。このように、コンパイラによっては非常に親切なメッセージを出力してくれることもあります。

複雑な場合は、エラーメッセージを下から上に読んでいくのが有効なこともあります。一番下のメッセージが、コンパイラが最終的に諦めた部分であり、そこに問題の核心がある可能性があります。
インスタンス化されたコードの確認:
- 一部のコンパイラ（特にGCCやClang）では、テンプレートがインスタンス化された後のコードを出力するオプションがあります（例: g++ -std=c++17 -fdump-tree-original -fdump-tree-optimized your_code.cpp）。これを活用すると、実際にコンパイラが生成したコードを確認でき、問題の箇所をより深く理解できる場合があります。ただし、出力されるコードは非常に低レベルで読みにくいことが多いです。
静的アサート (Static Assertions):
- static_assertは、コンパイル時に評価される条件を指定し、その条件が偽の場合にコンパイルエラーを発生させる機能です。テンプレートの中で、テンプレートパラメータが特定の要件を満たしているかを確認するために非常に有効です。SFINAEやコンセプトがない時代には、これにより早期にエラーを検出することがよく行われました。
  “`cpp
  template
  void process_arithmetic(T value) {
  static_assert(std::is_arithmetic::value, “Type T must be arithmetic (int, float, etc.)”); // T が算術型でない場合はコンパイルエラー
  std::cout << “Processing arithmetic value: ” << value << std::endl;
  }
int main() {
process_arithmetic(10); // OK
process_arithmetic(3.14); // OK
// process_arithmetic(“hello”); // コンパイルエラー: Type T must be arithmetic (int, float, etc.)
return 0;
}
``static_assertのエラーメッセージは、あなたが指定した文字列なので、非常に分かりやすいです。テンプレートの制約を指定する際には、コンセプト（C++20）がより推奨されますが、古い標準や単純なケースではstatic_assert`も有効です。
デバッガ:
- テンプレートのインスタンス化はコンパイル時に行われるため、実行時デバッガでテンプレートの展開過程をステップ実行することは難しいです。デバッグの主な焦点は、コンパイル時のエラーメッセージを理解すること、または実行時エラーが発生した場合は、インスタンス化された特定の型のコードに対してデバッグを行うことになります。

テンプレートのデバッグは慣れが必要です。最初のエラーで諦めず、メッセージを注意深く読み、何が問題なのかを分析する練習を重ねることが重要です。

テンプレートを使う上でのベストプラクティス

テンプレートはその強力さゆえに、適切に使用しないとコードの可読性や保守性を損なう可能性があります。以下に、テンプレートを使う上でのいくつかのベストプラクティスを示します。

テンプレートの定義はヘッダーファイルに:
- 前述のように、テンプレートの定義（実装）は、使用するコンパイル単位から見えている必要があります。特別な理由がない限り、テンプレートの定義はヘッダーファイル（.hや.hpp）に記述するのが最も一般的で簡単な方法です。これにより、リンカーエラー（定義が見つからないというエラー）を防ぐことができます。
テンプレート引数名を分かりやすくする:
- テンプレートパラメータ名は、単にT、Uといったアルファベット一文字で済ませることも多いですが、テンプレートの役割が複雑な場合は、ValueType, Container, Hasher, Predicateのように、そのパラメータが何を表しているかを明確に示す名前を使うと、コードの可読性が向上します。
不必要なテンプレート化を避ける:
- 全てをテンプレート化する必要はありません。特定の型に対してのみ処理を行う関数やクラスであれば、非テンプレートのままにしておく方が、コンパイル時間の短縮やコードサイズの削減につながる場合があります。テンプレートは、真に汎用性が必要な場合に利用するのが賢明です。
コンセプト (C++20) を活用する:
- C++20以降を使用できる環境であれば、コンセプトを使ってテンプレートパラメータの制約を明示的に指定しましょう。これにより、テンプレートの利用者がどのような型を渡すべきかを理解しやすくなり、コンパイルエラーメッセージも格段に分かりやすくなります。これは、テンプレートのユーザビリティとデバッグのしやすさを大きく改善します。
ドキュメンテーションをしっかり行う:
- テンプレートは非テンプレートのコードよりも理解が難しい傾向があります。特に、テンプレートパラメータがどのような要件（コンセプト、必要なメンバ関数など）を満たす必要があるのかを、ドキュメント（コメントなど）で明確に記述することが重要です。
コンパイル時間とコードサイズへの影響を考慮する:
- 大規模なプロジェクトでテンプレートを多用する場合、コンパイル時間がボトルネックになることがあります。テンプレートのインスタンス化の頻度や複雑さ、またコードサイズの増加について意識し、必要に応じて最適化や設計の見直しを検討します。

まとめ：テンプレートを使いこなす旅へ

C++テンプレートは、ジェネリックプログラミングを実現するための強力な機能です。関数テンプレートやクラステンプレートを使うことで、型に依存しない再利用性の高いコードを記述できます。これは、コードの重複を減らし、保守性を高め、型安全性を確保し、高いパフォーマンスを達成するために不可欠です。

もちろん、テンプレートにはコンパイル時間の増加や難解なエラーメッセージといった課題もあります。しかし、テンプレートの仕組み（コンパイル時のインスタンス化）を理解し、エラーメッセージを読み解く練習を重ね、そしてC++20で導入されたコンセプトのような新しい機能を活用することで、これらの課題に対処し、テンプレートの恩恵を最大限に享受できるようになります。

標準ライブラリ（STL）はテンプレートの宝庫であり、その使い方を学ぶことは、テンプレートの実践的な応用例を学ぶことでもあります。std::vector, std::map, std::sortといったツールが、なぜこれほど便利で強力なのか、テンプレートの視点から理解が深まるでしょう。

この記事が、皆さんがC++テンプレートの基本を理解し、その強力さを実感し、そしてさらに深く学んでいくための確固たる土台となることを願っています。テンプレートはC++プログラミングの重要な一歩であり、これをマスターすることで、より洗練された効率的なコードを書くことができるようになります。

最初は難しく感じるかもしれませんが、少しずつでもコードを書き、エラーと向き合い、試行錯誤を繰り返すことで、必ずテンプレートを使いこなせるようになります。

C++テンプレートの世界へ、ようこそ！そして、素晴らしいプログラミングの旅を続けてください。

C++ Templateとは？初心者向け基本と使い方を徹底解説

はじめに：なぜC++を学ぶのか、そして次なるステップへ

テンプレートがない世界の課題：なぜ汎用性が必要なのか？

テンプレートの基本：汎用的なコードの書き方

関数テンプレートの基本

include

include

複数のテンプレート引数

非型テンプレート引数 (Non-type Template Parameters)

関数のオーバーロードとテンプレート

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

include

include

include // std::vector もクラステンプレート

メンバ関数の定義（クラステンプレートの場合）

include // typeid を使うために必要

クラステンプレートと非型テンプレート引数

include

include

include

デフォルトテンプレート引数 (C++11, クラステンプレート / C++20, 関数テンプレート)

クラステンプレート引数推論 (Class Template Argument Deduction – CTAD) (C++17)

include // C++17 から std::vector の CTAD が可能に

include

テンプレートの利点と欠点

テンプレートの利点

テンプレートの欠点と注意点

より高度なテンプレートの概念

テンプレートの特殊化 (Template Specialization)

完全特殊化 (Full Specialization)

部分特殊化 (Partial Specialization)

エイリアステンプレート (Alias Templates) (C++11)

include

include

include

include

可変長引数テンプレート (Variadic Templates) (C++11)

include

SFINAE (Substitution Failure Is Not An Error)

include

include // std::enable_if_t が定義されているヘッダー

コンセプト (Concepts) (C++20)

include

include

include

include

include // std::integral, std::floating_point などが定義されているヘッダー

標準ライブラリにおけるテンプレート

テンプレートのデバッグ：難解なエラーとの戦い方

テンプレートを使う上でのベストプラクティス

まとめ：テンプレートを使いこなす旅へ

コメントする 返信をキャンセル

コメントする返信をキャンセル