【C++ Template】 --- 模板初阶

最新推荐文章于 2024-04-08 22:57:38 发布
最新推荐文章于 2024-04-08 22:57:38 发布
阅读量1k 收藏
点赞数 1
分类专栏： C++之STL学习笔记 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42296879/article/details/129954762
版权

目录

模板

模板就是建立通用的模具，大大提高复用性，
C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板
C++提供两种模板机制**:函数模板和类模板**

1、函数模板

1.1 函数模板语法

函数模板作用：
建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：
template < typename T>
函数声明或定义

解释：
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

【例子：利用函数模板进行交换】

template<typename T> //声明一个模板，注意不需要分号
void MySwap(T &a,T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
template<typename T>
void func()
{
    cout << "func调用 " << endl;
}
void My_TemplateFunc()
{
    int a = 12;
    int b = 34;

    //1、自动类型推导 --- 让编译器推导传入的参数是什么数据类型，然后进行交换
    MySwap(a, b);
    cout << "a = " << a << "\tb = " << b << endl;

    //2、显式指定类型 --- 告诉编译器需要转换哪一种类型
    MySwap<int>(a, b);
    cout << "a = " << a << "\tb = " << b << endl;
}

1.2 函数模板注意事项

函数模板注意事项：1、自动类型推导，必须推导出一致的数据类型T,才可以使用

void My_TemplateFunc()
{
    /* 函数模板注意事项：1*/
    int a = 12;
    char c = 'w';
    MySwap(a, c); //err，推导不出一致的T类型
}

函数模板注意事项：2、模板必须要确定出T的数据类型，才可以使用

void My_TemplateFunc()
{
    /* 函数模板注意事项：2*/
    int a = 12;
    int b = 34;

    func();  //err,没有指定T的数据类型
    func<int>(); //OK
}

1.3 函数模板案例

函数模板代表了一个函数集合，该函数模板与类型无关，在使用时被参数化，根据实参类型产生适用于不同类型的函数。
下例使用函数模板对一个字符数组和一个整形数组进行排序（使用冒泡算法，降序排列）

template<typename T>
void mySort(T arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        int max = i; //认定最大值的下标
        for (int j = i + 1; j < len; j++)
        {
            //认定的最大值arr[max] < 遍历的数组，说明arr[j]为最大值，则更新下标
            if (arr[max] < arr[j])
            {
                max = j;
            }
        }
        if (max != i)
        {
            MySwap(arr[max], arr[i]); 
        }
    }
}
template<typename T>
void PrintFunc(T arr[],int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << arr[i] << "  ";
    }
    cout << endl;
}
void My_TemplateFunc_SortCase()
{
    char ch[] = "bafsxc";
    int len = sizeof(ch) / sizeof(ch[0]);
    mySort(ch, len);
    PrintFunc(ch, len);

    int arr[] = { 23,6,56,451,3,8,9,5,90 };
    int num = sizeof(arr) / sizeof(arr[0]);
    mySort(arr, num);
    PrintFunc(arr, num);
}

结果：
在这里插入图片描述

1.4 普通函数与函数模板的区别

1、普通函数调用时可以发生自动类型转换（隐式类型转换）
2、函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
3、函数模板调用时，如果利用显示指定类型的方式，可以发生隐式类型转换
1.4.1 普通函数调用会进行隐式类型转换
int ADD(int a, int b)
{
    return a + b;
}
void My_TemplateFunc_Func_diff()
{
    int a = 10;
    int b = 20;
    char c = 'c';
    cout << ADD(a, c) << endl;
}

在这里插入图片描述

输出109：在ADD()函数中，把字符型C的值隐式转换为ASCII码值，然后进行累加.

1.4.2 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
template<typename T>
T MyAdd(T a, T b)
{
    return a + b;
}
void My_TemplateFunc_Func_diff()
{
    int a = 10;
    int b = 20;
    char c = 'c';

    cout << MyAdd(a, c) << endl;  //err
}

在这里插入图片描述

1.4.3 函数模板调用时，如果利用显示指定类型的方式，可以发生隐式类型转换
template<typename T>
T MyAdd(T a, T b)
{
    return a + b;
}
void My_TemplateFunc_Func_diff()
{
    int a = 10;
    int b = 20;
    char c = 'c';

    //显示指定 --- 可以发生隐式类型转换
    cout << MyAdd<int>(a, c) << endl;  //OK
}

