C++模板(上)

简介: C++模板(上)

模板

模板是C++种为了方便用户对于一些场景的使用,引入的新概念,使得我们的代码不会冗余

template关键字

template关键字的意思就是模板,语法为:template<typename T1,typename T2.....,typename Tn>

使用语境

我们需要对于多种类型进行交换的时候,Swap函数的使用,在C++模板之前/C语言中,我们只能多次书写不同类型参数的Swap函数,但是现在我们可以使用模板,让编译器自动识别我们传进去的参数的类型,也就是Swap函数只需要写一次

//使用方式为:
class A
{
public:
    A(int a)
       :_a(a)
    {}
private:
    int _a;
};
template<typename T>  ///模板是支持多个模板参数的,如果说需要对于两个不同类型进行交换,那就创建两个模板参数 template<typename T1,typename T2>
void Swap(T& a,T& b)
{
    T tmp=a;
    a=b;
    b=tmp;
}
int main()
{
    int a=1,b=2;
    double c=1.1,d=2.2;
    A a1(2);
    A a2(3);
    Swap(a,b);
    Swap(c,d);
    Swap(a1,a2);
    return 0;
}

模板中的typename也可以使用class来替换,为了方便,class是比较好用的

模板类型

模板分为类模板和函数模板,对于我们上述的Swap函数使用模板,这就是函数模板,类模板是在类中的成员中使用模板

模板的作用范围

模板只能作用域该语句下面第一个函数/类,所以每当创建一个函数/类模板时,就需要重新使用模板声明

函数模板

函数模板表示为一个函数家族,可以套用任意类型的参数来使用该函数,所以函数模板与类型无关,在使用的时候能被参数化,根据实参的类型推理函数特定的类型(这些都是编译器来实现的)

**使用模板**
**template <typename T1,typename T2……typename Tn> **
**返回值类型 + 函数名 (参数列表){}**

我们是可以在返回值类型中/参数列表中使用T,但是对于一个函数而言,T是整个函数的一种变量,不能又是int又是double

template<typename T>
void Swap(T& a,T& b)
{
    T tmp=a;
    a=b;
    b=tmp;
}
template<typename T1,typename T2>
void Swap(T1& a,T2& b)
{
    T1 tmp=a;
    a=b;
    b=tmp;
}
int main()
{
    int a=0;
    double b=1.1;
    return 0;
}

typename表示的是类型名字,可以用class来替换,但是struct不行(为了和结构体避开)

函数模板本身不是严格意义上的函数,是编译器根据传参类型进行自动生成的特点具体类型函数,所以编译器实际上是做了我们不愿意重复做的事情

函数模板的实例化

定义:用不同类型的参数使用函数模板的时候,称为函数模板的实例化,实例化分为两种一种是隐式实例化,另一种是显示实例化

隐式实例化

//让编译器根据我们传递的实参的类型推演模板参数的类型
template<typename T>
void Swap(T& a,T& b)
{
    T tmp=a;
    a=b;
    b=tmp;
}
int main()
{
    int a=10,b=20;
    double c=1.1,d=2.2;
    Swap(a,b);//T识别为int类型
    Swap(c,d);//这个情况T识别为double类型
    Swap(a,c);//这种情况会报错,因为编译器无法识别T到底是int还是double类型,在模板中编译器一般不会自动进行类型转换
    return 0;
}

为了解决上面多类型单模板的问题,我们可以通过两个方式来解决,1.手动强制转换(传参时候强转)2.显示类型转换

显示类型转换

//对于上述问题,我们两种方法处理
//让编译器根据我们传递的实参的类型推演模板参数的类型
template<typename T>
void Swap(T a,T b)
{
    T tmp=a;
    a=b;
    b=tmp;
}
int main()
{
    int a=10,b=20;
    double c=1.1,d=2.2;
    Swap(a,(int)c);//或者是Swap((double)a,c);//就是在传参的时候就将两个实参统一为同一类型
    //第二种方法,显示类型转换
    Swap<int>(a,c)//说明使得模板的类型为int类型
    Swap<double>(a,c);//double
    return 0;
}

显示转换,实际上就是我们让编译器认为模板类型就是<类型>括号中的类型

但是我们要知道的是,使用显示转换,或者自己传参强制转换的时候,不能使用&的,因为我们只是强制转换的,但是原有类型是没办法变的

当同时有模板函数和同名非模板函数时,在其他条件相同(只是一个用模板一个不用)在调用时候会优先调用非模板函数,如果模板可以产生一个具有更好匹配的函数,那么优先模板

template<typename T1,class T2>
int add(T1& a, T2& b)
{
    return a + b;
}
int add(int& a, double& b)
{
    return a + b;
}
int add(int& a, int& b)
{
    return a + b;
}
int main()
{
    int a = 10, b = 20;
    double c = 1.1, d = 2.2;
    add(a, c);
    add(a, b);
    return 0;
}

模板函数不允许自动类型转换,但普通函数可以进行自动类型转换

所以模板函数有显示实例化<>就是为了让编译器知道我们想要的类型是什么

类模板

类模板,就是一个类,和普通类是一样的,只是这个类中的成员变量中有模板参数typename T,当我们使用这个类的时候,编译器会根据我们的实例化类,来生成对应的类型

//下面是演示过程
class A
{
public:
    void Print()
    {
        cout<<_a<<endl;
    }
    T get_a()
    {
        return _a;
    }
private:
    T _a;
};
int main()
{
    A<int>a;
    a.Print();
    return 0;
}

