深入解析template，掌握C++模板的精髓！

掌握C++模板（template）的优雅之道！

一、什么是模板？
二、模板如何工作？
三、C++ 中的模板类型
- 3.1、类模板
- 3.2、函数模板
四、模板参数推导
- 4.1、模板参数推导示例
- 4.2、函数模板参数推导
- 4.3、类模板参数推导（C++17 起）
五、C++ 中模板函数的重载
六、C++ 中函数重载和模板之间的区别
七、typename VS class 关键字
八、总结

一、什么是模板？

模板是 C++ 中最强大和最广泛使用的方法之一，允许我们编写通用程序。它允许我们定义泛型函数和类。它促进了泛型编程，不需要为不同的参数编写相同的函数或方法。

可以将模板定义为创建泛型类和函数的蓝图。C++ 模板背后的想法很简单。将数据类型作为参数传递，不需要为不同的数据类型编写相同的代码。
在这里插入图片描述
在 C++ 的模板中使用两个关键字——template 和 typename 来实现泛型编程。

注意：typename 关键字始终可以替换为class关键字。

C++ 中一些最常见的模板示例：

像迭代器这样的库容器。可以通过将数据类型作为参数传递给迭代器来定义不同数据类型的迭代器。
在 C++ 中为 STL 定义的排序算法。无论数据类型如何，都可以按顺序对数据进行排序。

C++ 中的模板示例：

vector <int> vec;
vector <char> vec;
stack <string> s;
queue <int> q; 等。

二、模板如何工作？

使用 C++ 中的模板来创建泛型方法和类。它在编译时会扩展，就像任何宏一样，并允许函数或类在不重写的情况下处理不同的数据类型。
在这里插入图片描述
要在 C++ 中使用模板，需要使用两个关键字：template 和 typename 。首先编写关键字template，它告诉编译器当前函数或类是蓝图或模板。编写模板后，数据类型使用关键字typename 和占位符名称（T）表示。

C++ 中的模板可以通过两种方式实现，即函数模板和类模板。

三、C++ 中的模板类型

可以使用 C++ 中的模板来定义泛型函数和类。用两种不同的方式表示 C++ 中的模板，即函数模板和类模板。接下来详细了解这两种表示形式。

3.1、类模板

像 C++ 中的函数模板一样，也可以使用类模板来创建可以处理各种数据类型的单个类。C++ 中的类模板可以使代码更短、更易于管理。

模板函数的语法：

template <class T> class class-name 
{
   // class body
}

上面的类模板语法中：

T 是数据类型的占位符模板参数。实例化类时，将指定 T 或参数类型。
class 是用于在模板声明中指定泛型类型的关键字。

注意：当类在 C++ 中使用模板的概念时，该类称为泛型类。

C++ 中类模板的一些预定义示例是 LinkedList、Stack、Queue、Array 等。接下来举一个例子来了解 C++ 中类模板的工作和语法。

示例：

#include <iostream>
using namespace std;

// Declaring a template class named Test.
template <class T>
class Test
{
private:
   // A variable (answer) of type T so that it can store results of various types.
   T answer;

public:
   // Constructor of Test class.
   Test(T n) : answer(n)
   {
      cout << "Inside constructor" << endl;
   }

   T getNumber()
   {
      return answer;
   }
};

// Main function
int main()
{
   // Creating an object with an integer type.
   Test<int> numberInt(60);

   // Creating an object with double type.
   Test<double> numberDouble(17.27);

   // Calling the class method getNumber with different data types:
   cout << "Integer Number is: " << numberInt.getNumber() << endl;
   cout << "Double Number = " << numberDouble.getNumber() << endl;

   return 0;
}

输出：

Inside constructor
Inside constructor
Integer Number is: 60
Double Number = 17.27

上面的示例中定义了一个模板类（Test），有一个返回类型 T，表示着它们可以是任何类型。

3.2、函数模板

函数模板类似于普通函数。普通函数仅适用于一种数据类型，但函数模板代码可以适用于多种数据类型。因此，可以将 C++ 中的函数模板定义为可以使用多种数据类型的单个泛型函数。

