C/C++编程：模板

心已赠人 2023-01-13 06:25 141阅读 0赞

# 外部模板 #

*  传统C++中，模板只有在使用时才会被编译器实例化。即只要在每个编译单元(文件)中编译的代码中遇到了被完整定义的模板，都会实例化。
 *  这就产生了重复实例化而导致编译时间增加，并且，我们没有办法通知编译器不要触发模板实例化。

为此，C++11引入了**外部模板，扩充了原来的强制编译器在特定位置实例化模板的语法，使我们能够显式的通知编译器何时进行模板的实例化**

*  **template class std::vector`<`bool>; // 强行实例化**
 *  **extern template class std::vector`<`int>; // 不在该当前编译文件中实例化模板**

完整例子：

#include <iostream>
    #include <vector>
    
    template class std::vector<bool>;           // forcely instantiation
    extern template class std::vector<double>;  // external template for avoiding instantiation in this file
    
    template<bool T> class MagicType {
        
        bool magic = T;
    };
    
    int main() {
        
        // the >> in template
        std::vector<std::vector<int>> matrix;
        std::vector<MagicType<(1>2)>> magic; // legal, but not recommended
    }

# 尖括号`>` #

在传统C++的编译器中，`>>`一律被当作右移运算符来进行处理。但实际上我们很容易就会写出嵌套模板的代码：

std::vector<std::vector<int>> matrix;

这在传统C++编译器下是不能被编译的，而C++11开始，连续的尖括号将变得合法，并且能够顺序通过编译。比如下面的：

template<bool T>
    class MagicType{
        
    	bool magic == T;
    };
    
    std::vector<MagicType<<1>2>> magic// 合法，但不建议写出这样的代码

# 类型别名模板 #

在了解**类型别名模板**之前，需要理解**模板**和**类型**之间的不同。

*  **模板是用来产生类型的**
 *  在传统C++中，`typedef`可以为类型定义一个新的名称，但是却没有办法为模板定义一个新的名称。因为，模板不是类型：

#include <vector>
    
    template<typename  T, typename  U>
    class MagincType{
        
    public:
        T dark;
        U magic;
    };
    
    // 不合法
    template<typename  T>
    typedef MagincType<std::vector<T>, std::string> FakeDarkMagic;

C++11使用using引入了下面这种形式的写法：

#include <iostream>
    #include <algorithm>
    #include <vector>
    
    template<typename  T, typename  U>
    class MagincType{
        
    public:
        T dark;
        U magic;
    };
    
    
    template<typename  T>
    using TrueDarkMagic = MagincType<std::vector<T>, std::string>;
    
    int  main()
    {
        
        TrueDarkMagic<bool> you;
    }

# 默认模板参数 #

定义一个加法参数如下：

template<typename T, typename U>
    auto add(T x, U y) -> decltype(x+y) {
        
        return x+y;
    }
    
    // 调用模板参数
    auto ret = add<int, int>(1, 3);

也就是说，我们如果要使用这个模板，就必须每次都指定模板参数的类型

在C++11中提供了一种便利，可以指定模板的默认参数：

template<typename T = int, typename U = int>
    auto add(T x, U y) -> decltype(x+y) {
        
        return x+y;
    }
    
    // 调用模板参数
    auto ret = add(1, 3);

# 变长参数模板 #

在C++11之前，无论是类模板还是函数模板，都只能按照其指定的样子，接收一组固定数量的模板参数；从C++11起，加入新的表达方法：

*  **允许任意个数、任意类别的模板参数，同时也不需要在定义时将参数的个数固定**。

> **template<typename … Ts> class Magic;**

模板类Magic的对象，能够接受不受限制个数的typename作为模板的形式参数，比如下面：

class Magic<int,
    			std::vector<int>,
    			std::map<std::string,
    			std::vector<int>>> darkMagic

当然也可以个数为0的模板参数：

class Magic<> nothing;

*  **如果不希望产生的模板参数个数为0，可以手动的定义至少一个模板参数：**

> **template<typename Require, typename … Ts> class Magic;**