在这里插入图片描述

1.5 普通函数与函数模板的调用规则

调用规则如下：
（1）如果函数模板和普通函数都可以实现， 优先调用普通函数
（2）可以通过 空模板参数列表 来 强制调用函数模板
（3）函数模板也 可以发生重载
（4）如果函数模板可以产生更好的匹配, 优先调用函数模板

1.5.1 规则一
void MyPrint(int a, int b)
{
    cout << "调用普通函数" << endl;
}
template<typename T>
void  MyPrint(T a, T b)
{
    cout << "调用函数模板" << endl;
}
void My_TemplateFunc_CallFunc()
{
    int a = 10;
    int b = 20;

    //1. 如果函数模板和普通函数都可以实现， 优先调用普通函数
    MyPrint(10, 20);   //规则一
}
1.5.1 规则二
void MyPrint(int a, int b)
{
    cout << "调用普通函数" << endl;
}
template<typename T>
void  MyPrint(T a, T b)
{
    cout << "调用函数模板" << endl;
}
void My_TemplateFunc_CallFunc()
{
    int a = 10;
    int b = 20;
    
    //2、空模板参数列表，强制调用函数模板
    MyPrint<>(a, b);   //调用函数模板
}
1.5.1 规则三
void MyPrint(int a, int b)
{
    cout << "调用普通函数" << endl;
}
template<typename T>
void  MyPrint(T a, T b)
{
    cout << "调用函数模板" << endl;
}
template<typename T>
void  MyPrint(T a, T b，, T c)
{
    cout << "调用 重载的 函数模板" << endl;
}
void My_TemplateFunc_CallFunc()
{
    int a = 10;
    int b = 20;

    //3、函数模板也 可以发生重载
    MyPrint(a, b, 100);
}
1.5.1 规则四
void MyPrint(int a, int b)
{
    cout << "调用普通函数" << endl;
}
template<typename T>
void  MyPrint(T a, T b)
{
    cout << "调用函数模板" << endl;
}
template<typename T>
void  MyPrint(T a, T b，, T c)
{
    cout << "调用 重载的 函数模板" << endl;
}
void My_TemplateFunc_CallFunc()
{
    int a = 10;
    int b = 20;

    //4、如果函数模板可以产生更好的匹配, 优先调用函数模板
    char c1 = 'a';
    char c2 = 'b';
    MyPrint(c1, c2);  //调用的是 函数模板
}

结果
在这里插入图片描述

1.6 模板的局限性

1.6.1 模板的通用性并不是万能的
template<class T>
void f(T a, T b)
{
a = b;
}

在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

template<class T>
void f(T a, T b)
{
if(a > b) { ... }
}

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行
因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

1.6.2 为特定的类型提供具体化的模板
template<class T>
bool myCompare(T &a, T &b)
{
    if (a == b) { return true; }
    else { return false; }
}
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Age = age;
        this->m_Name = name;
    }

    ~Person()
    {

    }

    string m_Name;
    int m_Age;
};
//具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//具体化优先于常规模板;利用具体化的Person的版本 实现比较代码，会被优先调用
template<>bool myCompare(Person &p1, Person &p2)
{
    if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
    {
        return true;
    }
    else
    {
        return false;
    }

}
void My_TemplateFunc_Backpoint()
{
    int a = 10;
    int b = 20;
    cout << myCompare(a, b) << endl;
   
    //自定义数据类型，不会调用普通的函数模板
	//可以创建 具体化的Person数据类型的模板，用于特殊处理这个类型
    Person p1("Tom", 10);
    Person p2("Tom", 10);
    bool ret = myCompare(p1, p2);
    if (ret) { cout << "p1==p2" << endl; }
    else { cout << "p1 != p2" << endl; }
}

在这里插入图片描述

2、类模板

类模板作用
建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。

2.1 类模板语法

类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板
语法：

template < typename T >
类