注意：也可以重载一个标准函数来处理各种数据类型。

函数模板比重载普通函数更强大，因为只需要编写一个程序，它可以处理所有数据类型。

模板函数的语法：

template <class T> T function-name(T args) 
{
   // body of function
}

在上面的语法中：

T 是可以接受各种数据类型的参数或占位符的类型。
class 是用于在模板声明中指定泛型类型的关键字。也可以在class的位置上写 typename。

C++ 中一些预定义的函数模板示例有 sort()、max()、min() 等。接下来举个例子来了解 C++ 中函数模板的工作和语法。

示例：

#include <iostream>
using namespace std;

// Template function that will be adding two data.
template <typename T>
T add(T a, T b)
{
   return (a + b);
}

// Main function
int main()
{
   // Variables to store results of different data types.
   int ans1;
   double ans2;

   // Calling template function with int parameters.
   ans1 = add<int>(2, 2);
   cout << "Sum of 2 + 2 is: " << ans1 << endl;

   // Calling template function with double parameters.
   ans2 = add<double>(2.5, 3.5);
   cout << "Sum of 2.5 + 3.5 is: " << ans2 << endl;

   return 0;
}

输出：

Sum of 2 + 2 is: 4
Sum of 2.5 + 3.5 is: 6

上面的例子中定义了一个模板函数，即 add()，可以提供多种数据类型作为函数的参数。

四、模板参数推导

模板参数推导会自动推导出传递给类或函数模板的参数的数据类型。这允许在不显式指定数据类型的情况下实例化模板。

例如，函数模板将两个数字相乘：

template <typename t>
t multiply (t num1,t num2) { return num1*num2; }

一般想对整数使用multiply () 函数时，必须这样调用它：

multiply<int> (54, 4);

但也可以这样调用：

multiply(46, 10);

这里没有明确指定类型，即46, 10是整数。

模板类也是如此（仅从 C++ 17 开始）。例如将模板类定义为：

template<typename t>
class student{
    private:
       t total_marks;
    public:
       student(t x) : total_marks(x) {}
};

如果想创建这个类的实例，可以这样使用：

student<int> stu1(23);
//    or
student stu2(24);

需要注意的是，类的模板参数推导仅在 C++17 之后可用。

4.1、模板参数推导示例

STL vector类模板如何在不显式指定的情况下推导出数据类型。

// C++ Program to illustrate template arguments deduction in
// STL
#include <iostream>
#include <vector>
 
using namespace std;
 
int main()
{
    // creating a vector<float> object without specifying
    // type
    vector v1{ 1.1, 2.0, 3.9, 4.909 };
    cout << "Elements of v1 : ";
    for (auto i : v1) {
        cout << i << " ";
    }
 
    // creating a vector<int> object without specifying type
    vector v2{ 1, 2, 3, 4 };
    cout << endl << "Elements of v2 : ";
    for (auto i : v2) {
        cout << i << " ";
    }
}

输出：

Elements of v1 : 1.1 2 3.9 4.909 
Elements of v2 : 1 2 3 4

注意：由于在 C++17 中添加了类模板参数推导，因此上述程序在 C++ 14 及以下编译器中编译失败。

4.2、函数模板参数推导

自 C++ 标准以来，函数模板参数推导一直是 C++ 的一部分。可以跳过声明要传递给函数模板的参数类型，编译器将使用在函数调用中传递的参数自动推断类型。

示例：

// C++ program to illustrate the function template argument
// deduction
#include <iostream>
using namespace std;
 
// defining function template
template <typename t> t multiply(t first, t second)
{
    return first * second;
}
 
// driver code
int main()
{
    auto result = multiply(30, 20);
    std::cout << "Multiplication OF 30 and 20: " << result
              << std::endl;
 
    return 0;
}

注意：对于具有相同类型的参数的函数模板，例如模板 void function(t a1, t a2){}，则不能传递不同类型的参数。

4.3、类模板参数推导（C++17 起）

类模板参数推导是在 C++ 中添加的17，此后一直是语言的一部分。它允许创建类模板实例，而无需像函数模板一样显式定义类型。

示例：

