C++中如何使用模板编程_模板编程基础与高级技巧

template <typename T>
T max(T a, T b) {
  return (a > b) ? a : b;
}

int main() {
  int x = 5, y = 10;
  std::cout << "Max of integers: " << max(x, y) << std::endl;

  double p = 3.14, q = 2.71;
  std::cout << "Max of doubles: " << max(p, q) << std::endl;

  return 0;
}

template <typename T>
class Vector {
private:
  T* data;
  int size;
  int capacity;

public:
  Vector(int capacity = 10) : size(0), capacity(capacity) {
    data = new T[capacity];
  }

  ~Vector() {
    delete[] data;
  }

  void push_back(T value) {
    if (size == capacity) {
      // 扩容
      capacity *= 2;
      T* newData = new T[capacity];
      for (int i = 0; i < size; ++i) {
        newData[i] = data[i];
      }
      delete[] data;
      data = newData;
    }
    data[size++] = value;
  }

  T& operator[](int index) {
    return data[index];
  }

  int getSize() const {
    return size;
  }
};

int main() {
  Vector<int> intVector;
  intVector.push_back(1);
  intVector.push_back(2);
  std::cout << "Element at index 0: " << intVector[0] << std::endl;

  Vector<std::string> stringVector;
  stringVector.push_back("Hello");
  stringVector.push_back("World");
  std::cout << "Element at index 1: " << stringVector[1] << std::endl;

  return 0;
}

template <typename T>
class Printer {
public:
  void print(T value) {
    std::cout << "Generic print: " << value << std::endl;
  }
};

// 针对char*的特化版本
template<>
class Printer<char*> {
public:
  void print(char* value) {
    std::cout << "Specialized print for char*: " << value << std::endl;
  }
};

int main() {
  Printer<int> intPrinter;
  intPrinter.print(123); // 输出：Generic print: 123

  Printer<char*> charPrinter;
  char* str = "Hello, world!";
  charPrinter.print(str); // 输出：Specialized print for char*: Hello, world!

  return 0;
}

#include <iostream>
#include <type_traits>

template <typename T>
struct has_method {
  template <typename U>
  static auto check(U* ptr) -> decltype(ptr->foo(), std::true_type{});

  template <typename U>
  static std::false_type check(...);

  static const bool value = std::is_same<decltype(check<T>(nullptr)), std::true_type>::value;
};

struct A {
  void foo() {}
};

struct B {};

int main() {
  std::cout << "A has method foo: " << has_method<A>::value << std::endl; // 输出：A has method foo: 1
  std::cout << "B has method foo: " << has_method<B>::value << std::endl; // 输出：B has method foo: 0
  return 0;
}

template <int N>
struct Factorial {
  static const int value = N * Factorial<N - 1>::value;
};

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

int main() {
  std::cout << "Factorial of 5: " << Factorial<5>::value << std::endl; // 输出：Factorial of 5: 120
  return 0;
}