[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;
}

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

#include <iostream>
// クラステンプレートの定義
template <typename T>
class Box {
public:
    Box(T value) : value_(value) {}
    T getValue() const { return value_; }
private:
    T value_;
};
int main() {
    Box<int> intBox(123);
    Box<double> doubleBox(456.78);
    std::cout << intBox.getValue() << std::endl; // 整数のボックス
    std::cout << doubleBox.getValue() << std::endl; // 浮動小数点数のボックス
    return 0;
}

#include <iostream>
// 部分特殊化の例
template <typename T, typename U>
class Pair {
public:
    Pair(T first, U second) : first_(first), second_(second) {}
    void print() const {
        std::cout << first_ << ", " << second_ << std::endl;
    }
private:
    T first_;
    U second_;
};
// 特定の型に対する部分特殊化
template <typename T>
class Pair<T, int> {
public:
    Pair(T first, int second) : first_(first), second_(second) {}
    void print() const {
        std::cout << "Specialized: " << first_ << ", " << second_ << std::endl;
    }
private:
    T first_;
    int second_;
};
int main() {
    Pair<double, int> specializedPair(3.14, 42);
    specializedPair.print(); // 部分特殊化された出力
    return 0;
}

#include <iostream>
// 完全特殊化の例
template <typename T>
class Printer {
public:
    void print(T value) {
        std::cout << "Generic: " << value << std::endl;
    }
};
// 特定の型に対する完全特殊化
template <>
class Printer<int> {
public:
    void print(int value) {
        std::cout << "Specialized for int: " << value << std::endl;
    }
};
int main() {
    Printer<int> intPrinter;
    intPrinter.print(123); // 完全特殊化された出力
    return 0;
}

// example.h
#ifndef EXAMPLE_H
#define EXAMPLE_H
#include <iostream>
// 関数テンプレートの定義
template <typename T>
T add(T a, T b) {
    return a + b;
}
#endif // EXAMPLE_H

// example.h
#ifndef EXAMPLE_H
#define EXAMPLE_H
#include <iostream>
// インライン関数テンプレートの定義
template <typename T>
inline T multiply(T a, T b) {
    return a * b;
}
#endif // EXAMPLE_H

// example.cpp
#include "example.h"
// 明示的インスタンス化
template int add<int>(int, int);
template double add<double>(double, double);

#include <iostream>
// スマートポインタの簡単な実装
template <typename T>
class SmartPointer {
public:
    explicit SmartPointer(T* ptr) : ptr_(ptr) {}
    ~SmartPointer() { delete ptr_; }
    T& operator*() { return *ptr_; }
    T* operator->() { return ptr_; }
private:
    T* ptr_;
};
int main() {
    SmartPointer<int> ptr(new int(42));
    std::cout << *ptr << std::endl; // スマートポインタを通じて値を取得
    return 0;
}

#include <iostream>
#include <vector>
// 汎用的なスタッククラスの実装
template <typename T>
class Stack {
public:
    void push(const T& value) { data_.push_back(value); }
    void pop() { if (!data_.empty()) data_.pop_back(); }
    T top() const { return data_.back(); }
    bool empty() const { return data_.empty(); }
private:
    std::vector<T> data_;
};
int main() {
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    std::cout << intStack.top() << std::endl; // スタックのトップ要素を取得
    intStack.pop();
    std::cout << intStack.top() << std::endl; // スタックのトップ要素を取得
    return 0;
}

#include <iostream>
// ベクトルクラスの実装
template <typename T>
class Vector2D {
public:
    Vector2D(T x, T y) : x_(x), y_(y) {}
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x_ + other.x_, y_ + other.y_);
    }
    void print() const {
        std::cout << "(" << x_ << ", " << y_ << ")" << std::endl;
    }
private:
    T x_, y_;
};
int main() {
    Vector2D<int> vec1(1, 2);
    Vector2D<int> vec2(3, 4);
    Vector2D<int> result = vec1 + vec2;
    result.print(); // ベクトルの加算結果を表示
    return 0;
}