42.模版类的作用

2026-01-23
2221 字 · 11 分钟
C++ 模板类 泛型编程 类模板 C++模板

🔬 模版类的作用

📋 总结

📖 内容概览 本文详细介绍C++模板类（类模板）的概念、作用、语法及使用方法，包括模板类与函数模板的区别、模板类成员函数的创建时机、模板类对象的传参方式等内容。通过丰富的代码示例和深入的原理分析，帮助读者理解模板类如何实现代码复用和泛型编程。 🎯 核心概念

🎯 1. 模板类的基本概念

模板类是C++泛型编程的核心特性之一，它允许创建一个通用的类，其成员变量和成员函数的类型可以是参数化的。

1.1 模板类的作用

  • 代码复用：编写一次模板，可用于多种数据类型
  • 泛型编程：实现与类型无关的通用算法和数据结构
  • 类型安全：在编译时进行类型检查，避免运行时错误
  • 减少冗余代码：避免为不同数据类型编写几乎相同的类

1.2 模板类的语法

template <class T1, class T2, ...>
class ClassName {
    // 类成员定义
};
  • template：声明模板的关键字
  • <class T1, class T2, ...>：模板参数列表，可以包含多个类型参数
  • class：类型参数的关键字，也可以使用typename
  • T1, T2, ...：类型参数名，用于表示通用类型

📌 2. 模板类与函数模板的区别

特性模板类函数模板
数据类型推导不支持，必须显式指定类型参数支持自动类型推导
默认模板参数支持支持（C++11及以上）
实例化方式ClassName<Type1, Type2> objFunctionName(arg1, arg2) 或显式实例化
成员函数创建调用时才创建编译时创建所有可能的实例

📌 3. 模板类的使用方法

3.1 模板类的定义

template <class nameType, class priceType>
class Car {
public:
    Car(nameType name, priceType price) {
        this->C_name = name;
        this->C_price = price;
    }


    void printCar();
    nameType C_name;
    priceType C_price;
};

3.2 模板类的实例化

// 显式指定模板参数类型 Car<string, int> p1(“宝马”, 100);

3.3 模板类成员函数的定义

  • 类内定义：直接在类模板内部定义
  • 类外定义：需要指定模板参数 // 类外定义模板类成员函数 void Car<nameType, priceType>::printCar() { cout << “车辆的名字：” << C_name << endl; cout << “车辆的价格：” << C_price << endl; }

📌 4. 模板类的默认参数

C++11支持为模板类的类型参数指定默认值：

template <class nameType, class priceType = int>
class Car {
    // 类定义
};
// 使用默认参数实例化
Car<string> car1("奔驰", 200);  // priceType默认为int

📌 5. 模板类成员函数的创建时机

模板类的成员函数只有在被调用时才会被创建，这是模板类的一个重要特性：

  • 未被调用的成员函数不会被编译
  • 只有在调用时才会检查成员函数的合法性
  • 允许为不同类型的模板参数提供不同的成员函数实现

📌 6. 模板类对象的传参方式

模板类对象作为函数参数有三种主要传递方式：

  1. 指定传入类型：直接指定模板类的具体类型
  2. 参数模板化：将模板类的类型参数作为函数模板参数
  3. 整个类模板化：将整个模板类作为函数模板参数 💻 代码示例

1. 模板类的基本使用

#include <iostream>
#include <string>
using namespace std;


// 模板类定义
template <class nameType, class priceType>
class Car {
public:
    Car(nameType name, priceType price) {
        this->C_name = name;
        this->C_price = price;
    }


    void printCar() {
        cout << "车辆的名字：" << C_name << endl;
        cout << "车辆的价格：" << C_price << endl;
    }


    nameType C_name;
    priceType C_price;
};
int main() {
    // 模板类实例化
    Car<string, int> p1("宝马", 100);
    p1.printCar();
    // 使用不同类型参数
    Car<string, double> p2("奔驰", 150.5);
    p2.printCar();
    return 0;
}

2. 模板类的默认参数

#include <iostream>
#include <string>
using namespace std;


// 带有默认参数的模板类
template <class nameType, class priceType = int>
class Car {
public:
    Car(nameType name, priceType price) {
        this->C_name = name;
        this->C_price = price;
    }


    void printCar() {
        cout << "车的名字是：" << C_name << endl;
        cout << "车的价格是：" << C_price << endl;
    }


    nameType C_name;
    priceType C_price;
};


int main() {
    // 使用显式类型参数
    Car<string, int> car1("宝马", 100);
    car1.printCar();


    // 使用默认类型参数
    Car<string> car2("奔驰", 200);  // priceType默认为int
    car2.printCar();


    return 0;
}

3. 模板类成员函数的创建时机

#include <iostream>
using namespace std;


class Car1 {
public:
    void printCar1() {
        cout << "Car1调用" << endl;
    }
};


