C++ 学习系列 -- 模板 template

一? C++ 模板介绍？

? C++ 为什么引入模板？

? ? ? 我的理解是：

C++ 引入模板的概念，是为了复用重复的代码，当某些代码除了操作的数据类型不同以外，其他逻辑全都相同，此时就适合采用模板的方式。

定义模板类或者模板函数时，只是定义了一个代码的架子，使用时需要配合上实际的数据类型，数据类型可以是基本数据类型也可以是用户自定义的类型。

官方一点的说法：

所谓模板，实际上是建立一个通用函数或类，其类内部的类型和函数的形参类型不具体指定，用一个虚拟的类型来代表。这种通用的方式称为模板。

模板是泛型编程的基础,泛型编程即以一种独立于任何特定类型的方式编写代码。

这种模板的设计在许多编程语言中是由类似的，比如 Java 、Scala 中都有模板的概念。

二? class template 类模板

类模板例子：

// complex.h
template<typename T>
class Complex
{
public:
    Complex(T re = 0, T im = 0):m_re(re), m_im(im)
    {

    }

    Complex& operator+=(const Complex& other);

    T real() const
    {
        return m_re;
    }

    T imag() const
    {
        return m_im;
    }


private:
    T m_re;
    T m_im;
};


template<typename T>
Complex<T>& Complex<T>::operator+=(const Complex& other)
{
    this->m_re += other.m_re; // 任意一个类都是自己的 friend class，所以可以使用 private 成员变量
    this->m_im += other.m_im;
    return *this;
}

// main.cpp
#include"complex.h"

int main()
{
    Complex<double> c1(1, 2);
    Complex<int>    c2(1.1, 2.2);
    Complex<float>  c3(1.1, 2.2);

    return 0;
}

上面是一个复数 Complex模板类的简单实现。

三? function template 函数模板

// complex.h
template<typename T>
class Complex
{
public:
    Complex(T re = 0, T im = 0):m_re(re), m_im(im)
    {

    }