*  变长参数模板也能直接调整到模板函数上。传统C中的printf函数，虽然也能达成不定个数的形参的调用，但是其并非类型安全。而C++11除了定义类型安全的变长参数函数外，还可以使类似printf的函数能自然地处理非自带类别的对象。**除了在模板参数中能使用…表示不定长模板参数外，函数参数也使用同样的表示法代表不定长参数**，这也为我们简单编写变长参数函数提供了便携的手段，比如：

> **template<typename … Args> void printf(const std::string &str, Args… args);**

我们定义了变长的模板参数，那么如何对参数进行解包呢？

首先，我们可以使用`sizeof...`来计算参数的个数：

template<typename ...Ts>
    void magic(Ts... args){
        
    	std::cout << sizeof...(args) << std::endl;
    }

我们可以传递任意个参数个magic函数：

magic(); //输出0
    magic(1);  //输出1
    magic(1, ""); //输出2

其次，对参数进行解包，到目前为止还没有一种简单的方法能够处理参数包，但是有两种经典的处理方法：

## 递归模板函数 ##

递归是最经典的处理方法。这种方法不断递归的向函数传递模板参数，进而达到递归遍历所有模板参数的目的：

#include <iostream>
    template<typename T0>
    void printf1(T0 value){
        
        std::cout << value << "\n";
    }
    
    template<typename T, typename... Ts>
    void printf1(T value, Ts... args){
        
        std::cout << value << "**\n";
        printf1(args...);
    }
    
    int main(){
        
        printf1(1, 2, "123", 1.2);
        return 0;
    }

![在这里插入图片描述][20210418124010771.png]

## 变参模板展开 ##

当然，更好的方法是C++17中支持的变参模板参数展开的支持，这样我们就可以在一个函数中完成printf的编写

template<typename T, typename... Ts>
    void printf1(T value, Ts... args){
        
        std::cout << value << "\n";
        if constexpr (sizeof...(args) > 0){
        
            printf1(args...);
        }
    }

事实上，有时我们虽然使用了变参模板，但不一定要对参数做逐个遍历，我们可以利用std::bind以及完美转发等特性实现对函数和参数的绑定，从而达到成功调用的目的

## 初始化列表展开 ##

递归模板函数是一种标准的做法，但缺点显而易见的在于必须**定义一个终止递归的函数**。

这里介绍一种使用初始化列表展开的黑魔法

template<typename T, typename... Ts>
    void printf1(T value, Ts... args){
        
        std::cout << value << "\n";
        (void) std::initializer_list<T>{
        ([&args]{
        
            std::cout << args << "\n";
        }(),value)...};
    }

在这个代码中，额外使用了C++11中提供的初始化列表以及lambda表达式的特性。

通过初始化列表，`(lamda表达式, value)...`将会被展开。由于逗号表达式的出现，首先会执行前面的lambda表达式，完成参数的输出。为了避免编译器警告，我们可以将std::initializer\_list显式转为void

# 折叠表达式 #

C++17将变长参数这种特性进一步带给了表达式：

#innclude<iostream>
    
    template<typename... T>
    auto sum(T... t){
        
    	return (t + ...);
    }
    
    int main(){
        
    	std::cout << sum(1, 2, 3, 4, 5, 6, 7, 8, 9);
    }

# 非类型模板参数推导 #

前面我们主要提及的是模板参数的一种形式：类型模板参数

template<typename T, typename U>
    auto add(T t, U u){
        
    	return t + u;
    }

其中模板的参数T和U为具体的类型。但是还有一种常见的模板参数形式可以让不同字面量称为模板参数，即非类型模板参数：

template<typename T, int BufSize>
    class buffer_t{
        
    public:
        T & alloc();
        void free(T & item);
    
    private:
        T data[BufSize];
    };
    
    
    buffer_t<int , 100> buf; // 100 作为模板参数

在这种模板参数的形式下，我们可以将100作为模板的参数传递。 在C++11引入了类型推导这一特性后，我们会很自然的问，既然这里的模板参数以具体的字面量进行传递，能否让编译器辅助我们进行类型推导，通过使用占位符auto从而不再需要明确指明类型？C++11引入了这一特性：

template<auto value> void foo(){
        
    	std::cout << value << "\n";
    	return;
    }
    
    int main(){
        
    	foo<10>(); //value被推导为int类型
    }

[20210418124010771.png]: /images/20221022/35947b098e0c4788a5aca1f571bd12ac.png