c++如何使用模板函数和类_c++泛型编程之模板应用详解

冰火之心

发布时间：2025-09-18 09:10:02

472人浏览过

来源于php中文网

原创

C++模板通过类型参数实现泛型编程，支持模板函数和模板类，提升代码复用性；例如max_value函数可自动适配int或double类型，MyVector类能存储不同数据类型；还可通过模板特化处理char*等特殊类型，确保字符串正确复制与释放；结合SFINAE与enable_if可根据类型特性选择重载函数，实现编译期类型判断；模板元编程允许在编译期计算阶乘等值，优化性能；但需注意代码膨胀和复杂错误信息问题，应保持模板简洁并合理使用特化与静态断言。

c++如何使用模板函数和类_c++泛型编程之模板应用详解

C++模板函数和类，简单来说，就是一种“模具”，你可以用它来生产不同类型的函数或类，而不用为每种类型都写一份代码。这极大地提升了代码的复用性和效率，是C++泛型编程的核心。

使用模板，就像是给你的代码加了一个“类型参数”，这个参数在你真正使用函数或类的时候才会被确定。

解决方案

C++模板主要有两种：模板函数和模板类。

1. 模板函数

立即学习“C++免费学习笔记（深入）”；

模板函数允许你编写一个可以处理多种数据类型的函数，而无需为每种类型编写单独的函数。

template 
T max_value(T a, T b) {
  return (a > b) ? a : b;
}

int main() {
  int int_max = max_value(5, 10);
  double double_max = max_value(5.5, 10.2);
  std::cout << "Max int: " << int_max << std::endl;
  std::cout << "Max double: " << double_max << std::endl;
  return 0;
}

在这个例子中，

typename T

声明了一个类型参数

。当你调用

max_value(5, 10)

时，编译器会推断

是

int

类型，并生成一个

int

版本的

max_value

函数。同理，调用

max_value(5.5, 10.2)

会生成一个

double

版本的函数。

2. 模板类

模板类与模板函数类似，但它是针对类的。你可以创建一个通用的类，它可以处理不同类型的数据。

template 
class MyVector {
private:
  T* data;
  int size;
  int capacity;

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

  ~MyVector() {
    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 get(int index) const {
    if (index < 0 || index >= size) {
      throw std::out_of_range("Index out of range");
    }
    return data[index];
  }

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

int main() {
  MyVector intVector(10);
  intVector.push_back(5);
  intVector.push_back(10);
  std::cout << "Int Vector Size: " << intVector.getSize() << std::endl;
  std::cout << "Element at index 0: " << intVector.get(0) << std::endl;

  MyVector doubleVector(5);
  doubleVector.push_back(3.14);
  doubleVector.push_back(2.71);
  std::cout << "Double Vector Size: " << doubleVector.getSize() << std::endl;
  std::cout << "Element at index 1: " << doubleVector.get(1) << std::endl;

  return 0;
}

在这个例子中，

MyVector

是一个模板类，它可以存储任何类型的数据。

MyVector

创建了一个存储

int

类型的向量，而

MyVector

创建了一个存储

double

类型的向量。

快剪辑

国内⼀体化视频⽣产平台

下载

模板特化：解决特定类型的特殊需求

有时候，泛型模板并不能完美适用于所有类型。例如，对于

char*

类型，你可能需要提供一个特殊版本的

MyVector

，以便正确地处理字符串的复制和销毁。这就是模板特化的用武之地。

template <> // 注意这个空的模板参数列表
class MyVector {
private:
  char** data;
  int size;
  int capacity;

public:
  MyVector(int capacity) : capacity(capacity), size(0) {
    data = new char*[capacity];
  }

  ~MyVector() {
    for (int i = 0; i < size; ++i) {
      delete[] data[i]; // 释放每个字符串
    }
    delete[] data;
  }

  void push_back(char* value) {
    if (size == capacity) {
      capacity *= 2;
      char** newData = new char*[capacity];
      for (int i = 0; i < size; ++i) {
        newData[i] = data[i];
      }
      delete[] data;
      data = newData;
    }
    data[size++] = strdup(value); // 使用strdup复制字符串
  }

  char* get(int index) const {
    if (index < 0 || index >= size) {
      throw std::out_of_range("Index out of range");
    }
    return data[index];
  }

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

int main() {
  MyVector stringVector(5);
  stringVector.push_back("hello");
  stringVector.push_back("world");
  std::cout << "String Vector Size: " << stringVector.getSize() << std::endl;
  std::cout << "Element at index 0: " << stringVector.get(0) << std::endl;

  return 0;
}

在这个特化版本中，

MyVector

使用

strdup

来复制字符串，并在析构函数中释放每个字符串，以避免内存泄漏。

template <>

表示这是一个完全特化，针对

char*

类型。

模板元编程：在编译期进行计算

模板的强大之处不仅仅在于代码复用，还在于它允许你在编译期进行计算。这被称为模板元编程（Template Metaprogramming，TMP）。

template 
struct Factorial {
  static const int value = N * Factorial::value;
};

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

int main() {
  constexpr int result = Factorial<5>::value; // 编译期计算
  std::cout << "Factorial of 5: " << result << std::endl;
  return 0;
}

在这个例子中，

Factorial

模板在编译期计算阶乘。

constexpr

关键字确保

result

在编译时被计算出来。模板元编程可以用于各种编译期优化和代码生成。

SFINAE（Substitution Failure Is Not An Error）：优雅地处理类型不匹配

SFINAE 是一种C++特性，它允许编译器在模板参数替换失败时，不立即报错，而是尝试其他的模板重载。这为我们提供了在编译期根据类型特性选择不同代码路径的能力。

#include 
#include 

template 
typename std::enable_if::value, T>::type
process(T value) {
  std::cout << "Processing integral value: " << value << std::endl;
  return value * 2;
}

template 
typename std::enable_if::value, T>::type
process(T value) {
  std::cout << "Processing floating-point value: " << value << std::endl;
  return value * 1.5;
}

int main() {
  int intValue = 10;
  double doubleValue = 3.14;

  process(intValue);    // 输出: Processing integral value: 10
  process(doubleValue);  // 输出: Processing floating-point value: 3.14

  return 0;
}

在这个例子中，