template<class NameType,class AgeType>
class MyPerson01
{
public:
    template<class NameType, class AgeType>
    MyPerson01(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    void Show()
    {
        cout << "name:" << this->m_Name << endl;
        cout << "age:" << this->m_Age << endl;
    }

    NameType m_Name;
    AgeType  m_Age;
};
void My_TemplateClass_Basic()
{
    MyPerson01<string, int> p1("Tom", 18);
    p1.Show();
}

在这里插入图片描述

2.2 类模板与函数模板区别

  1. 类模板 没有自动类型推导 的使用方式 — 只能使用 显示指定方式
  2. 类模板在模板参数列表中可以有默认参数
template<class NameType, class AgeType = int>
class MyPerson0
{
public:
    MyPerson0(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    void Show()
    {
        cout << "name:" << this->m_Name << endl;
        cout << "age:" << this->m_Age << endl;
    }

    NameType m_Name;
    AgeType  m_Age;
};
void My_TemplateClass_TemplateFunc_diff()
{
    //MyPerson p("lslslsl", 200);  //err ，自动类型推导不适用于 类模板

    MyPerson<string, int> p1("sssss", 200);  // 必须使用显示指定类型的方式，使用类模板
    p1.Show();

    MyPerson<string> p2("gggggg", 345);  //  类模板在模板参数列表中可以有默认参数,直接在模板后面指定即可
    p2.Show();
}

在这里插入图片描述
在这里插入图片描述

2.3 类模板中成员函数创建时机

普通类中的成员函数：一开始就可以创建
类模板中的成员函数：在调用时才去创建

class MyPerson03
{
public:
    void ShowPerson03()
    {
        cout << "Show Person03 类" << endl;
    }
};
class MyPerson04
{
public:
    void ShowPerson04()
    {
        cout << "Show Person04 类" << endl;
    }
};
template<class T>
class MyClass
{
public:
    T obj;

    //类模板中的成员函数,并不是一开始就创建的，而是在模板调用时再生成
    void FUNC1()
    {
        obj.ShowPerson03();
    }
    void FUNC2()
    {
        obj.ShowPerson04();
    }
};
void My_TemplateClass_CreatTime()
{
    MyClass<MyPerson03> p1;
    p1.FUNC1();
    p1.FUNC2(); //compile err, 编译会出错，说明函数调用 才会去 创建成员函数
}

在这里插入图片描述

2.4 类模板对象做函数参数

类模板实例化出的对象，向函数传参的方式

三种传入方式：
1. 指定传入的类型 — 直接显示对象的数据类型
2. 参数模板化 — 将对象中的参数变为模板进行传递
3. 整个类模板化 — 将这个对象类型 模板化进行传递

template<class T1,class T2>
class MyPerson05
{
public:
    MyPerson05(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    void Show()
    {
        cout << "NAME: " << this->m_Name << "\tAGE: " << this->m_Age << endl;
    }

    T1 m_Name;
    T2 m_Age;
};

void My_TemplateClass_Func_data()
{
    MyPerson05<string, int> p1("sdsdsds", 100);
    ShowPerson01(p1);//1. 指定传入的类型 --- 直接显示对象的数据类型


    MyPerson05<string, int> p2("ldfldldlf", 200);
    ShowPerson02(p2);//2. 参数模板化-- - 将对象中的参数变为模板进行传递


    MyPerson05<string, int> p3("ppppppp", 34);
    ShowPerson03(p3);//3. 整个类模板化-- - 将这个对象类型 模板化进行传递
}
2.4.1 指定传入的类型
void ShowPerson01(MyPerson05<string,int> &p)
{
    p.Show();
}

在这里插入图片描述

2.4.2 参数模板化
template<class T1,class T2>
void ShowPerson02(MyPerson05<T1, T2> &p)
{
    p.Show();
    cout << "T1 的类型为：" << typeid(T1).name() << endl;
    cout << "T2 的类型为：" << typeid(T2).name() << endl;
}

在这里插入图片描述

2.4.3 整个类模板化
template<class T>
void ShowPerson03(T &p)
{
    p.Show();
    cout << "T 的类型为：" << typeid(T).name() << endl;
}

在这里插入图片描述

2.4.4 总结

通过类模板创建的对象，可以有三种方式向函数中进行传参
使用比较广泛是第一种：指定传入的类型

2.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：

