C++(十四)模板进阶

于 2024-08-30 22:13:18 发布
阅读量593 收藏 10
点赞数 17
文章标签： java 算法 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79608541/article/details/141711044
版权

 模板进阶

在之前我们学习过模板的基本使用，不熟悉的小伙伴可以翻看：C++（七）模板

在这里我们就直接更深入的学习模板

一、非类型模板参数

首先我们明确一点：模板分为类型模板和非类型模板

所以参数也分别对应为类型模板参数和非类型模板参数 

1. 类型模板（Type Template）

类型模板是最常见的模板类型，它允许你为类或函数定义参数化的类型。这种模板参数代表一种数据类型，编译时会根据你提供的实际类型进行实例化。

示例：

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    int x = 5, y = 10;
    double a = 2.5, b = 4.5;

    // 使用类型模板实例化函数（显式）            隐式也没有问题，为了易于观察写作显式
    int int_result = add<int>(x, y);          // int add(int, int)
    double double_result = add<double>(a, b); // double add(double, double)

    return 0;
}

 在上面的例子中，add函数是一个类型模板，T是一个类型参数。这个模板可以处理任何数据类型，如int或double，而无需为每种类型编写不同的函数（交给编译器去做）。

在这里面 T就是类型模板参数 ，T会自动识别（或指定）成int或者double等类型。

这就是一个最为简单直观的类型模板。

2. 非类型模板（Non-Type Template）

非类型模板的参数不是类型，而是常量表达式（如整数、指针、引用等）。这些参数在模板实例化时被指定，并且通常用来影响模板内部的实现。

非类型模板的参数就为： 非类型模板参数 

什么意思呢？我们用一个最简单的例子看看非类型模板的使用：

template <int N>
int multiply(int a) {
    return a * N;
}

int main() {
    int result1 = multiply<5>(2);     // 5 * 2 = 10
    int result2 = multiply<10>(3);    // 10 * 3 = 30

    return 0;
}

 在这个例子中，multiply函数模板有一个非类型模板参数N，它是一个整型常量。在实例化时，N的值被替换为实际的常量值，如5或10。

注意：

  • 非类型模板参数都被定义为常量表达式（const expression）这意味着它们的值在编译时是已知的。

  • 常见的非类型模板参数类型包括：

    • 整型常量 (int, char, bool, 等)
    • 枚举类型 (enum)
    • 指针类型 (指向对象或函数的指针)
    • 引用类型 (对象的引用)
    • 浮点数常量 (C++20及更高版本，现在大部分的编译器是不支持浮点型的!!!)
    • 类的静态成员

在这里主要介绍整型常量，使用相对比较多：

1.1.1整形常量

示例：

#include<iostream>
template <int N = 10>
int multiply(int a) {
    return a * N;
}

int main() {
    int result1 = multiply<5>(2);     // 5 * 2 = 10
    int result2 = multiply(3);        // 10 * 3 = 30
    std::cout << result1 <<std::endl;
    std::cout << result2;

    return 0;
}

程序运行结果：

30
10

        在这段程序里面，N可以给上缺省值，这也是没有问题的。

        只需要，且非常重要的一点：编译时常量，非类型模板参数必须是编译时常量，这意味着它们的值在编译时已确定。这里的N一定是一个常量且在编译时已确定，在函数中不可被修改！！！

错误用法：

template <int N = 10>
int multiply(int a) {
    N=30;
    return a * N;
}

int main() {
    int result1 = multiply<5>(2);     // 5 * 2 = 10
    int result2 = multiply(3);        // 10 * 3 = 30

    return 0;
}

程序运行结果：

​

下面的几种用法并非很常用，可适当时候翻看：

1.1.2.枚举类型

 示例：

#include<iostream>
enum Color { 
    Red, 
    Green, 
    Blue 
};

template <Color C>
class ColorPrinter {
public:
    void print() const {
        //关键字:constexpr，用于表示一个表达式或函数可以在编译时求值
        /* 如果 C 是 Red，则只会编译输出 "Red\n" 的代码块，其他分支不会编译。
         * 如果 C 是 Green，则只会编译输出 "Green\n" 的代码块。
         * 如果 C 是 Blue，则只会编译输出 "Blue\n" 的代码块。
         */
        if constexpr (C == Red) 
        {
            std::cout << "Red\n";
        }
        else if (C == Green) 
        {
            std::cout << "Green\n";
        }
        else if (C == Blue) 
        {
            std::cout << "Blue\n";
        }
    }
};