class Car2 {
public:
    void printCar2() {
        cout << "Car2调用" << endl;
    }
};


// 模板类
template <class T>
class Car {
public:
    T m_car;


    void fun01() {
        m_car.printCar1();  // 调用Car1的成员函数
    }


    void fun02() {
        m_car.printCar2();  // 调用Car2的成员函数
    }
};


int main() {
    // 实例化Car<Car1>
    Car<Car1> car1;
    car1.fun01();  // 合法，调用Car1::printCar1()
    // car1.fun02();  // 编译错误，Car1没有printCar2()方法


    // 实例化Car<Car2>
    Car<Car2> car2;
    // car2.fun01();  // 编译错误，Car2没有printCar1()方法
    car2.fun02();  // 合法，调用Car2::printCar2()


    return 0;
}

4. 模板类对象的三种传参方式

#include <iostream>
#include <string>
using namespace std;


// 模板类定义
template <class nameType, class priceType = int>
class Car {
public:
    Car(nameType name, priceType price) {
        this->C_name = name;
        this->C_price = price;
    }


    void printCar() {
        cout << "车辆的名字：" << C_name << endl;
        cout << "车辆的价格：" << C_price << endl;
    }


    nameType C_name;
    priceType C_price;
};


// 方式1：指定传入类型
void showCar1(Car<string, int>& p) {
    p.printCar();
}


// 方式2：参数模板化
template <class T1, class T2>
void showCar2(Car<T1, T2>& p) {
    p.printCar();
}


// 方式3：整个类模板化
template <class T>
void showCar3(T& p) {
    p.printCar();
}


int main() {
    Car<string, int> car1("宝马", 100);
    Car<string, double> car2("奔驰", 200.5);
    Car<string, int> car3("奥迪", 300);


    // 使用方式1
    cout << "=== 方式1：指定传入类型 ===" << endl;
    showCar1(car1);


    // 使用方式2
    cout << "\n=== 方式2：参数模板化 ===" << endl;
    showCar2(car2);


    // 使用方式3
    cout << "\n=== 方式3：整个类模板化 ===" << endl;
    showCar3(car3);


    return 0;
}

⚠️ 注意事项

  1. 模板类的实例化：模板类必须显式指定类型参数，不能像函数模板那样自动推导
  2. 模板类的成员函数：只有在被调用时才会被创建，未调用的成员函数不会被编译
  3. 模板类的头文件：模板类的声明和定义通常放在同一个头文件中，因为模板实例化需要完整的定义
  4. 模板类的继承：模板类可以继承普通类，普通类也可以继承模板类，模板类之间也可以相互继承
  5. 模板类的特化：可以为特定类型提供模板类的特化实现，以优化性能或处理特殊情况
  6. 模板类的编译错误：模板类的错误通常在实例化时才会被发现，而不是在定义时 📚 总结与最佳实践

1. 模板类的核心优势

  • 代码复用：编写一次模板，可用于多种数据类型
  • 类型安全：编译时进行类型检查，避免运行时错误
  • 高性能：生成的代码与直接编写的类型特定代码性能相同
  • 灵活性：支持多种类型参数和默认参数

2. 模板类的使用场景

  • 通用数据结构：如vector、list、map等STL容器
  • 通用算法：如排序、查找等与类型无关的算法
  • 适配器类：将一种接口转换为另一种接口
  • 策略模式实现：通过模板参数实现策略的动态切换

3. 最佳实践

  1. 合理设计模板参数：只使用必要的模板参数，避免过度泛化
  2. 提供默认模板参数：简化模板类的使用，提高代码可读性
  3. 模板类定义放在头文件：确保模板实例化时能访问完整的定义
  4. 使用typename关键字：在模板中表示类型时，优先使用typename而非class
  5. 考虑模板特化：为特殊类型提供优化的特化实现
  6. 避免模板嵌套过深：过度嵌套会降低代码可读性和编译速度
  7. 使用概念（C++20）：限制模板参数的类型，提高代码安全性和可读性

4. 常见误区

  • 模板类会增加编译时间：模板实例化会增加编译时间，但不会影响运行时间
  • 模板类会生成冗余代码：编译器会优化重复的实例化代码
  • 模板类只能用于基本数据类型：模板类可以用于任何数据类型，包括自定义类型
  • 模板类的错误难以调试：使用现代IDE和编译器，模板错误信息已经得到很大改善 通过合理使用模板类，可以实现高效、类型安全的泛型编程，大大提高代码的复用性和可维护性。模板类是C++中实现泛型编程的核心工具，掌握模板类的使用是成为优秀C++程序员的重要一步。
Thanks for reading!

42.模版类的作用

2026-01-23
2221 字 · 11 分钟
C++ 模板类 泛型编程 类模板 C++模板
© Gxy | CC BY-NC-SA 4.0
打赏作者
已复制链接
41.move函数
43.模版和泛型的区别

评论区

分享你的想法，与大家交流讨论

目录