// C++ Program to implement
// Class Template Arguments 
// Deduction
#include <iostream>
#include <string>
#include <typeinfo>
using namespace std;
 
// defining class template
template <typename t>
class student {
private:
    string student_name;
    t total_marks;
 
public:
    student();
    // parameterized constructor
    student(string n, t m)
    {
        student_name = n;
        total_marks = m;
    }
 
    void getinfo()
    {
        cout << "STUDENT NAME: " << student_name << endl;
        cout << "TOTAL MARKS: " << total_marks << endl;
        cout << "Type ID: " << typeid(total_marks).name()
             << endl;
    }
};
 
int main()
{
    // student <int> is used to fulfill
      // template requirements
    student<int> s1("vipul", 100);
    student<int> s2("yash", 100.0);
 
    s1.getinfo();
    s2.getinfo();
 
    return 0;
}

输出：

STUDENT NAME: vipul
TOTAL MARKS: 100
Type ID: i
STUDENT NAME: yash
TOTAL MARKS: 100
Type ID: d

五、C++ 中模板函数的重载

重载是允许在同一作用域中指定多个同名函数的功能。因此，通过重载 C++ 中的模板函数，可以在 C++ 中定义具有相同名称但使用不同参数调用的函数模板。

示例：

#include <iostream>
using namespace std;

// Declaring the template function.
template <class T>

// Overloading the template function.
void display(T t1)
{
   cout << "Inside the display template function: " << t1 << endl;
}

// Overloading the template function with an integer parameter.
void display(int t1)
{
   cout << "Inside the overloaded integer-display template function: " << t1 << endl;
}

// main function
int main()
{
   // Calling the overloaded template function with different arguments.
   display(20);
   display(20.55);
   display('G');

   return 0;
}

输出：

Inside the overloaded integer-display template function: 20
Inside the display template function: 20.55
Inside the display template function: G

在上面的例子中定义了一个名为 display() 的模板函数，它接受一个参数并执行其中编写的指令。这里还用整数参数覆盖了display()函数。因此，当为函数提供整数值作为参数时，将调用重载函数（即 display(int t)）而不是模板函数。将对其余数据类型调用模板显示方法，即 display(T t1)。

六、C++ 中函数重载和模板之间的区别

在了解 C++ 中的函数重载和模板之间的区别之前，首先要知道 C++ 中的多态性是什么。

多态性意味着具有多种形式。多态性是面向对象编程的一个重要概念。可以将多态性定义为函数或消息以多种形式显示的能力。

C++ 中的函数重载和模板都是 C++ 中多态性的示例。当需要定义执行类似操作的多个函数时，应该使用函数重载。另一方面，当需要定义执行相同操作的多个函数时，应该在 C++ 中使用模板。

C++ 中的函数重载和模板之间最重要的区别之一是模板不能接受不同数量的参数，但重载函数可以接受不同数量的参数。

七、typename VS class 关键字

typename 和 class 是 C++ 模板中使用的关键字。typename 和 class 关键字之间没有区别。C++ 开发人员根据自己的喜好互换使用这两个关键字。type-parameter-key 中的 class 和 typename 之间没有语义差异。

在特殊情况下，不能在class的地方使用 typename。在声明模板参数的模板时，必须使用 class。

无效用法：

template <template <typename> typename T> class C 
{ 
    // body
}

有效用法：

template <template <typename> class T> class C 
{ 
    // body
}

八、总结

模板是添加到 C++ 中最强大和最广泛使用的方法之一，它允许编写通用程序。它将使我们能够定义泛型函数和类。

要在 C++ 中使用模板，使用两个关键字：template 和 typename 。还可以使用 class 关键字而不是 typename。
它消除了代码重复，并帮助进行通用回调。
它帮助编写非常高效和强大的库。示例：C++ 中的 STL。
它在编译器时会扩展，就像任何宏一样。
函数模板类似于普通函数。C++ 中的函数模板是可以使用多种数据类型的单个泛型函数。
像 C++ 中的函数模板一样，也可以使用类模板来创建可以处理各种数据类型的单个类。
由于模板是在编译时计算的，因此它们可能会减慢编译时间。

在这里插入图片描述