int main() {
    ColorPrinter<Red> redPrinter;
    redPrinter.print();     // 输出 "Red"
    return 0;
}

代码运行结果：

Red
1.1.3 指针和引用

        指针和引用类型的非类型模板参数用于传递对象的地址或引用。

示例：

#include<iostream>
template <int* ptr>
class PointerWrapper {
public:
    void print() const
    {
        std::cout << "Value: " << *ptr << "\n";
    }
};
int x = 5;
int main() {
    
    PointerWrapper<&x> wrapper;
    wrapper.print(); // 输出 "Value: 5"
    return 0;
}

运行结果： 

Value: 5

引用版本：

#include <iostream>

template <int& ref>  // 使用引用作为非类型模板参数
class PointerWrapper {
public:
    void print() const {
        std::cout << "Value: " << ref << "\n";  // 直接输出引用的值
    }
};

int x = 5;

int main() {
    PointerWrapper<x> wrapper;  // 使用引用的非类型模板参数
    wrapper.print(); // 输出 "Value: 5"
    return 0;
}

运行结果： 

Value: 5
1.1.4 类的静态成员

因为现在很多编译器尚未支持浮点数常量，所以这里直接跳过了。

下面直接演示静态成员：

#include<iostream>
class MyClass {
public:
    // 声明静态常量成员变量
    static const int value ;
};
// 类外定义静态常量成员变量
const int MyClass::value = 42;

template <int N>
class StaticValuePrinter {
public:
    void print() const 
    {
        std::cout << "Value: " << N << "\n";
    }
};

int main() {
    StaticValuePrinter<MyClass::value> printer;
    printer.print(); // 输出 "Value: 42"
    return 0;
}

运行结果：

Value: 42

二、类模板特化 

  • 什么是类模板特化？ 
  • 模板特化有什么用？

我们的学习围绕上述问题进行展开：

1.模板特化的定义

        类模板特化（Class Template Specialization）是C++模板编程中的一个重要特性，允许针对特定的模板参数提供专门化的实现。

在我们学习的模板的过程中，分为类模板和函数模板，函数特化很自然的也分为

  •      类模板特化 
  •      函数模板特化

 2.类模板特化：

那模板特化到底什么意思？看以下代码：

#include <iostream>

// 通用的类模板
template <typename T>
class MyClass {
public:
    void print() const 
    {
        std::cout << "Generic template\n";
    }
};

// 对int类型的特化 (可以看作为模板开的特殊通道，只要是int就走这边）
template <>
class MyClass<int> {
public:
    void print() const 
    {
        std::cout << "Specialized template for int\n";
    }
};

int main() {
    MyClass<double> obj1;  // 使用通用模板
    obj1.print();          // 输出: Generic template

    MyClass<int> obj2;     // 使用模板特化
    obj2.print();          // 输出: Specialized template for int

    return 0;
}
  • 通用模板 MyClass<T> 提供了一个 print 方法，适用于任何类型的 T。
  • MyClass<int> 是 MyClass 的完全特化版本，专门针对 int 类型，并提供了不同的 print 方法。（可以看作int的特殊通道，只要是int就走这里）

仔细阅读以上代码可以看出

类模板特化的写法

1.必须先定义一个基本的类模板

2.使用 template<> 声明完全特化的模板或者声明部分特化，在模板参数中指定部分条件。

3.为特定的模板参数提供不同的实现。

上面又提到了2个概念：

  • 完全特化
  • 部分特化

那么什么是完全特化？什么是部分特化呢？

说起来也简单：

  • 完全特化（Full Specialization）：为特定的模板参数提供完全不同的实现。
  • 部分特化（Partial Specialization）：为一部分模板参数提供特定的实现，而不是所有的模板参数。

上面我们举的第一个例子里面就是完全特化，就是将基础模板的全部参数都提供特定的实现，上面示例代码基础模板的全部参数就 T：将其特化成int

template <typename T>

完全特化：

template <>
class MyClass<int> 
{
 ... ...
};

理解了上面内容之后我们再看看什么是部分特化：

首先一个示例：（完全特化）

#include <iostream>

