[C++] 関数テンプレートの定義と使い方

#include <iostream>
// テンプレートの定義
template <typename T>
T add(T a, T b) {
    return a + b;
}
int main() {
    std::cout << add(3, 4) << std::endl; // 整数の加算
    std::cout << add(3.5, 4.5) << std::endl; // 浮動小数点数の加算
    return 0;
}

7
8

#include <iostream>
// 単一のテンプレートパラメータ
template <typename T>
T multiply(T a, T b) {
    return a * b;
}
// 複数のテンプレートパラメータ
template <typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}
int main() {
    std::cout << multiply(2, 3) << std::endl; // 整数の乗算
    std::cout << add(2, 3.5) << std::endl; // 整数と浮動小数点数の加算
    return 0;
}

#include <iostream>
template <typename T>
T subtract(T a, T b) {
    return a - b;
}
int main() {
    std::cout << subtract(10, 5) << std::endl; // 型推論による整数の減算
    std::cout << subtract<double>(10, 5) << std::endl; // 明示的な型指定による減算
    return 0;
}

#include <iostream>
template <typename T = int>
T divide(T a, T b) {
    return a / b;
}
int main() {
    std::cout << divide(10, 2) << std::endl; // デフォルトの型(int)による除算
    std::cout << divide<double>(10.0, 2.0) << std::endl; // 明示的な型指定による除算
    return 0;
}

#include <iostream>
// テンプレート関数の定義
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}
int main() {
    std::cout << max(10, 20) << std::endl; // 整数の比較
    std::cout << max(10.5, 20.5) << std::endl; // 浮動小数点数の比較
    return 0;
}

#include <iostream>
// テンプレート関数
template <typename T>
T square(T a) {
    return a * a;
}
// 特定の型に対するオーバーロード
int square(int a) {
    std::cout << "Integer version called" << std::endl;
    return a * a;
}
int main() {
    std::cout << square(5) << std::endl; // 整数版が呼ばれる
    std::cout << square(5.5) << std::endl; // テンプレート版が呼ばれる
    return 0;
}

#include <iostream>
// テンプレート関数
template <typename T>
T absolute(T a) {
    return (a < 0) ? -a : a;
}
// 完全特殊化
template <>
const char* absolute(const char* a) {
    return a; // 文字列に対してはそのまま返す
}
int main() {
    std::cout << absolute(-10) << std::endl; // 整数の絶対値
    std::cout << absolute(-10.5) << std::endl; // 浮動小数点数の絶対値
    std::cout << absolute("Hello") << std::endl; // 文字列はそのまま
    return 0;
}

#include <iostream>
// テンプレートによる再帰的な階乗計算
template <unsigned int N>
struct Factorial {
    static const unsigned int value = N * Factorial<N - 1>::value;
};
// 基底ケース
template <>
struct Factorial<0> {
    static const unsigned int value = 1;
};
int main() {
    std::cout << "Factorial of 5: " << Factorial<5>::value << std::endl;
    return 0;
}

#include <iostream>
// フィボナッチ数列のテンプレートメタプログラミング
template <unsigned int N>
struct Fibonacci {
    static const unsigned int value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value;
};
// 基底ケース
template <>
struct Fibonacci<0> {
    static const unsigned int value = 0;
};
template <>
struct Fibonacci<1> {
    static const unsigned int value = 1;
};
int main() {
    std::cout << "Fibonacci of 10: " << Fibonacci<10>::value << std::endl;
    return 0;
}

#include <iostream>
#include <type_traits>
// SFINAEを用いた関数テンプレート
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
process(T value) {
    std::cout << "Integral type: " << value << std::endl;
    return value;
}
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
process(T value) {
    std::cout << "Floating point type: " << value << std::endl;
    return value;
}
int main() {
    process(10); // 整数型
    process(10.5); // 浮動小数点型
    return 0;
}

#include <iostream>
// テンプレート関数
template <typename T>
T divide(T a, T b) {
    return a / b; // 除算演算子が定義されていない型に対してはエラー
}
int main() {
    std::cout << divide(10, 2) << std::endl; // 整数の除算
    // std::cout << divide("Hello", "World") << std::endl; // コンパイルエラー
    return 0;
}

#include <iostream>
// テンプレート関数
template <typename T>
T multiply(T a, T b) {
    return a * b;
}
int main() {
    std::cout << multiply(2, 3) << std::endl; // int型でインスタンス化
    std::cout << multiply(2.5, 3.5) << std::endl; // double型でインスタンス化
    return 0;
}

#include <iostream>
// テンプレートによるバブルソート関数
template <typename T>
void bubbleSort(T arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        for (int j = 0; j < n - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                T temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
int main() {
    int intArr[] = {5, 2, 9, 1, 5, 6};
    double doubleArr[] = {3.5, 2.1, 5.6, 1.2};
    bubbleSort(intArr, 6);
    bubbleSort(doubleArr, 4);
    std::cout << "Sorted integer array: ";
    for (int i : intArr) std::cout << i << " ";
    std::cout << std::endl;
    std::cout << "Sorted double array: ";
    for (double d : doubleArr) std::cout << d << " ";
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <type_traits>
#include <cmath>

// 整数型に対するGCDの計算
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
gcd(T a, T b) {
    while (b != 0) {
        T temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

// 浮動小数点数型に対するGCDの計算
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
gcd(T a, T b) {
    const T epsilon = 1e-9; // 許容誤差
    while (std::fabs(b) > epsilon) {
        T temp = b;
        b = std::fmod(a, b);
        a = temp;
    }
    return a;
}

int main() {
    int int_a = 56, int_b = 98;
    double double_a = 56.0, double_b = 98.0;

    std::cout << "GCD of integers: " << gcd(int_a, int_b) << std::endl;
    std::cout << "GCD of floating-point numbers: " << gcd(double_a, double_b) << std::endl;

    return 0;
}

#include <iostream>
#include <vector>
// テンプレートによるベクトル要素の表示
template <typename T>
void printVector(const std::vector<T>& vec) {
    for (const T& elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
}
int main() {
    std::vector<int> intVec = {1, 2, 3, 4, 5};
    std::vector<std::string> stringVec = {"Hello", "World"};
    printVector(intVec);
    printVector(stringVec);
    return 0;
}