  1. 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型； 如果不指定，编译器无法给子类分配内存
  2. 如果想灵活指定出父类中T的类型，子类也需变为类模板
2.5.1 注意点（1）

在这里插入图片描述
指定父类T类型后

template<class T>
class Base
{
public:
    Base()
    {
        cout << "父类中 T 的类型为：" << typeid(T).name() << endl;
    }

    T m;
};
class Son1 : public Base<int>
{
public:

};
2.5.2 注意点（2）
template<class T>
class Base
{
public:
    Base()
    {
        cout << "父类中 T 的类型为：" << typeid(T).name() << endl;
    }

    T m;
};

template<class T1,class T2>
class Son2 :public Base<T2>
{
public:
    Son2()
    {
        cout << "子类中 T1 的类型为：" << typeid(T1).name() << endl;
        cout << "子类中 T2 的类型为：" << typeid(T2).name() << endl;
    }

    T1 obj;

};
void My_TemplateClass_Inheritance()
{
    Son2<int,char> s1;  
}

此时， int为子类Son2中的 T1的类型，char为子类Son2中的 T2的类型 ； 并且由于子类Son2继承的父类Base，此时会把T2 当作父类的T类型传给父类，因此，父类的 T 为char

在这里插入图片描述

2.6 类模板成员函数类外实现

类模板中成员函数类外实现时，需要加上模板参数列表

template<class T1,class T2>
class Myperson06
{
public:
    Myperson06(T1 name, T2 age);
    void ShowMyPerson06();