    bool operator<(const Complex& other) const
    {
        if(this->m_re < other.m_re)
        {
            return true;
        }
        else if(this->m_re > other.m_re)
        {
            return false;
        }
        else
        {
            if(this->m_im < other.m_im)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

    T real() const
    {
        return m_re;
    }

    T imag() const
    {
        return m_im;
    }


private:
    T m_re;
    T m_im;
};

// main.cpp
#include <iostream>
#include"complex.h"

// 模板函数
template<typename T>
const T& myMin(const T& a, const T& b)
{
    return a < b ? a : b;
}

int main()
{
      int a1 = 11;
      int b1 = 22;
      std::cout << myMin(a1, b1) << std::endl;

      double a2 = 1.1;
      double b2 = 2.2;
      std::cout << myMin(a2, b2) << std::endl;
      
      Complex<int> c11(11, 2);
      Complex<int> c12(1, 22);

      auto cc = myMin(c11, c12);
      std::cout << cc.real() << ", " << cc.imag() << std::endl;
  
      return 0;
}

? ? ? ?以上代码定义了一个模板函数 myMin ；一个模板类 Complex，自定义了一个 operator< 成员函数。

? ? ? 从代码中我们发现一个问题，模板类要用尖括号指明实际的元素类型，而模板函数并不需要尖括号指明实际的元素类型。这是因为在?C++ 中，模板函数在调用时，可以通过传入的实参推断出形参的类型，因而不需要指明实际的元素类型。

? ? ? 模板函数 myMin 传入的类型需要有比较的能力，c++ 基本类型天然就具有比较的能力，而用户自定义类型需要实现?operator< 成员函数，才能在编译到 < 那行代码时能够通过，若是自定义类型没有实现 operator< 成员函数时，编译会出现错误。

四? member template 成员模板

成员模板也是一种函数模板，只不过针对的是构造函数的模板。

// base.h
class Base2
{

};

class Derive2:public Base2
{

};

class Base3
{
    
};

class Derive3:public Base3
{
    
};

// my_pair.h
template<typename T1, typename T2>
class MyPair
{
public:
    typedef T1 firstArgumentType;
    typedef T1 secondArgumentType;

    MyPair():first(T1()), second(T2())
    {
    }

    MyPair(const T1& arg1, const T2& arg2):first(arg1), second(arg2)
    {
    }

    // 成员模板
    template<typename U1, typename U2>
    MyPair(const MyPair<U1, U2>& other):first(other.first),second(other.second)
    {
    }
public:
    T1 first;
    T2 second;
};

// main.cpp
#include"my_pair.h"
#include"base.h"

int main()
{
    MyPair<Base2, Base3> pair1;
    MyPair<Derive2, Derive3> pair2;

    MyPair<Base2, Base3> pair3(pair2);

   return 0;
}

五? 模板特化（specialization）与偏特化（partial specialization）

1. 模板特化 （specialization）

? ? ? 模板特化指得是将模板类或者模板函数特化到某些特定的指定类型，使得在编译器编译时，实际编译执行的代码是特化后的版本。

?

// my_hash.h
#include<iostream>
#include<iostream>

template <class T>
struct my_hash
{
    T operator()(T x)
    {
        std::cout << "template <class T> struct my_hash" << std::endl;
        return x;
    }
};

// 以下为三个特化版本
template<>
struct my_hash<int>
{
    int operator()(int x)
    {
        std::cout << "template <> struct my_hash<int>" << std::endl;
        return x;
    }
};

template<>
struct my_hash<char>
{
    char operator()(char x)
    {
        std::cout << "template <> struct my_hash<char>" << std::endl;
        return x;
    }
};

template<>
struct my_hash<long>
{
    long operator()(long x)
    {
        std::cout << "template <> struct my_hash<long>" << std::endl;
        return x;
    }
};
// main.cpp

#include"my_hash.h"

int main()
{
    std::cout << my_hash<std::string>()("abcd") << std::endl;

    std::cout << my_hash<char>()('a') << std::endl;
    std::cout << my_hash<int>()(66) << std::endl;
    std::cout << my_hash<long>()(6666) << std::endl;

    return 0;
}

?输出：

2. 模板偏特化（partial specialization）

2.1? 个数偏特化

? ? ? 模板的个数变化时的特化版本

// my_vector.h
#include<iostream>

template<typename T, typename Alloc>
class my_vector
{
public:
    my_vector()
    {
        std::cout << "template<typename T, typename Alloc> class my_vector" << std::endl;
    }
};

template<typename Alloc>
class my_vector<bool, Alloc>
{
public:
    my_vector()
    {
        std::cout << "template<typename Alloc> class my_vector<bool, Alloc>" << std::endl;
    }
};

// main.cpp
#include"my_vector.h"

int main()
{
   my_vector<std::string, std::allocator<std::string>>  vec1;
   my_vector<bool, std::allocator<std::string>>  vec2;

   return 0;
}

输出：

2.2 范围偏特化

? ? ? 通过特化模板类型的指针来实现指针的特化

// e.h
#include<iostream>

template<typename T>
class E
{
public:
    E()
    {
        std::cout << "template<typename T> class E" << std::endl;
    }
};

template<typename T>
class E<T*>
{
public:
    E()
    {
        std::cout << "template<typename T> class E<T*>" << std::endl;
    }
};

// main.cpp
#include"e.h"

int main()
{
    E<std::string> e1;
    E<std::string*> e2;
    
    return 0;
}

输出：

六? 模板模板参数（template template parameter）

模板模板参数其实就是模板的其中参数又是另外一个模板参数，示例代码如下：

XCLS 类 的第一个模板参数是 T ，第二个模板参数是一个模板类 Container，我们可以定义一个 XX 模板类来组合使用 XCLS ，将 XX 传入即可；

也可以使用容器类 list? 传入，但是如果直接传入编译是会出错的，比如下面

   XCLS<std::string, std::list> xcls3; 编译不过

? 编译不过的原因是，std::list 实际上是两个模板参数，编译器检查时发现少给了一个模板参数 _Alloc ，所以编译不过。?

template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class list;

可以通过如下定义?Lst 来将模板类 list 的模板参数限定为 一个

template<typename T>
using Lst = std::list<T, std::allocator<T>>;

// xcls.h
#include<iostream>

template<typename T, template<typename U> class Container>
class XCLS
{
public:
    XCLS()
    {
        std::cout << "template<typename T, template<typename U> class Container> class XCLS" << std::endl;
    }
private:
    Container<T> c;
};

template<typename T>
class XX
{
public:
    XX()
    {
        std::cout << "template<typename T> class XX" << std::endl;
    }
};

// main.cpp
#include"xcls.h"

int main()
{  
   // 模板模板的参数使用
   XCLS<std::string, XX> xcls1;
   XCLS<std::string, Lst> xcls2;
   // XCLS<std::string, std::list> xcls3; 编译不过

   return 0;
}

输出：