[C++] テンプレートの型推論の仕組みと使い方

#include <iostream>
// 関数テンプレートの定義
template <typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}
int main() {
    int x = 10, y = 20;
    double a = 5.5, b = 2.3;
    // int型の比較
    std::cout << "Max of x and y: " << max(x, y) << std::endl;
    // double型の比較
    std::cout << "Max of a and b: " << max(a, b) << std::endl;
    return 0;
}

Max of x and y: 20
Max of a and b: 5.5

  #include <iostream>
  template <typename T>
  void printValue(T value) {
      std::cout << value << std::endl;
  }
  int main() {
      printValue(10);    // int型として推論
      printValue(3.14);  // double型として推論
      return 0;
  }

  auto x = 42;       // int型として推論
  auto y = 3.14;     // double型として推論
  auto z = "Hello";  // const char*型として推論

  auto add = [](auto a, auto b) { return a + b; };
  std::cout << add(1, 2) << std::endl;       // int型として推論
  std::cout << add(1.5, 2.5) << std::endl;   // double型として推論

template <typename T>
T add(T a, T b) {
    return a + b;
}

#include <iostream>
// 関数テンプレートの定義
template <typename T>
T multiply(T a, T b) {
    return a * b;
}
int main() {
    int x = 3, y = 4;
    double a = 2.5, b = 4.0;
    // int型の掛け算
    std::cout << "Product of x and y: " << multiply(x, y) << std::endl;
    // double型の掛け算
    std::cout << "Product of a and b: " << multiply(a, b) << std::endl;
    return 0;
}

Product of x and y: 12
Product of a and b: 10

template <typename T>
class Box {
public:
    Box(T value) : value_(value) {}
    T getValue() const { return value_; }
private:
    T value_;
};

#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(45.67);
    // int型のBox
    std::cout << "intBox contains: " << intBox.getValue() << std::endl;
    // double型のBox
    std::cout << "doubleBox contains: " << doubleBox.getValue() << std::endl;
    return 0;
}

intBox contains: 123
doubleBox contains: 45.67

#include <iostream>
// クラステンプレートの定義
template <typename T>
class Box {
public:
    Box(T value) : value_(value) {}
    T getValue() const { return value_; }
private:
    T value_;
};
// 特殊化されたクラステンプレート
template <>
class Box<std::string> {
public:
    Box(std::string value) : value_(value) {}
    std::string getValue() const { return "String: " + value_; }
private:
    std::string value_;
};
int main() {
    Box<int> intBox(123);
    Box<std::string> stringBox("Hello");
    // int型のBox
    std::cout << "intBox contains: " << intBox.getValue() << std::endl;
    // string型のBox(特殊化)
    std::cout << "stringBox contains: " << stringBox.getValue() << std::endl;
    return 0;
}

intBox contains: 123
stringBox contains: String: Hello

#include <iostream>
#include <memory>
class MyClass {
public:
    void display() const {
        std::cout << "MyClass instance" << std::endl;
    }
};
int main() {
    // 型推論を用いたunique_ptrの生成
    auto ptr = std::make_unique<MyClass>();
    ptr->display();
    return 0;
}

#include <iostream>
#include <vector>
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // 型推論を用いたイテレータの使用
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
    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;
};
int main() {
    // コンパイル時にフィボナッチ数列を計算
    std::cout << "Fibonacci<10>::value: " << Fibonacci<10>::value << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // 型推論を用いたループ
    for (auto number : numbers) {
        std::cout << number << " ";
    }
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
int main() {
    std::vector<int> data = {5, 3, 9, 1, 7};
    // 型推論を用いたソート
    std::sort(data.begin(), data.end());
    for (auto value : data) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    return 0;
}