【C++ Primer】第十六章：模板与泛型编程

最新推荐文章于 2026-01-09 13:11:39 发布
原创 最新推荐文章于 2026-01-09 13:11:39 发布 · 276 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

模板与泛型编程是 C++ 最强大和现代的特性之一，它让你能够编写类型安全且高效的通用代码。

1. 函数模板

基本函数模板

// 模板声明
template<typename T>
int compare(const T& v1, const T& v2) {
    if (v1 < v2) return -1;
    if (v2 < v1) return 1;
    return 0;
}

// 使用类型推导
void function_template_demo() {
    std::cout << compare(1, 2) << std::endl;        // T = int
    std::cout << compare(3.14, 2.71) << std::endl;  // T = double
    std::cout << compare("hello", "world") << std::endl; // T = const char*
    
    // 显式指定模板参数
    std::cout << compare<double>(1, 3.14) << std::endl; // T = double
}

非类型模板参数

// 非类型模板参数
template<typename T, std::size_t N>
void print_array(const T (&arr)[N]) {
    for (std::size_t i = 0; i < N; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

template<int Value>
class FixedValue {
public:
    int get() const { return Value; }
};

void nontype_template_demo() {
    int arr[] = {1, 2, 3, 4, 5};
    print_array(arr);  // T = int, N = 5
    
    FixedValue<42> fv;
    std::cout << fv.get() << std::endl;  // 输出 42
}

2. 类模板

基本的类模板

// 类模板声明
template<typename T>
class Stack {
private:
    std::vector<T> elements;
    
public:
    // 模板类的成员函数可以在类内定义
    void push(const T& value) {
        elements.push_back(value);
    }
    
    void push(T&& value) {
        elements.push_back(std::move(value));
    }
    
    T pop() {
        if (elements.empty()) {
            throw std::out_of_range("Stack<>::pop(): empty stack");
        }
        T value = std::move(elements.back());
        elements.pop_back();
        return value;
    }
    
    const T& top() const {
        if (elements.empty()) {
            throw std::out_of_range("Stack<>::top(): empty stack");
        }
        return elements.back();
    }
    
    bool empty() const {
        return elements.empty();
    }
    
    std::size_t size() const {
        return elements.size();
    }
};

// 类外定义成员函数
template<typename T>
void Stack<T>::clear() {
    elements.clear();
}

void class_template_demo() {
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    intStack.push(3);
    
    std::cout << "Top: " << intStack.top() << std::endl;
    std::cout << "Size: " << intStack.size() << std::endl;
    
    while (!intStack.empty()) {
        std::cout << intStack.pop() << " ";
    }
    std::cout << std::endl;
}

模板友元

template<typename T>
class Box {
private:
    T value;
    
public:
    Box(const T& v) : value(v) {}
    
    // 声明友元函数模板
    template<typename U>
    friend std::ostream& operator<<(std::ostream& os, const Box<U>& box);
};

// 定义友元函数模板
template<typename U>
std::ostream& operator<<(std::ostream& os, const Box<U>& box) {
    return os << "Box(" << box.value << ")";
}

3. 模板特化和偏特化

完全特化

// 主模板
template<typename T>
class TypeInfo {
public:
    static std::string name() {
        return "unknown";
    }
};

// 完全特化
template<>
class TypeInfo<int> {
public:
    static std::string name() {
        return "int";
    }
};

template<>
class TypeInfo<double> {
public:
    static std::string name() {
        return "double";
    }
};

template<>
class TypeInfo<std::string> {
public:
    static std::string name() {
        return "std::string";
    }
};

偏特化（部分特化）

// 主模板
template<typename T, typename U>
class Pair {
public:
    static std::string name() {
        return "Pair<T, U>";
    }
};

// 偏特化：两个类型相同
template<typename T>
class Pair<T, T> {
public:
    static std::string name() {
        return "Pair<T, T>";
    }
};

// 偏特化：第二个类型为 int
template<typename T>
class Pair<T, int> {
public:
    static std::string name() {
        return "Pair<T, int>";
    }
};

// 偏特化：指针类型
template<typename T, typename U>
class Pair<T*, U*> {
public:
    static std::string name() {
        return "Pair<T*, U*>";
    }
};

void specialization_demo() {
    std::cout << TypeInfo<int>::name() << std::endl;           // int
    std::cout << TypeInfo<double>::name() << std::endl;        // double
    std::cout << TypeInfo<std::string>::name() << std::endl;   // std::string
    
    std::cout << Pair<int, double>::name() << std::endl;       // Pair<T, U>
    std::cout << Pair<int, int>::name() << std::endl;          // Pair<T, T>
    std::cout << Pair<double, int>::name() << std::endl;       // Pair<T, int>
    std::cout << Pair<int*, double*>::name() << std::endl;     // Pair<T*, U*>
}

4. 模板元编程

编译时计算

// 编译时阶乘计算
template<unsigned n>
struct Factorial {
    static constexpr unsigned value = n * Factorial<n - 1>::value;
};

// 基况特化
template<>
struct Factorial<0> {
    static constexpr unsigned value = 1;
};

// 编译时判断类型是否相同
template<typename T, typename U>
struct IsSame {
    static constexpr bool value = false;
};

template<typename T>
struct IsSame<T, T> {
    static constexpr bool value = true;
};

void template_metaprogramming_demo() {
    std::cout << "Factorial<5>::value = " << Factorial<5>::value << std::endl; // 120
    std::cout << "Factorial<10>::value = " << Factorial<10>::value << std::endl; // 3628800
    
    std::cout << std::boolalpha;
    std::cout << "IsSame<int, int>::value = " << IsSame<int, int>::value << std::endl; // true
    std::cout << "IsSame<int, double>::value = " << IsSame<int, double>::value << std::endl; // false
}

类型特征（Type Traits）

#include <type_traits>

// 自定义类型特征
template<typename T>
struct IsPointer {
    static constexpr bool value = false;
};

template<typename T>
struct IsPointer<T*> {
    static constexpr bool value = true;
};

template<typename T>
void process(const T& value) {
    if constexpr (IsPointer<T>::value) {
        std::cout << "Pointer: " << *value << std::endl;
    } else {
        std::cout << "Value: " << value << std::endl;
    }
}

void type_traits_demo() {
    int x = 42;
    int* ptr = &x;
    
    process(x);    // Value: 42
    process(ptr);  // Pointer: 42
    
    // 标准库类型特征
    std::cout << "is_integral<int>: " << std::is_integral<int>::value << std::endl;
    std::cout << "is_floating_point<double>: " << std::is_floating_point<double>::value << std::endl;
    std::cout << "is_pointer<int*>: " << std::is_pointer<int*>::value << std::endl;
}

5. 可变参数模板

参数包和递归展开

// 基况函数
void print() {
    std::cout << std::endl;
}

// 可变参数模板函数
template<typename T, typename... Args>
void print(T first, Args... args) {
    std::cout << first;
    if constexpr (sizeof...(args) > 0) {
        std::cout << ", ";
    }
    print(args...);  // 递归调用
}

// 使用折叠表达式（C++17）
template<typename... Args>
void print_fold(Args... args) {
    ((std::cout << args << ", "), ...) << std::endl;
}

// 计算参数包大小
template<typename... Args>
constexpr std::size_t count_args(Args... args) {
    return sizeof...(args);
}

void variadic_template_demo() {
    print(1, 2.5, "hello", 'a');  // 1, 2.5, hello, a
    print_fold(1, 2.5, "hello", 'a');  // 1, 2.5, hello, a,
    
    std::cout << "count_args(1, 2, 3): " << count_args(1, 2, 3) << std::endl; // 3
    std::cout << "count_args(): " << count_args() << std::endl; // 0
}

完美转发

// 工厂函数模板
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

class Widget {
private:
    std::string name;
    int value;
    
public:
    Widget(const std::string& n, int v) : name(n), value(v) {
        std::cout << "Widget constructed: " << name << ", " << value << std::endl;
    }
    
    Widget(std::string&& n, int v) : name(std::move(n)), value(v) {
        std::cout << "Widget move constructed: " << name << ", " << value << std::endl;
    }
};

void perfect_forwarding_demo() {
    std::string name = "test";
    
    // 完美转发：保持值类别
    auto w1 = make_unique<Widget>(name, 42);           // 拷贝 name
    auto w2 = make_unique<Widget>(std::move(name), 42); // 移动 name
    auto w3 = make_unique<Widget>("temporary", 42);    // 使用临时对象
}

6. 模板高级特性

SFINAE（替换失败不是错误）

// SFINAE：根据类型是否有特定成员函数选择不同实现
template<typename T>
class HasSize {
private:
    template<typename U>
    static auto test(int) -> decltype(std::declval<U>().size(), std::true_type{});
    
    template<typename U>
    static std::false_type test(...);
    
public:
    static constexpr bool value = decltype(test<T>(0))::value;
};

template<typename Container>
typename std::enable_if<HasSize<Container>::value, std::size_t>::type
get_size(const Container& c) {
    return c.size();  // 如果容器有 size() 成员函数
}

template<typename Container>
typename std::enable_if<!HasSize<Container>::value, std::size_t>::type
get_size(const Container& c) {
    return 0;  // 默认实现
}

void sfinae_demo() {
    std::vector<int> vec = {1, 2, 3};
    std::cout << "vector size: " << get_size(vec) << std::endl;  // 3
    
    int arr[] = {1, 2, 3};
    std::cout << "array size: " << get_size(arr) << std::endl;   // 0
}

概念（C++20）

#ifdef __cpp_concepts
// C++20 概念
template<typename T>
concept Arithmetic = std::is_arithmetic_v<T>;

template<typename T>
concept HasArea = requires(T t) {
    t.area();
};

template<Arithmetic T>
T square(const T& x) {
    return x * x;
}

template<HasArea T>
void print_area(const T& shape) {
    std::cout << "Area: " << shape.area() << std::endl;
}

class Circle {
public:
    double area() const { return 3.14159 * radius * radius; }
    double radius = 1.0;
};

void concepts_demo() {
    std::cout << square(5) << std::endl;      // 25
    std::cout << square(3.14) << std::endl;   // 9.8596
    // square("hello");  // 错误：不满足 Arithmetic 概念
    
    Circle c;
    print_area(c);  // Area: 3.14159
}
#endif

7. 实践项目：智能指针模板

template<typename T>
class UniquePtr {
private:
    T* ptr;
    
public:
    // 构造函数
    explicit UniquePtr(T* p = nullptr) : ptr(p) {}
    
    // 禁止拷贝
    UniquePtr(const UniquePtr&) = delete;
    UniquePtr& operator=(const UniquePtr&) = delete;
    
    // 移动语义
    UniquePtr(UniquePtr&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }
    
    UniquePtr& operator=(UniquePtr&& other) noexcept {
        if (this != &other) {
            delete ptr;
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }
    
    // 析构函数
    ~UniquePtr() {
        delete ptr;
    }
    
    // 操作符重载
    T& operator*() const { return *ptr; }
    T* operator->() const { return ptr; }
    explicit operator bool() const { return ptr != nullptr; }
    
    // 资源管理
    T* release() {
        T* temp = ptr;
        ptr = nullptr;
        return temp;
    }
    
    void reset(T* p = nullptr) {
        delete ptr;
        ptr = p;
    }
    
    T* get() const { return ptr; }
};

// 特化版本用于数组
template<typename T>
class UniquePtr<T[]> {
private:
    T* ptr;
    
public:
    explicit UniquePtr(T* p = nullptr) : ptr(p) {}
    
    ~UniquePtr() {
        delete[] ptr;
    }
    
    // 禁止拷贝，允许移动（与上面类似）
    // ...
    
    T& operator[](std::size_t index) const {
        return ptr[index];
    }
};

最佳实践总结

  1. 使用 typename 和 class 声明类型参数（两者等价）
  2. 模板定义通常放在头文件中
  3. 使用 SFINAE 或概念进行约束
  4. 优先使用可变参数模板而不是函数重载
  5. 理解模板实例化的时机和成本
  6. 使用特化提供特定类型的优化实现

调试技巧

// 在模板中添加静态断言进行编译时检查
template<typename T>
void process(const T& value) {
    static_assert(std::is_arithmetic_v<T>, 
                  "T must be an arithmetic type");
    // ...
}
C++ Primer(第五版)|练习题答案与解析(第十六章:模板与泛型编程)
qq_24739717的博客
03-04 1506
C++ Primer(第五版)|练习题答案与解析(第十六章:模板与泛型编程) 本博客主要记录C++ Primer(第五版)中的练习题答案与解析。 参考:C++Primer C++ Primer 练习题16.1 给出实例化定义 P579，当调用一个函数模板时，编译器会使用实参的类型来确定绑定到模版参数T上的类型。之后编译器利用推断出的模版参数来实例化一个特定版本的函数，这个过程被称之为实例化。 ...
C++Primer第五版 习题答案 第十六章 模板与泛型编程（Templates and Generic Programming）
shamozhizhoutx的博客
05-24 3554
练习16.1 给出实例化的定义。 实例化：编译器处理过程，用实际的模板实参来生成模板的一个特殊实例，其中参数被替换为对应的实参。当函数模板被调用时，会自动根据传递给它的实参来实例化。而使用类模板时，则需要我们提供显式模板实参。 练习16.2 编写并测试你自己版本的 compare 函数。 #include <iostream> template<typename T&g...
c++Primer第16章：模板与泛型编程(习题解答）
qq_50271250的博客
01-14 753
16.1.1节练习 16.1 当调用一个函数模板时，编译器会利用给定的函数实参来推断模板实参，用此实际参数代替模板参数来创建出模板的一个新的“实例”，也就是一个真正的可以调用的函数，这个过程被称为实例化。 16.2 #include<bits/stdc++.h> using namespace std; template<typename T> int compare(const T&v1,const T&v2) { if(v1<v2)return
《c++primer》 第16章：模板与泛型编程
qq_40844444的博客
02-05 228
模板参数可以是类型参数、非类型参数或模板模板参数。函数模板允许编写通用的函数，适用于多种类型。类模板允许编写通用的类，适用于多种类型。模板特殊化允许为特定类型提供特定的实现。成员模板是类模板中的模板函数或模板类。显式实例化可以减少编译时间和代码大小。
C++ primer 第16章：模板与泛型编程 个人学习笔记。
weixin_45154969的博客
08-17 159
T 为模板参数v1:v2;
c++Primer——第十六章：模板与泛型编程
judith的博客
08-20 200
1、在模板的类型参数前必须使用关键字class或typename，在模板参数列表中这两个关键字的含义相同，可以互换使用。 2、默认情况下，对于一个实例化了的类模板，其成员只有在使用时才会被实例化 3、在一个类模板的作用域内，我么可以直接使用模板名而不必指定模板实参 4、在普通代码中，由于编译器掌握类的定义，因此它知道通过作用域运算符访问的名字是类型还是static成员，但对于模板代码就存在困难。如：T::mem，编译器并不知道mem是类型还是static成员。c++默认通过作用域运算符访问的不是类型，
C++Primer 第十六章 模板与泛型编程 习题答案
BadWomannnn的博客
03-16 299
编译器用推断出的模板参数为我们实例化一个特定版本的函数，当编译器实例化一个模板时，它使用实际的模板实参代替对应的模板参数来创建一个新的实例。
C++ PRIMER 第十六章 模板与泛型编程
金色的省略号
08-10 284
第四部分 面向对象编程与泛型编程 　　第十六章　模板与泛型编程 　　所谓泛型编程是以独立于任何特定类型的方式编写代码，使用泛型程序时，我们需要提供具体程序实例所操作的类型或值，模板是泛型编程的基础，使用模板时无须了解模板的定义，在泛型编程中，我们所编写的类或函数能够多态地用于跨越编译时不相关的类型，一个类或一个函数可以用来操纵多种类型的对象 　　16.1 定义模板 　　　　16.1.1 定...
C++ Primer 总结索引 | 第十六章：模板与泛型编程
AsherGu的博客
07-10 1081
定义模板；模板实参的推断：类型转换，std::move，转发；重载与模板；可变参数模板：包拓展，转发参数包；模板特例化
《C++ Primer》导学系列：第 16 章 - 模板与泛型编程
iShare_Carlos的博客
07-04 1470
在C++中，模板是一种强大的工具，可以让我们编写通用代码，而不必在编译时指定类型。模板允许我们定义函数模板和类模板，使得相同的代码可以处理不同的数据类型。理解模板的基本概念和语法是掌握高级C++编程的重要一步。类模板允许我们定义一个可以接受任意类型数据成员的类。public:private:本节总结了解了模板的基本概念和语法，掌握了函数模板和类模板的定义方法。理解了模板参数的使用，包括类型参数、非类型参数和模板模板参数。掌握了模板实例化的概念和方法，能够正确实例化函数模板和类模板。
C++ Primer 第五版 第16章 模板与泛型编程
weixin_44500921的博客
06-13 1181
一个函数模板（function template）就是一个公式，可用来生成针对特定类型的函数版本。模板定义以关键字template开始，后跟一个模板参数列表（template parameter list），这是一个逗号分隔的一个或多个模板参数的列表，用小于号（<）和大于号（>）包围起来。在模板定义中，模板参数列表不能为空。模板参数表示在类或函数定义中用到的类型或值。当使用模板时，我们（隐式地或显式地）指定模板实参（template argument），将其绑定到模板参数上。
C++ primer 第十六章 泛型 实现自定义Queue 修改版
09-19
总的来说，"C++ primer 第十六章 泛型 实现自定义Queue 修改版"的学习内容涵盖了C++模板基础、泛型编程、C++11新特性以及问题排查技巧。通过这个主题的学习，开发者可以深化对C++模板的理解，提高编写高效、通用代码...
C++ Primer 第五版 学习总结（十六） 第16章 模板与泛型编程
cf18862344377的博客
04-23 750
函数模板可以用来生成针对特定类型的函数版本。模板定义以关键字template开始，后跟一个模板参数列表（template parameter list）。模板参数列表以尖括号<>包围，内含用逗号分隔的一个或多个模板参数（template parameter）。定义模板时，模板参数列表不能为空。模板参数表示在类或函数定义中用到的类型或值。当使用模板时，需要显式或隐式地指定模板实参（template argument），并将其绑定到模板参数上。
C++读取exe程序标准输出
duke0226的专栏
01-07 232
Test.exe代码如下：逐行打印输入参数。
如何解决 PyCharm 控制台 pip install 报错 OSError: [Errno 18] Cross-device link 问题
最新发布
全栈小辉
01-09 510
本文分析了PyCharm控制台执行pip install时出现OSError: [Errno 18] Cross-device link报错的根源及解决方案。该错误是由于操作系统限制跨存储设备移动文件所致，当pip缓存路径与虚拟环境路径位于不同设备时（如C盘缓存D盘安装），就会触发此错误。文章从底层系统调用机制出发，指出三种典型诱因：pip缓存路径与虚拟环境路径跨设备、虚拟环境部署在外接设备、Linux下tmpfs缓存冲突。提供了四种解决方案：临时禁用缓存安装、修改pip缓存路径到同一设备、迁移虚拟环境位置
C++ 入门完全指南（四）--函数与模块化编程
whc的博客
01-06 432
本章介绍了C++函数的基础知识，包括函数的作用、基本语法和参数传递方式。函数通过代码复用、模块化提高程序的可维护性和可读性。基本语法涵盖函数定义、声明与调用，演示了有返回值和无返回值函数的实现。参数传递部分详细对比了值传递（创建参数副本，不影响原始变量）和引用传递（直接操作原始变量）的区别，并通过交换变量等实例展示其应用场景。本章内容为后续函数高级特性学习奠定了基础，帮助读者掌握模块化编程的基本方法。
.NET 核心：Func 与 Action 委托（从入门到实战）
bugcom的博客
01-07 654
摘要：本文系统讲解 .NET 中 Func 与 Action 委托的核心区别。Func 用于有返回值的场景（如计算、查询），最后一个泛型参数为返回类型；Action 用于无返回值的操作（如打印、遍历）。通过定义解析、代码示例（含输出结果）、LINQ 应用场景和对比表格，清晰展示两者差异。关键判断标准是"是否需要返回值"：需要结果用 Func，仅执行操作用 Action。文章内容可直接作为技术文档使用，适合 C#/.NET 各阶段开发者参考。
【GESP】C++五级练习（贪心思想考点） luogu-P9532 [YsOI2023] 前缀和
CoderCoding的博客
01-06 234
GESP C++ 五级练习题，虽然题目名称叫前缀和，但却是贪心考点，确实有点奇怪的误导。题目难度⭐⭐★☆☆，五级来说难度适中。洛谷难度等级普及−。
信奥赛C++提高组csp-s之强连通分量详解
王老师青少年编程
01-09 728
信奥赛C++提高组csp-s之强连通分量详解
C++ Primer: 模板与范型编程详解 - pw2052电源芯片应用
C++ Primer 第十六章深入探讨了模板与范型编程这一主题，这是一种强大的工具，用于创建在不同数据类型上通用的代码。章节开始于模板定义的介绍，指出模板和C#中的泛型相似，通过使用虚拟类型参数，如`typename T`或`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值