语法:

template<class T1,class T2,…,class Tn>

class 类模板名

{

//类中成员定义(成员函数/成员变量)

}

template<class T>
class A  //A就是模板名字
{
public:
    void Print()
    {
        cout << _a << endl;
    }
    T get_a();
private:
    T _a;
};
template<class T>
T A<T>::get_a()
{
    return _a;
}
#include<vector>
int main()
{
    A<int>a;
    vector<int>a;
    a.Print();
    return 0;
}

类模板的实例化

类模板的实例化是需要在<>中确认类型的(不然编译器不知道如何定义T类型)如:vector<int>a (int类型的容器vector)

类模板的实例化需要在类模板名字后面跟着<>,然后将实例化的类型放在<>中即可,类模板不是真正的类,实例化的结果才是类

总结

模板分为函数模板和类模板

函数模板

  • 函数模板不是函数,实例化之后的才是函数

类模板

  • 类模板也不是真正意义上的类,实例化的后的结果才是类

函数模板和类模板实例化都是由编译器处理的,所以我们只需要给他实例化的类型即可

函数模板的实例化分为隐式实例化和显示实例化,隐式就是不需要<类型>,显示的需要<类型>

函数模板的显示实例化:一般是处理单个模板参数对多个类型的实参时候<类型>,<>中的类型决定最后返回类型(指定模板参数的实际类型)

template<class T>
T add(T a, T b)
{
    return a + b;
}
int main()
{
    int b = 10;
    double c = 1.1;
    //两个类型传参,我们规定的是<double>类型,所以T类型为double,所以传参的时候隐式转换
    c=add<double>(c, b);//如果是add<int>(c,d)输出结果为11
    cout << c << endl;//输出为11.1
    return 0;
}

类模板和模板类

说明:模板类是类模板实例化后的一个产物,比如说,我们拿着杯子,想去接一杯饮料,你想要可乐,那就去接可乐,想要雪碧就去接雪碧,那么可乐、雪碧这就是我们实例化产生的产物,根据我们的意愿产生的,这就是由类模板得到的模板类

类模板和模板类,前者注重模板,后者注重类,也就是说,类模板并不是一个真正意义上的类,而类模板实例化之后的产物才是真正意义上的类(编译器处理,我们来选定模板参数类型),这样得到的也就是模板类

相关文章
|
2月前
|
存储 算法 C++
C++ STL 初探:打开标准模板库的大门
C++ STL 初探:打开标准模板库的大门
120 10
|
4月前
|
编译器 C++
【C++】——初识模板
【C++】——初识模板
【C++】——初识模板
|
1月前
|
安全 编译器 C++
【C++11】可变模板参数详解
本文详细介绍了C++11引入的可变模板参数,这是一种允许模板接受任意数量和类型参数的强大工具。文章从基本概念入手,讲解了可变模板参数的语法、参数包的展开方法,以及如何结合递归调用、折叠表达式等技术实现高效编程。通过具体示例,如打印任意数量参数、类型安全的`printf`替代方案等,展示了其在实际开发中的应用。最后,文章讨论了性能优化策略和常见问题,帮助读者更好地理解和使用这一高级C++特性。
47 4
|
1月前
|
算法 编译器 C++
【C++】模板详细讲解(含反向迭代器)
C++模板是泛型编程的核心,允许编写与类型无关的代码,提高代码复用性和灵活性。模板分为函数模板和类模板,支持隐式和显式实例化,以及特化(全特化和偏特化)。C++标准库广泛使用模板,如容器、迭代器、算法和函数对象等,以支持高效、灵活的编程。反向迭代器通过对正向迭代器的封装,实现了逆序遍历的功能。
36 3
|
5月前
|
程序员 C++
C++模板元编程入门
【7月更文挑战第9天】C++模板元编程是一项强大而复杂的技术,它允许程序员在编译时进行复杂的计算和操作,从而提高了程序的性能和灵活性。然而,模板元编程的复杂性和抽象性也使其难以掌握和应用。通过本文的介绍,希望能够帮助你初步了解C++模板元编程的基本概念和技术要点,为进一步深入学习和应用打下坚实的基础。在实际开发中,合理运用模板元编程技术,可以极大地提升程序的性能和可维护性。
|
1月前
|
编译器 C++
【c++】模板详解(1)
本文介绍了C++中的模板概念,包括函数模板和类模板,强调了模板作为泛型编程基础的重要性。函数模板允许创建类型无关的函数,类模板则能根据不同的类型生成不同的类。文章通过具体示例详细解释了模板的定义、实例化及匹配原则,帮助读者理解模板机制,为学习STL打下基础。
32 0
|
2月前
|
编译器 程序员 C++
【C++打怪之路Lv7】-- 模板初阶
【C++打怪之路Lv7】-- 模板初阶
20 1
|
2月前
|
存储 编译器 C++
【C++篇】引领C++模板初体验:泛型编程的力量与妙用
【C++篇】引领C++模板初体验:泛型编程的力量与妙用
50 9
|
2月前
|
编译器 C语言 C++
C++入门6——模板(泛型编程、函数模板、类模板)
C++入门6——模板(泛型编程、函数模板、类模板)
69 0
C++入门6——模板(泛型编程、函数模板、类模板)
|
2月前
|
算法 编译器 C++
【C++篇】领略模板编程的进阶之美:参数巧思与编译的智慧
【C++篇】领略模板编程的进阶之美:参数巧思与编译的智慧
95 2