// 通用的类模板
template <typename T1, typename T2>
class MyClass {
public:
    void print() const {
        std::cout << "基础 MyClass \n";
    }
};

// 完全特化：针对类型 int 和 double 的组合
template <>
class MyClass<int, double> 
{
public:
    void print() const {
        std::cout << "完全特化 <int double>\n";
    }
};

int main() {
    MyClass<int, double> obj1; // 使用完全特化
    obj1.print(); // 输出

    MyClass<int, int> obj2;    // 使用通用模板
    obj2.print(); // 输出

    return 0;
}

 运行结果：

完全特化 <int double>
基础 MyClass

观察以上代码，和第一个例子没有本质的不同只不过是类模板参数多了一个。

完全特化，MyClass<int, double> 针对 int 和 double 的组合提供了特定的实现。这种实现会完全替代通用模板，当模板参数是 int 和 double 时，编译器会选择这个特化版本（走这个特殊通道）。

基于上面代码，如果让它是一个部分特化应该怎么写呢？

示例（部分特化）：

template <typename T1, typename T2>
class MyClass {
public:
    void print() const {
        std::cout << "基础 MyClass \n";
    }
};

// 部分特化：当两个类型相同
template <typename T2>
class MyClass<int, T2> {
public:
    void print() const {
        std::cout << "部分特化 \n";
    }
};

int main() {
    MyClass<int, int> obj1; // 使用部分特化
    obj1.print(); 

    MyClass<double, double> obj2;    // 使用基础模板
    obj2.print();

    return 0;
}

运行结果： 

部分特化
基础 MyClass

部分特化：MyClass<int, T2> 部分特化了 T1 为 int，T2 保持泛化。这意味着当 T1 是 int 时，不论 T2 是什么类型，都会使用这个部分特化的版本（T1是int 优先走这边）。

在部分特化中的写法是值得我们注意的

如果想要只特化T2，T1还是使用任意类型，语法也是支持的

// 部分特化：当第二个类型是 int 时
template <typename T1>
class MyClass<T1, int>
{
... ...
};

 那么如果全特化和部分特化同时存在，那main函数里面的对象会走哪一个呢？

先说结论：哪个更匹配走哪一个!!!

书面来说模板特化的规则：

  • 完全特化：最具体，针对一个完全确定的类型组合，如 MyClass<int, double>。
  • 部分特化：相对于通用模板来说更具体，但仍然可以匹配多种类型组合，如 MyClass<int, T2> 或 MyClass<T, T>。
  • 通用模板：最不具体，适用于任何类型组合。

代码演示：（大家可以先思考下面代码obj1，obj2，obj3分别的输出是什么再看运行结果）

#include <iostream>
template <typename T1, typename T2>
class MyClass {
public:
    void print() const {
        std::cout << "基础 MyClass \n";
    }
};

// 部分特化：当两个类型相同
template <typename T>
class MyClass<T, T> {
public:
    void print() const {
        std::cout << "部分特化 \n";
    }
};

// 部分特化：当第一个类型是 int 时
template <typename T2>
class MyClass<int, T2> {
public:
    void print() const {
        std::cout << "部分特化 <int, T2>\n";
    }
};

// 完全特化：针对类型 int 和 double 的组合
template <>
class MyClass<int, double>
{
public:
    void print() const {
        std::cout << "完全特化 <int double>\n";
    }
};

int main() {
    MyClass<int, double> obj1;        
    obj1.print();

    MyClass<int, char> obj2;           
    obj2.print();

    MyClass<short, double> obj3;
    obj3.print();

    return 0;
}

运行结果：

完全特化 <int double>
部分特化 <int, T2>
基础 MyClass

关于类模板特化这里就先展示这么多，小伙伴有疑问可以多多实践，多敲敲研究更多的变化。

3.函数模板特化 

        学习了上面类模板的使用，函数模板的使用也是如法炮制，只是在代码的书写使用中略微有点差别。

函数模板特化的使用步骤：

  • 定义通用的函数模板（在特化之前必须先有一个基础的函数模板）
  • template<> 声明和定义特化的模板函数

【注意】：函数模板特化不支持部分模板特化，只有全特化

示例：

#include <iostream>
#include <string>

// 1. 定义一个通用的函数模板
template <typename T>
void print(T value) {
    std::cout << "基础: " << value << std::endl;
}

