[C++] テンプレートを使用したコンストラクタの定義方法

#include <iostream>
// クラスの定義
class MyClass {
public:
    // テンプレートコンストラクタ
    template <typename T>
    MyClass(T value) {
        std::cout << "Value: " << value << std::endl;
    }
};
int main() {
    MyClass obj1(10);       // int型
    MyClass obj2(3.14);     // double型
    MyClass obj3("Hello");  // const char*型
    return 0;
}

template <typename T>
MyClass(T value) {
    // コンストラクタの処理
}

#include <iostream>
// クラスの定義
class MyClass {
public:
    // デフォルトテンプレート引数を持つコンストラクタ
    template <typename T = int>
    MyClass(T value = 0) {
        std::cout << "Value: " << value << std::endl;
    }
};
int main() {
    MyClass obj1;          // デフォルトのint型
    MyClass obj2(3.14);    // double型
    return 0;
}

#include <iostream>
// クラスの定義
class MyClass {
public:
    // 複数のテンプレートパラメータを持つコンストラクタ
    template <typename T, typename U>
    MyClass(T first, U second) {
        std::cout << "First: " << first << ", Second: " << second << std::endl;
    }
};
int main() {
    MyClass obj1(10, 3.14);       // int型とdouble型
    MyClass obj2("Hello", 42);    // const char*型とint型
    return 0;
}

#include <iostream>
// クラスの定義
class Printer {
public:
    // 単一型のテンプレートコンストラクタ
    template <typename T>
    Printer(T value) {
        std::cout << "Printing: " << value << std::endl;
    }
};
int main() {
    Printer p1(100);         // int型
    Printer p2(3.1415);      // double型
    Printer p3("C++");       // const char*型
    return 0;
}

#include <iostream>
// クラスの定義
class Pair {
public:
    // 複数型のテンプレートコンストラクタ
    template <typename T, typename U>
    Pair(T first, U second) {
        std::cout << "First: " << first << ", Second: " << second << std::endl;
    }
};
int main() {
    Pair p1(10, 20.5);          // int型とdouble型
    Pair p2("Hello", 42);       // const char*型とint型
    return 0;
}

#include <iostream>
#include <vector>
// クラスの定義
template <typename T>
class Container {
    std::vector<T> elements;
public:
    // コンテナクラスのテンプレートコンストラクタ
    template <typename U>
    Container(const std::vector<U>& vec) {
        for (const auto& elem : vec) {
            elements.push_back(static_cast<T>(elem));
        }
    }
    void print() const {
        for (const auto& elem : elements) {
            std::cout << elem << " ";
        }
        std::cout << std::endl;
    }
};
int main() {
    std::vector<int> intVec = {1, 2, 3};
    Container<double> doubleContainer(intVec);
    doubleContainer.print();  // 出力: 1.0 2.0 3.0
    std::vector<float> floatVec = {1.1f, 2.2f, 3.3f};
    Container<int> intContainer(floatVec);
    intContainer.print();     // 出力: 1 2 3
    return 0;
}

#include <iostream>
// クラスの定義
class Converter {
    double value;
public:
    // 型変換を伴うテンプレートコンストラクタ
    template <typename T>
    Converter(T input) : value(static_cast<double>(input)) {
        std::cout << "Converted value: " << value << std::endl;
    }
};
int main() {
    Converter c1(42);        // int型からdouble型への変換
    Converter c2(3.14f);     // float型からdouble型への変換
    return 0;
}

#include <iostream>
#include <memory>
// クラスの定義
class Resource {
public:
    Resource() {
        std::cout << "Resource acquired" << std::endl;
    }
    ~Resource() {
        std::cout << "Resource released" << std::endl;
    }
};
// スマートポインタを使用したクラス
class Manager {
    std::unique_ptr<Resource> resource;
public:
    // スマートポインタとテンプレートコンストラクタ
    template <typename T>
    Manager(T* ptr) : resource(ptr) {
        std::cout << "Resource managed" << std::endl;
    }
};
int main() {
    Manager m(new Resource());
    return 0;
}

#include <iostream>

// コンパイル時にフィボナッチ数を計算するテンプレート
template <int N>
struct Fibonacci {
    static const int value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value;
};

// 基底ケース
template <>
struct Fibonacci<0> {
    static const int value = 0;
};

template <>
struct Fibonacci<1> {
    static const int value = 1;
};

// クラスの定義
template <int N>
class FibonacciPrinter {
   public:
    // テンプレートメタプログラミングを使用したコンストラクタ
    FibonacciPrinter() {
        std::cout << "Fibonacci(" << N << ") = " << Fibonacci<N>::value
                  << std::endl;
    }
};

int main() {
    FibonacciPrinter<10> fp; // フィボナッチ数の計算
    return 0;
}

#include <iostream>
#include <type_traits>
// クラスの定義
class Example {
public:
    // テンプレートコンストラクタ
    template <typename T>
    Example(T value) {
        static_assert(std::is_integral<T>::value, "Only integral types are allowed");
        std::cout << "Value: " << value << std::endl;
    }
};
int main() {
    Example e1(42);    // OK
    // Example e2(3.14); // Error: static_assert failed
    return 0;
}

#include <iostream>
// テンプレートの定義
template <typename T>
class Printer {
public:
    void print() {
        std::cout << "Generic printer" << std::endl;
    }
};
// 特化テンプレートの定義
template <>
class Printer<int> {
public:
    void print() {
        std::cout << "Integer printer" << std::endl;
    }
};
int main() {
    Printer<int> p1;
    p1.print();  // 出力: Integer printer
    Printer<double> p2;
    p2.print();  // 出力: Generic printer
    return 0;
}

#include <iostream>
#include <type_traits>
// クラスの定義
class Example {
public:
    // テンプレートコンストラクタ
    template <typename T>
    Example(T value) {
        static_assert(std::is_integral<T>::value, "Only integral types are allowed");
        std::cout << "Value: " << value << std::endl;
    }
};
int main() {
    Example e1(42);    // OK
    // Example e2(3.14); // Error: static_assert failed
    return 0;
}