サンプルコード

#include <iostream>
#include <string>  // ← 関数テンプレートのため、という訳ではなく string を使用したいため。
using namespace std;

// シンプルなテンプレート
template <typename MY_TYPE>
  MY_TYPE MyFunc(MY_TYPE a)
{
    return a * a;
}

// 未確定な型が二つあるテンプレート
template <typename MY_TYPE_A, typename MY_TYPE_B>
  void MyFunc2(MY_TYPE_A a, MY_TYPE_B b)
{
    cout << a << ", " << b << endl;
}

// 特定のメソッドを有するクラスを想定したテンプレート
template <typename MY_TYPE>
  void MyFunc3(const MY_TYPE& container)
{
    for(int i = 0, size = container.size(); i < size; ++i) {
        cout << container[i] << endl;
    }
}

int main() {
    // それっぽい型で解釈させても問題にならないと思われる場合
    MyFunc2(MyFunc(10), MyFunc(1.5)); //=> 100, 2.25

    // 曖昧さがあったり、自動解釈では困る場合
    // テンプレート実引数で型を明記できます
    cout << MyFunc<int>(1.5) << endl; //=> 1
    cout << MyFunc<double>(1.5) << endl; //=> 2.25
    MyFunc2<int, char>('0', '0'); //=> 48, 0
    MyFunc3<string>("string"); //← 指定しないと const char* と解釈されてエラー
    return 0;
}

関数テンプレートを使用する箇所で都度、よばれた型で関数の実体が生成されます。そのため、関数テンプレートを使用する側から丸々中身が見える必要があり、ヘッダファイルには通常プロトタイプ宣言だけを記述することはできず、関数テンプレートをすべて記述する必要があります。

これを避ける実用上ほぼ唯一の方法に「明示的実体化」というものがあります。関数テンプレートの実装を記述したファイルで明示的実体化をしておけば、その型に関して関数の実体が用意されるため、関数テンプレートを使用する側で通常発生する実体化が不要となり、したがって中身の実装を知る必要がなくなるため、ヘッダファイルに関数テンプレートのプロトタイプ宣言だけを記述しておくことができます。

main.cpp

#include <iostream>
#include "sub.h"
using namespace std;

int main() {
    cout << MyFunc(10) << endl;
    return 0;
}

sub.h

#ifndef SUB_H_
#define SUB_H_

template <typename MY_TYPE>
  MY_TYPE MyFunc(MY_TYPE a); // ← プロトタイプ宣言

#endif // #ifndef SUB_H_

sub.cpp

#include "sub.h"

template <typename MY_TYPE>
  MY_TYPE MyFunc(MY_TYPE a)
{
    return a * a;
}

template int MyFunc(int a); // 明示的実体化

コンパイル例

g++ -Wall -o main.o -c main.cpp
g++ -Wall -o sub.o -c sub.cpp
g++ -Wall -o main main.o sub.o

分割コンパイルについては、こちらやこちらをご参照ください。

特殊化とオーバロード

クラステンプレートの場合と異なり部分特殊化はありません。オーバロードで対応します。

#include <iostream>
using namespace std;

template <typename MY_TYPE_A, typename MY_TYPE_B>
  void MyFunc(MY_TYPE_A a, MY_TYPE_B b)
{
    cout << a << ", " << b << endl;
}

// 特殊化
template <>
  void MyFunc(double a, double b)
{
    cout << "double double: " << a << ", " << b << endl;
}

// オーバロード (部分特殊化ではない)
template <typename MY_TYPE_B>
  void MyFunc(double a, MY_TYPE_B b)
{
    cout << "double *: " << a << ", " << b << endl;
}

int main() {
    MyFunc<int, int>(1, 1); //=> 1, 1 (通常のテンプレート)
    MyFunc<double, double>(1.1, 1.1); //=> double double: 1.1, 1.1 (特殊化)
    MyFunc<double, int>(1.1, 1); //=> 1.1, 1 (通常のテンプレート) ← テンプレート引数が2つ
    MyFunc<int>(1.1, 1); //=> double *: 1.1, 1 (オーバロードした通常のテンプレート) ← テンプレート引数が1つ

    // テンプレート引数を省略すると、より合致率の高いもの
    // 今回の場合はオーバロード済みのものが利用される。
    MyFunc(1.1, 1); //=> double *: 1.1, 1
    return 0;
}

関連ページ

voidへのポインタ (C++をもう一度)

サンプルコード void へのポインタ void* には関数ポインタおよびメンバポインタを除く (← コンパイラによっては代入できてしまいますが独自仕様です) ポインタをキャストなしで代入できます。ただし void* のままでは、実体にアクセスすることも他のポインタに代入することもできません。事前に何らかの型のポインタ型にキャストする必要があります。

STL/アルゴリズム (C++をもう一度)

概要配列のように複数の要素の入れ物として機能するクラスをコンテナとよびます。コンテナクラスには vector、list、queue/stack などがあります。それぞれのコンテナクラスはクラステンプレートとして提供されており、したがってヘッダファイルを include するだけで使用できます。ヘッダファイルにはコンテナクラスのクラステンプレートだけでなく、そのコンテナのイテレータクラスのクラス

クラステンプレート (C++をもう一度)

サンプルコード my_class.h #ifndef MY_CLASS_H_ #define MY_CLASS_H_ // 関数テンプレート https://www.qoosky.io/techs/22b50b7062 と同様、 // テンプレートは通常ヘッダファイルにすべてを記述する必要があります。 // ヘッダファイルでの using 使用は好ましくないため std::cout 等とします