// 2. 特化函数模板（特化int类型）
template <>
void print<int>(int value) {
    std::cout << "特化int类型: " << value << std::endl;
}

// 2. 特化函数模板（特化std::string类型）
template <>
void print<std::string>(std::string value) {
    std::cout << "特化std::string类型: " << value << std::endl;
}

int main() {
    // 3. 调用模板特化函数
    print(10);                      // 调用特化的int版本
    print(3.14);                    // 调用通用版本
    print("Hello");                 // 调用通用版本
    print(std::string("Hello"));    // 调用特化的std::string版本

    return 0;
}

如果理解了类模板的特化，函数模板的特化应该还是很好理解的，知道大家需要注意代码实践写的时候，语法应该是这么写的。

关于模板进阶暂时就提及这么多下面个大家提供一个脑图，帮助大家更清晰的学习理解模板。

 

Juttt
关注
  • 17
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[C++]： 模板进阶
水墨不写bug
07-10 1514
C++模板进阶：非类型模板参数，模板的特化，模板的分离编译
C++进阶——模板进阶
m0_73093743的博客
01-02 446
当类模板的函数声明和类模板的函数定义分开两个文件写时，编译器就会分离编译。private:// .h 文件public:void pop();private:// .cpp 文件// 显示实力化templatetemplate。
[C++进阶]模板进阶
2301_80017277的博客
07-21 1084
class 类模板名 {};T* _finish;
C++模板进阶
weixin_44614083的博客
05-13 546
系列文章目录 C++入门 C++类和对象（上） C++类和对象（中） C++类和对象（下） C/C++内存管理 C++string类 C++vector类 C++list类 C++stack和queue C++双端队列 文章目录系列文章目录前言一、非类型模板参数二、模板的特化1.函数模板特化2.类模板的特化三、分离编译总结 前言 模板是C++中泛型编程的基础。一个模板就是一个创建类或函数的蓝图。 一、非类型模板参数 模板参数分为类型模板参数和非类型模板参数。 类型模板参数：出现在模板参数列表中，跟在
C++ 模板进阶篇
qq_61635026的博客
07-16 836
C++ 模板进阶篇
C++模板：进阶特性的探索
07-14
### C++模板：进阶特性的探索 #### 一、模板基础 在C++中，模板是一种非常重要的机制，它允许开发人员编写泛型代码。这意味着你可以编写一次代码，让它适用于多种不同的数据类型，而无需为每种类型都编写一份相同...
C++开发工程师高级进阶课程-提升C++面试和开发能力.zip
01-20
《C++开发工程师高级进阶课程-提升C++面试和开发能力》的资源包，旨在帮助C++开发者进一步提升自己的专业技能，以适应更高级别的面试挑战和开发工作。这份资料集涵盖了C++语言的核心知识，包括但不限于C++面试常见...
C(C++)语言经典进阶中文资料
06-09
《C(C++)语言经典进阶中文资料》是一个包含多本知名C++和C语言学习书籍的资源包，专为那些已经掌握了基础知识并寻求更深入理解的程序员设计。这个压缩包中，你将找到三本非常有影响力的书籍，分别是《C++编程指南》...
《由浅入深学C++-基础、进阶与必做300题》pdf格式 （完整版 带目录
07-26
本书循序渐进地讲述了C++的基础知识、C++程序的组成及其开发过程、C++程序中的数据、表达式和语句、控制程序流程、数组与字符串、指针与引用、使用函数、函数模板、错误和异常处理、宏和预编译、面向对象的开发、...
学堂在线郑莉《c++程序设计语言》(基础和进阶)的编程作业题
06-25
本压缩包文件包含的编程作业题旨在帮助学习者深入理解和掌握C++的基础知识以及进阶技巧。通过实践这些题目，学生可以提升编程能力，更好地应用C++解决实际问题。 C++是一门强大的面向对象编程语言，它不仅继承了...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 4439
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 4493
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 4637
linux上datax 安装以及使用
《深入理解 Java 中的适配器模式》
最新发布
面团到油条的成长日记
08-29 2780
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
操作系统原子操作
zzt_is_me的博客
08-28 2817
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 2380
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 1763
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 2502
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
死锁及其产生条件
秋夫人
08-26 1252
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值