C++【模板初阶】

钟灵9212026-06-06 8:38

这里写目录标题

  • [一. 泛型编程](#一. 泛型编程)
  • [二. 函数模板](#二. 函数模板)
    • [2.1 函数模板的概念](#2.1 函数模板的概念)
    • [2.2 函数模板的格式](#2.2 函数模板的格式)
    • [2.3 函数模板的原理](#2.3 函数模板的原理)
    • [2.4 函数模板的实例化](#2.4 函数模板的实例化)
      • [2.4.1 隐式实例化](#2.4.1 隐式实例化)
      • [2.4.2 显式实例化](#2.4.2 显式实例化)
    • [2.5 函数模板的匹配原则](#2.5 函数模板的匹配原则)
  • [三. 类模板](#三. 类模板)
    • [3.1 类模板的定义格式](#3.1 类模板的定义格式)
    • [3.2 类模板的实例化](#3.2 类模板的实例化)
    • [3.3 在类模板外部定义成员函数](#3.3 在类模板外部定义成员函数)

一. 泛型编程

之前面对不同参数类型的交换函数时我们通常利用函数重载，如下：

javascript 复制代码 
void Swap(int& left, int& right)
{
  int temp = left;
  left = right;
  right = temp;
}
void Swap(double& left, double& right)
{
  double temp = left;
  left = right;
  right = temp;
}
void Swap(char& left, char& right)
{
  char temp = left;
  left = right;
  right = temp;
}

使用函数重载虽然可以实现，但是有几个不好的地方：

  1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
  2. 代码的可维护性比较低，一个出错可能所有的重载均出错

那能否告诉编译器一个模板，让编译器根据不同的类型利用该模板来生成代码呢？

我们下面就来看看c++是如何解决的。

1.1模板的概念

泛型编程的概念是：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。C++ 模板是一种强大的泛型编程工具，它通过在编译时进行代码参数化，允许开发者编写与具体数据类型无关的、可复用的函数或类，从而实现类型安全、高效率的代码复用。

模板就像一个"饼干模具"。模具本身（模板代码）是固定形状的。你可以用面粉（int）来压出饼干，也可以用巧克力（string）来压出饼干。模具是同一个，但产出的饼干（生成的 Stack或 Stack类）是不同类型的具体实物

1.2 模板的优点

(1).复用性：模板允许你在不同的类型上使用相同的代码，而无需重复编写类似的代码。

(2).可读性：模板代码具有更高的抽象性，使得代码更易于理解和维护。

(3).类型安全：模板可以在编译时进行类型检查，避免运行时的类型错误。

二. 函数模板

2.1 函数模板的概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.2 函数模板的格式

template<typename T1, typename T2,...,typename Tn>

返回值类型 函数名(参数列表){}

javascript 复制代码 
template<class T>
T Add(const T& left, const T& right)
{
  return left + right;
}

template<class T1, class T2>
T1 Add(const T1& left, const T2& right)
{
  return left + right;
}

template<class T>
T* func1(int n)
{
	return new T[n];
}

eg：T是占位的，既可以表示参数类型，返回值类型，也可以放在函数体内（比如可以在函数体内定义一个局部变量 T tmp;，或者像 new Tn这样在函数体内使用 T来创建对象.)。

注意： typename是用来定义模板参数的关键字，也可以使用class

2.3 函数模板的原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

2.4 函数模板的实例化

用不同类型的参数使用函数模板时 ，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

2.4.1 隐式实例化

  1. 隐式实例化：让编译器根据实参推演模板参数的实际类型
javascript 复制代码 
#include<iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 3, a2 = 5;
	double d1 = 10.1, d2 = 12.2;
	cout << Add(a1, a2) << endl; //将模板参数T推演为int类型
	cout << Add(d1, d2) << endl; //将模板参数T推演为double类型

	return 0;
}

如果传入的参数是不同类型时呢？

javascript 复制代码 
#include <iostream>

template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}

int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    
    // 正常调用，T会被推导为int
    int result1 = Add(a1, a2);
    std::cout << "Add(a1, a2) = " << result1 << std::endl;
    
    // 正常调用，T会被推导为double
    double result2 = Add(d1, d2);
    std::cout << "Add(d1, d2) = " << result2 << std::endl;
    
    /*
     * 以下语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
     * 通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有
     * 一个T，编译器无法确定此处到底该将T确定为int还是double类型，因此会报错
     * Add(a1, d1);
     */
     
    // 注意：在模板中，编译器一般不会进行隐式类型转换操作
    // 此时有两种处理方式：
    
    // 1. 用户自己来强制转换
    int result3 = Add(a1, (int)d1);
    std::cout << "Add(a1, (int)d1) = " << result3 << std::endl;
    
    // 2. 使用显式实例化
    int result4 = Add<int>(a1, d1);  // 指定T为int，d1会被隐式转换为int
    std::cout << "Add<int>(a1, d1) = " << result4 << std::endl;
    
    // 也可以显式指定为double
    double result5 = Add<double>(a1, d1);  // a1会被隐式转换为double
    std::cout << "Add<double>(a1, d1) = " << result5 << std::endl;
    
    return 0;
}

2.4.2 显式实例化

  1. 显式实例化：在函数名后的<>中指定模板参数的实际类型
javascript 复制代码 
#include<iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 3, a2 = 5;
	double d1 = 10.1, d2 = 12.2;
	//显式实例化
	cout << Add<int>(a1, d1) << endl;
	cout << Add<int>(d1, d2) << endl;
	cout << Add<double>(a2, d2) << endl;
	cout << Add<double>(a1, a2) << endl;

	return 0;
}

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功则编译器就会报错。

2.5 函数模板的匹配原则

  1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
javascript 复制代码 
// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
  return left + right;
}
void Test()
{
   Add(1, 2);// 与非模板函数匹配，编译器不需要特化
   Add<int>(1, 2);  // 调用编译器特化的Add版本
}
  1. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
javascript 复制代码 
#include<iostream>
using namespace std;
// 专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}
//通过加法函数
template<class T1,class T2>
T1 Add(T1 left, T2 right)
{
	return left + right;
}
int main()
{
	Add(1, 2); //与非函数模板类型完全匹配，不需要函数模板实例化
	Add(1, 2.0); //模板函数可以生成更加匹配的版本，编译器根据实参类型生成更加匹配的Add函数

	return 0;
}
  1. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
javascript 复制代码
  1. 函数模板中的每一个类型参数在函数参数列表中必须至少使用一次。

    如图没有使用T2，就会报错。
  2. 模板参数名在同一模板参数列表中只能使用一次，但可在多个不同函数模板的定义或声明中重复使用
javascript 复制代码 
template<class T,class T> //错误，在同一函数模板中重复定义模板参数
javascript 复制代码 
#include<iostream>
using namespace std;
template<class T>
void Test1(T t)
{
	cout << t << endl;
}

template<class T> //在不同函数模板中可以使用相同的模板参数名
void Test2(T t)
{
	cout << t << endl;
}
int main()
{
	Test1(3);
	Test2(5);
	return 0;
}
  1. 模板的声明和定义所使用的模板参数名可以不相同。
javascript 复制代码 
#include<iostream>
using namespace std;
//函数模板的声明
template<class T>
void Test(T t); 

//函数模板的定义
template<class U>
void Test(U t) 
{
	cout << t << endl;
}
int main()
{
	Test(10);
	return 0;
}
  1. 函数模板如果有多个模板参数，则每个模板参数前都必须使用关键字typename或class修饰

三. 类模板

3.1 类模板的定义格式

javascript 复制代码 
template<class T1, class T2, ..., class Tn> 
class 类模板名
{
// 类内成员定义
};
javascript 复制代码 
#include<iostream>
using namespace std;
// 类模版
template<typename T>
class Stack
{
public:
Stack(size_t capacity = 4)
{
  _array = new T[capacity];
  _capacity = capacity;
  _size = 0;
}
void Push(const T& data);
private:
 T* _array;
 size_t _capacity;
 size_t _size;
};
// 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误，具体原因后面会讲
template<class T>
void Stack<T>::Push(const T& data)
{
  // 扩容
  _array[_size] = data;
  ++_size;
}
int main()
{
  Stack<int> st1;    
  // int
  Stack<double> st2; // double
  return 0;
}

3.2 类模板的实例化

javascript 复制代码 
#include<iostream>
using namespace std;
template<class T>
class A {
public:
	T a; //成员变量
	T b; //成员变量
	T Add(T a, T b)
	{
		return a + b;
	}
};
int main()
{
	A<int> a;

	a.Add(1, 1.2); 
	//此处不报错，因为在创建对象a时已经指定T是int类型，
	//当Add()函数模板实例化时也会实例化出一个int类型的函数，它会自动将double类型的1.2转换为int类型的1。

	return 0;
}

1.当类模板有两个模板形参时，实例化类模板时，类型之间要用逗号分隔开。

javascript 复制代码 
#include<iostream>
using namespace std;
template<class T1,class T2>
class A {
public:
	T1 a; //成员变量
	T2 b; //成员变量
	T1 Add(T1 a, T2 b)
	{
		return a + b;
	}
};
int main()
{
	A<int, int> a; //创建模板类的一个对象a
	A<int, double> b; //创建模板类的一个对象b
	return 0;
}

2.使用new操作符创建对象的方式实例化。

javascript 复制代码 
A<int, int>* a = new A<int, int>;
A<int, double>* b = new A<int, double>;

A<int, int>* a = new A<int, int>;
实例化了一个 A类模板，两个模板参数都是 int类型
在堆上动态分配内存，创建对象
用指针 a指向这个对象

3.模板的声明或定义只能在全局、命名空间或类范围内进行，不能在局部、函数 范围内进行，比如不能在main()函数中声明或定义一个模板。

javascript 复制代码 
int main() {
    // 错误：不能在函数内部定义模板
    template<typename T>
    class LocalTemplate {  // 编译错误！
        T data;
    };
    
    return 0;
}



void someFunction() {
    // 错误：不能在函数内部定义模板函数
    template<typename T>
    T add(T a, T b) {  // 编译错误！
        return a + b;
    }
}

3.3 在类模板外部定义成员函数

类中的成员函数既可以在类中定义，也可以在类外定义。类模板中的成员函数同样 可以在类模板内定义，也可以在类模板外定义，只是在类外定义成员函数时需要带上模板头：template<模板参数表>。

javascript 复制代码 
// 类模板声明
template<typename T>
class MyClass {
private:
    T data;
public:
    MyClass(T value);           // 构造函数声明
    void setData(T value);      // 成员函数声明
    T getData() const;         // 成员函数声明
};

// 在类外定义构造函数
template<typename T>
MyClass<T>::MyClass(T value) : data(value) {}

// 在类外定义成员函数 setData
template<typename T>
void MyClass<T>::setData(T value) {
    data = value;
}

// 在类外定义成员函数 getData
template<typename T>
T MyClass<T>::getData() const {
    return data;
}

常见错误实例：

javascript 复制代码 
template<typename T>
class MyClass {
public:
    void method();
};

// 错误：缺少 template<typename T>
void MyClass<T>::method() {  // 编译错误
    // ...
}




template<typename T>
class MyClass {
public:
    void method();
};

// 错误：作用域指定不正确
template<typename T>
void MyClass::method() {  // 编译错误，缺少<T>
    // ...
}

注意：类模板在实例化时，带有模板形参的成员函数并不随着自动被实例化，只有当它被调用或取地址时，才被实例化。

javascript 复制代码 
#include <iostream>
using namespace std;

template<typename T>
class MyClass {
private:
    T data;
public:
    MyClass(T d) : data(d) {}
    
    void method1() {  // 会被实例化
        cout << "Method1: " << data << endl;
    }
    
    void method2() {  // 不会实例化（如果没有被调用）
        cout << "Method2: " << data + 100 << endl;
    }
    
    void method3() {  // 即使有错误，只要不调用就不会报错
        T* ptr = 123;  // 错误的赋值，但如果不调用就不会被发现
        *ptr = data;
    }
    
    void method4(T x) {  // 依赖模板参数的语法检查
        x.someMethod();  // 如果T没有someMethod()，这里会出错
                         // 但只在调用method4时才会检查
    }
};
相关推荐
码不停蹄的玄黓1 小时前
旁路缓存（Cache-Aside，CA）
java·开发语言
江屿风1 小时前
【C++笔记】vector流食般投喂
开发语言·c++·笔记
星恒随风1 小时前
Python 基础语法详解(3):顺序语句、条件语句和循环语句一篇讲清楚
开发语言·笔记·python·学习
CHHH_HHH1 小时前
【C++】红黑树：比AVL树更实用的平衡二叉搜索树
开发语言·数据结构·c++·算法·stl
牛油果子哥q1 小时前
【C++内存对齐与结构体填充】C++内存对齐与结构体填充深度精讲：对齐规则、结构体内存大小计算、填充冗余、笔试真题与工程优化方案
开发语言·c++
数智工坊1 小时前
周志华《Machine Learning》学习笔记--第九章--聚类
笔记·学习·机器学习
ch.ju1 小时前
Java程序设计(第3版)第四章——set-get方法
java·开发语言
Lazionr1 小时前
基础算法 | 模拟算法练习
c++·算法
智能制造产品经理代码提升1 小时前
快速搭建PayPal标准API测试框架
开发语言·lua
热门推荐
01GitHub 镜像站点022026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf03【AI】2026 年具身智能模型和世界模型总结04Codex 下载安装指南：Windows 和 macOS 官方版下载05Codex 桌面端更新后 Chrome 插件和 Computer Use 不可用，怎么排查和修复06【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法07CC-Switch 下载、安装与使用配置指南【2026.5.29】08Codex 接入 DeepSeek API 完整配置文档09CC-Switch & Claude 基于 Linux 服务器安装使用指南10裂开！ChatGPT 居然开始要手机号验证，附详细解决方法