[C++] テンプレートクラスのメンバ関数の定義方法

#include <iostream>
// テンプレートクラスの定義
template<typename T>
class Sample {
public:
    // クラス内でのメンバ関数の定義
    void display(const T& value) {
        std::cout << "Value: " << value << std::endl;
    }
};
int main() {
    Sample<int> intSample;
    intSample.display(10); // 出力: Value: 10
    Sample<std::string> stringSample;
    stringSample.display("Hello"); // 出力: Value: Hello
    return 0;
}

#include <iostream>
// テンプレートクラスの宣言
template<typename T>
class Sample {
public:
    void display(const T& value);
};
// クラス外でのメンバ関数の定義
template<typename T>
void Sample<T>::display(const T& value) {
    std::cout << "Value: " << value << std::endl;
}
int main() {
    Sample<int> intSample;
    intSample.display(20); // 出力: Value: 20
    Sample<std::string> stringSample;
    stringSample.display("World"); // 出力: Value: World
    return 0;
}

#include <iostream>
#include <string>
// テンプレートクラスの宣言
template<typename T, typename U>
class Pair {
public:
    void display() {
        std::cout << "Generic Pair" << std::endl;
    }
};
// 部分特殊化：2つの型が同じ場合
template<typename T>
class Pair<T, T> {
public:
    void display() {
        std::cout << "Specialized Pair with same types" << std::endl;
    }
};
int main() {
    Pair<int, double> genericPair;
    genericPair.display(); // 出力: Generic Pair
    Pair<int, int> specializedPair;
    specializedPair.display(); // 出力: Specialized Pair with same types
    return 0;
}

#include <iostream>
#include <string>
// テンプレートクラスの宣言
template<typename T>
class Printer {
public:
    void print(const T& value) {
        std::cout << "Generic Printer: " << value << std::endl;
    }
};
// 完全特殊化：std::string型の場合
template<>
class Printer<std::string> {
public:
    void print(const std::string& value) {
        std::cout << "String Printer: " << value << std::endl;
    }
};
int main() {
    Printer<int> intPrinter;
    intPrinter.print(100); // 出力: Generic Printer: 100
    Printer<std::string> stringPrinter;
    stringPrinter.print("Hello, World!"); // 出力: String Printer: Hello, World!
    return 0;
}

#include <iostream>
#include <vector>
// テンプレートクラスによるスタックの実装
template<typename T>
class Stack {
private:
    std::vector<T> elements;
public:
    void push(const T& element) {
        elements.push_back(element);
    }
    void pop() {
        if (!elements.empty()) {
            elements.pop_back();
        }
    }
    T top() const {
        return elements.back();
    }
    bool isEmpty() const {
        return elements.empty();
    }
};
int main() {
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    std::cout << "Top element: " << intStack.top() << std::endl; // 出力: Top element: 2
    intStack.pop();
    std::cout << "Top element after pop: " << intStack.top() << std::endl; // 出力: Top element after pop: 1
    return 0;
}

#include <iostream>
// テンプレートクラスによるユニークポインタの実装
template<typename T>
class UniquePtr {
private:
    T* ptr;
public:
    explicit UniquePtr(T* p = nullptr) : ptr(p) {}
    ~UniquePtr() { delete ptr; }
    T& operator*() { return *ptr; }
    T* operator->() { return ptr; }
    // コピー禁止
    UniquePtr(const UniquePtr&) = delete;
    UniquePtr& operator=(const UniquePtr&) = delete;
    // ムーブセマンティクス
    UniquePtr(UniquePtr&& other) noexcept : ptr(other.ptr) { other.ptr = nullptr; }
    UniquePtr& operator=(UniquePtr&& other) noexcept {
        if (this != &other) {
            delete ptr;
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }
};
int main() {
    UniquePtr<int> uniquePtr(new int(42));
    std::cout << "Value: " << *uniquePtr << std::endl; // 出力: Value: 42
    return 0;
}

#include <iostream>
#include <cmath>
// テンプレートクラスによるベクトルの実装
template<typename T>
class Vector2D {
private:
    T x, y;
public:
    Vector2D(T x, T y) : x(x), y(y) {}
    T magnitude() const {
        return std::sqrt(x * x + y * y);
    }
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }
    void display() const {
        std::cout << "Vector(" << x << ", " << y << ")" << std::endl;
    }
};
int main() {
    Vector2D<double> vec1(3.0, 4.0);
    Vector2D<double> vec2(1.0, 2.0);
    Vector2D<double> vec3 = vec1 + vec2;
    vec3.display(); // 出力: Vector(4, 6)
    std::cout << "Magnitude: " << vec3.magnitude() << std::endl; // 出力: Magnitude: 7.2111
    return 0;
}