模板在C++中怎样使用 函数模板与类模板编写指南

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

template <typename T>

T

max

T

int main() {
  int x = 5, y = 10;
  std::cout << "Max of " << x << " and " << y << " is " << max(x, y) << std::endl; // T 被推导为 int

  double a = 5.5, b = 10.5;
  std::cout << "Max of " << a << " and " << b << " is " << max(a, b) << std::endl; // T 被推导为 double

  // 显式指定模板参数
  std::cout << "Max of " << x << " and " << b << " is " << max<double>(x, b) << std::endl; // T 被显式指定为 double，x 会被转换为 double
  return 0;
}

T

max<double>(x, b)

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

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

  ~Vector() {
    delete[] data;
  }

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

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

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

template <typename T>

T

Vector

Vector

T

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

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

  return 0;
}

Vector<int>

Vector<std::string>

template <typename T>
void Vector<T>::push_back(T value) {
  // ... 实现 ...
}

template <typename T>

template <>
const char* max(const char* a, const char* b) {
  return (std::strcmp(a, b) > 0) ? a : b;
}

const char*

max

std::strcmp

template <>
class Vector<bool> {
private:
  unsigned int* data; // 使用位来存储 bool 值，节省空间
  int size;
  int capacity;

public:
  Vector(int capacity) : size(0), capacity((capacity + 31) / 32) {
    data = new unsigned int[capacity];
    for (int i = 0; i < capacity; ++i) {
      data[i] = 0; // 初始化所有位为 0
    }
  }

  ~Vector() {
    delete[] data;
  }

  void push_back(bool value) {
    if (size == capacity * 32) {
      // 扩容操作 (简化)
      unsigned int* newData = new unsigned int[(capacity * 2 + 31) / 32];
      for (int i = 0; i < capacity * 2; ++i) {
        newData[i] = 0; // 初始化所有位为 0
      }

      for (int i = 0; i < capacity; ++i) {
          newData[i] = data[i];
      }
      delete[] data;
      data = newData;
      capacity *= 2;
    }

    int index = size / 32;
    int bit = size % 32;

    if (value) {
      data[index] |= (1U << bit); // 设置相应的位
    } else {
      data[index] &= ~(1U << bit); // 清除相应的位
    }
    size++;
  }

  bool operator[](int index) const {
    int i = index / 32;
    int bit = index % 32;
    return (data[i] >> bit) & 1;
  }

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

bool

Vector

bool

template <typename T, typename U>
class MyClass {
  // 通用版本
};

template <typename U>
class MyClass<int, U> {
  // 针对 T = int 的偏特化版本
};

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() {
  constexpr int result = Factorial<5>::value; // 编译时计算 5!
  std::cout << "Factorial of 5 is " << result << std::endl; // 输出 120
  return 0;
}

Factorial

N

Factorial<5>::value

template <typename T>
struct is_int {
  static const bool value = false;
};

template <>
struct is_int<int> {
  static const bool value = true;
};

template <typename T>
void process(T value) {
  if constexpr (is_int<T>::value) {
    std::cout << "Processing an integer: " << value << std::endl;
  } else {
    std::cout << "Processing a non-integer value." << std::endl;
  }
}

int main() {
  process(5);   // 输出 "Processing an integer: 5"
  process(5.5); // 输出 "Processing a non-integer value."
  return 0;
}

is_int

int

if constexpr

is_int<T>::value

constexpr

if constexpr