    T1 m_Name;
    T2 m_Age;
};
template<class T1,class T2>
Myperson06<T1,T2>::Myperson06(T1 name ,T2 age)
{
    this->m_Name = name;
    this->m_Age = age;
}
template<class T1,class T2>
void Myperson06<T1, T2>::ShowMyPerson06()
{
    cout << "NAME : " << this->m_Name << "\tAGE: " << this->m_Age << endl;
}
void My_TemplateClass_OutOfClass()
{
    Myperson06<string,int> p1("sdsdsdsds",5467);
    p1.ShowMyPerson06();

}

2.7 类模板分文件编写

问题：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决：

解决方式1：直接包含.cpp源文件
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

person.hpp中代码：

#pragma once
#include <iostream>
using namespace std;
#include <string>
template<class T1, class T2>
class Person 
{
public:
	Person(T1 name, T2 age);
	void showPerson();
public:
	T1 m_Name;
	T2 m_Age;
};
//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}
//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}

类模板分文件编写.cpp中代码

#include<iostream>
using namespace std;
//#include "person.h"
#include "person.cpp" //解决方式1，包含cpp源文件

//解决方式2，将声明和实现写到一起，文件后缀名改为.hpp
#include "person.hpp"

void test01()
{
	Person<string, int> p("Tom", 10);
	p.showPerson();
}
int main() 
{
	test01();
	system("pause");
	return 0;
}

主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp

2.8 类模板与友元

全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在

2.8.1 类内实现
template<class T1, class T2>
class Myperson08
{
public:
    Myperson08(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    //类内实现   ---  通过全局函数打印Myperson08类的信息
    friend void PrintMyperson08Info(Myperson08<T1,T2> p)
    {
        cout << "NAME; " << p.m_Name << "\tAGE: " << p.m_Age << endl;
    }

private:
    T1 m_Name;
    T2 m_Age;

};
void My_TemplateClass_Friend()
{
    Myperson08<string, int> p1("vbcgghcv", 34);
    PrintMyperson08Info(p1);
}

在这里插入图片描述

2.8.1 类外实现
//如果全局函数 是类外实现，需要在程序最开始声明该函数 和 类模板
template<class T1, class T2> class Myperson08;   //声明类模板
template<class T1, class T2>
void PrintMyperson08Info2(Myperson08<T1, T2> p) //声明该函数
{
    cout << "类外实现内容为" << endl;
    cout << "NAME; " << p.m_Name << "\tAGE: " << p.m_Age << endl;
}

//通过全局函数打印M有person08类的信息
template<class T1, class T2>
class Myperson08
{
public:
    Myperson08(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    //类外实现   ---  通过全局函数打印Myperson08类的信息
    //加一个空参数模板列表
    friend void PrintMyperson08Info2<>(Myperson08<T1, T2> p);

private:
    T1 m_Name;
    T2 m_Age;
};
void My_TemplateClass_Friend()
{
    Myperson08<string, int> p2("nnnnnnn", 88);
    PrintMyperson08Info2(p2);
}

在这里插入图片描述

just kidding°
关注
专栏目录
C++初阶--vector模拟实现
Iiverson2000的博客
07-29 364
今天我们不直接上代码了，我们先来分析一下vector这个容器。 我们来看看这个东西 vector<vector> 这我们可以大概猜到是一个二维数组。 但并不完全是，二维数组是一个n*n 的矩形结构，而这里的vector套vector可不是这样， 我们来剖析一下它 当我们执行 vv [ i] [ j ] 这行代码时 首先执行 vv. operator [ i ],也就是vv [ i ] 这时候我们在一个大vector中找到了，很多很多的vector。每一个vector 是用i 控制的，一
C++ --函数模板初阶的知识总结
烟华的博客
10-08 158
一，泛型编程 编写与类型无关的通用代码，是代码复用的一种手段，模板是泛型编程的基础。 二，函数重载和函数模板的关联 函数重载：定义函数名相同而形参列表（形参个数或形参类别）不同的多个函数。。 函数模板：创建一类实现逻辑（函数体）一样，只是用到参数的类型不同的函数的公式。 区别： 1，函数重载用于定义功能相似的同名函数，提高函数的易用性，但代码复用率低，只要有新类型出现就要增加对应的函数，而且代码可...
C++ 函数模板&类模板
qq_30722721的博客
08-15 448
C++模板说明 模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。模板是一种对类型进行参数化的工具，通常有两种形式：函数模板和类模板。函数模板针对仅参数类型不同的函数，类模板针对仅数据成员和成员函数类型不同的类。 　　使用模板的目的就是能够让程序员编写与类型无关的代码。比如编写了一个交...
C++ Template模板
⚡
12-14 3508
函数模板扩展了函数重载并简化函数的重载： 利用函数重载可以让多个函数共享一个函数名，只要所重载的函数的参数类型必须有所不同。 但是，由于参数的类型不一样，虽然这些函数所完成的功能完全一样，也必须为每一个重载函数编写代码。 类模板实际上是函数模板的推广： (类是对问题的抽象，而类模板是对类的抽象，即更高层次上的抽象）类模板称为带参数(或参数化)的类，也称为类工厂，它可用来生成多个功能相同而某些数据...
C++模板template
dongbab的博客
01-14 223
C++ template
C++： C++模板＜template＞
C++ JAVA的专栏
02-09 994
C++：C++模板＜template＞
C++学习之路-Template模板
weixin_45452278的博客
08-19 441
了解模板之前，先了解一个概念：泛型。泛型，实质上就是不使用具体数据类型（例如 int、double、float等），而是使用一种通用类型来进行程序设计的方法，该方法可以大规模的减少程序代码的编写量，让程序员可以集中精力用于业务逻辑的实现。是一种将类型参数化进而达到代码复用的技术，强调的是，在C++中是使用模板来实现泛型。typename 后跟的“T”只是一个占位符而已，是自定义的，可以改成任意字符，只需要全部统一即可。但是，尽量统一，不要乱写符号，尽量写成T，因为T可以认为是Type的简称。}
C++初阶：STL之vector类模板
weixin_36194037的博客
12-14 1439
C++初阶：STL之vector类模板
C++之模板初阶
An_Mo的博客
09-23 333
一、泛型编程 泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础 模板：告诉编译器一个模子，让编译器根据不同类型利用该模子生成代码 模板分为：函数模板和类模板 二、 函数模板 1、函数模板概念 函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。 2、函数模板格式 template<typename T1, typename T2,…,typename Tn> 返回值类型 函数名(参数列表){} templ
C++ —— 模板初阶
m0_64240499的博客
10-20 515
C++ —— 模板初阶
C++之模板(Template)模式
lovely_yoshino的博客
07-22 4923
0. 简介 模板模式是行为模式的最后一章，也是我们设计模式的最后一章。模板模式是C++高级用法中不可或缺的一部分，也是作为我这种SLAMer必不可少的需要大量使用的模式。在Ceres，G2o中都可以看到这样的用法。它在超类中定义了一个算法的框架， 允许子类在不修改结构的情况下重写算法的特定步骤。 1. 模板模式示意图 我们可以看到模板模式结构是非常简单的设计模式。通过复用模板抽象类的方法能够避免大量的重复性代码。 模板方法基于继承机制， 它允许你通过扩展子类中的部分内容来改变部分算法。 策略模式基于组合机制
C++模板（template）详解
2301_81261654的博客
03-09 8058
原因是在链接过程中，编译器找不到模板函数的定义，因为在使用模板时，.h文件中的模板的声明知晓了模板参数的类型，但在.cpp文件中的模版不知道，所以.cpp中模板的定义没法实例化,也就没法在编译阶段生成一份经过实例化的具体的代码，这将导致程序在链接阶段找不到模板函数的实现而报链接错误。这样一来，在调用Add函数的时候，其本质上是调用了上面的经过实例化的模板函数，这样做的好处就是，程序员就可以不用对每一种数据类型都去实现对应的函数，大大提高了效率，而且只实现这么一份通用的模板函数可以使其更易于维护。
C++编程语言中模板（template）介绍
liitdar的博客
06-05 8017
泛型编程是一种代码编写方式，通过使用泛型编程，可以编写出独立于任何特定类型的代码。模板是泛型编程的基础，是创建泛型函数或类的蓝图（公式）。C++的STL(Standard Template Library)容器及其迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。每个容器都有一个单一的定义，比如vector，我们可以定义许多包含不同类型元素的vector，比如：“vector ”或“vector ”。C++的模板包括函数模板和类模板。
深入解析template，掌握C++模板的精髓！
最新发布
Lion_Long的博客
04-08 1543
模板是 C++ 中最强大和最广泛使用的方法之一，允许我们编写通用程序。它允许我们定义泛型函数和类。它促进了泛型编程，不需要为不同的参数编写相同的函数或方法。可以将模板定义为创建泛型类和函数的蓝图。C++ 模板背后的想法很简单。将数据类型作为参数传递，不需要为不同的数据类型编写相同的代码。在 C++ 的模板中使用两个关键字——template和typename来实现泛型编程。注意：typename 关键字始终可以替换为class关键字。像迭代器这样的库容器。
C++模板详解：泛型编程、模板原理、非类型模板参数、模板特化、分离编译
林慢慢的博客
06-01 1684
泛型编程、模板原理、非类型模板参数、模板特化、分离编译
【C++】模板template
qq_52572621的博客
11-15 2084
1、我们使用模板的目的就是为了提高代码的复用性，减少重复代码的编写； 2、函数模板的底层并不是只有一个函数完成的，它是根据你传入参数的类型，给你分配一个适用你传入类型的函数；如果你连续传入n个类型，他就会给你分配n个函数；
C++模板——template
原来45的博客
06-11 3万+
目录1. 模板2. 函数模板2.1 函数模板概念2.2 函数模板格式2.3 函数模板原理2.4 函数模板的实例化2.5 模板参数的匹配原则2.6 声明定义分离3. 类模板3.1 类模板格式3.2 类模板的实例化3.3 类模板中函数放在类外进行定义时4. 模板分离编译4.1 什么是分离编译4.2 模板的分离编译5. 缺省值，返回值6. 总结...
C语言实现模版
zoomdy's blog
02-02 2万+
C语言有两把双刃剑，一把是“指针”，另一把是“宏”。这回咱就用“宏”来实现C++中才有的模版。这里的模版实现一个很简单的加法函数，同一个函数代码可以处理不同类型的加法运算。 http://blog.csdn.net/zoomdy/article/details/79242528 mingdu.zheng at gmail dot com C++的实现 template &lt;cl...
C++：模板总结
热门推荐
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
03-16 6万+
写在前面 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;模板（Template）指C++程序设计设计语言中采用类型作为参数的程序设计，支持通用程序设计。C++ 的标准库提供许多有用的函数大多结合了模板的观念，如STL以及IO Stream。模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成...
C++模板template深度解析
"C++模板template用法小结(推荐)\n主要介绍了C++模板template用法总结，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下" C++模板是C++编程语言中的一个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值