c++ 模板详解

这篇具有很好参考价值的文章主要介绍了c++ 模板详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

  • 模板就是将类型进行参数化

函数模板

//函数模板的定义格式
template<class 形参名,class 形参名...>
返回值类型 函数名(参数列表){
    函数体;
}
  • 模板形参不能为空,并且函数模板中每一个类型参数在函数参数表中至少使用一次,只有这样才能推断出具体的类型
template <class T>
T Add(T x1, T x2){
    return x1+x2;
}

int main(){
    cout<<Add(2,3)<<endl;//5
    cout<<Add(3.2,1.4)<<endl;//4.6
    return 0;
}

函数模板实例化

  • 不能直接使用函数模板实现具体操作,必须对模板进行实例化,即将模板参数实例化,就是用具体的类型参数去替换函数模板中的模板参数,生成一个确定的具体类型的真正函数,才能实现运算操作

  • 实例化方式

    • 隐式实例化:根据具体的函数调用形式,推演出模板参数类型
    • 显式实例化:通过显式声明形式指定模板参数类型
  • 隐式实例化

    • 上述代码中调用Add(2,3)的过程

    • 编译器根据传入的实参2和3推断出模型形参类型是int

    • 会将函数模板实例化出一个int类型的函数

    • int Add(int x1,int x2){
          return x1+x2;
      }
      
    • 编译器生成具体类型函数的过程称为实例化,生成的函数称为模板函数

    • 生成int类型的函数后,再将2和3传入进行计算

    • 当调用Add(3.2,1.4)又会生成一个float的函数

    • 每次调用都会根据不同的类型实例化出不同类型的函数,所以最终可执行程序的大小和重载方式相比并不会减少,只是提高了程序员对代码的复用

    • 问题:隐式实例化不能为同一个模板形参指定两种不同的类型,例如Add(2,3.2),此时编译器会报错,因为编译器不能推断出T的类型

  • 显式实例化

    • cout<<Add<int>(2,3.2)<<endl;//5  cout << Add<int>(2, static_cast<int>(3.2)) << endl;最好的方式是进行一个显式转换
      cout<<Add<float>(3,2)<<endl;//5
      
  • 函数模板也可以进行重载

template <class T>
T Add(T x1, T x2){
    return x1+x2;
}

template <class T>
T Add(T x1, T x2, T x3){
    return x1 + x2 + x3;
}

int main(){
    cout<<Add(2,3)<<endl;//5
    cout<<Add(3.2,1.4)<<endl;//4.6
    cout<<Add<int>(2,3.2)<<endl;//5  cout << Add<int>(2, static_cast<int>(3.2)) << endl;最好的方式是进行一个显式转换
    cout<<Add<float>(3,2)<<endl;//5
    cout<<Add(1,2,3)<<endl;//6
    return 0;
}
  • 当模板函数和自己写的Add具有具体的int类型的函数而言,此时如果传入的参数是int则会调用具体化的int函数,即C++编译器优先考虑普通函数

类模板

//类模板定义格式
template <class 形参名, class 形参名>
class 类名{
    
}
  • 由于类模板包含类型参数,因此也称为参数化类,如果说类是对象的抽象,对象是类的实例,则类模板是类的抽象,类是类模板的实例
template <class T1, class T2>
class Add{
private:
    T1 x1;
    T2 x2;
public:
    Add(T1 x1, T2 x2):x1(x1),x2(x2){}
    T1 get(){
        return x1 + x2;
    }
};

int main(){
    Add<double,int> a(1.2,2);
    cout<<a.get()<<endl;//3.2
    return 0;
}

类模板实例化

  • 使用类模板创建对象时,必须指明具体的数据类型,这和函数模板不一样,这是因为函数模板中一定会传递实参,可以根据实参推断出所有的数据类型,但是类模板中,构造函数时不一定会同时传递T1 T2,所以不一定会百分百推断出数据类型,因此需要显式传递
  • 可以使用对象指针进行实例化Add<double,int> *p1 = new Add<double,int>(1.2,2);但是需要注意两边的模板参数需要相同
template <class T>
class A{
public:
    T Add(T t1, T t2){
        return t1 + t2;
    }
};

int main(){
    A<int> a;
    cout<<a.Add(1.2,2)<<endl;
}
  • 在函数模板中,不能进行自动转换,这是因为函数模板中需要根据实参来推断数据类型,而在类模板中,因为已经显式指定了int,所以会创建一个int的类,然后可以自动转换

  • 在类模板外定义成员函数,格式

template <模板形参表>
函数返回类型 类名<模板形参名>::函数名(参数列表){}
template <class T>
class A{
public:
    T Add(T t1, T t2){
        return t1 + t2;
    }
    T sub(T t1, T t2);
};

template<class T>
T A<T>::sub(T t1, T t2) {
    
}
  • 类模板在实例化时,带有模板形参的成员函数并不对着自动被实例化,只有当它被调用或取地址时才会被实例化。因为不被调用的时候,你根本不知道模板形参表中的数据类型是什么,想实例化就需要把所有的数据类型组合都实例化一遍,这显然是不可接受的

类模板与友元函数

非模板友元函数

  • 在类模板中声明一个普通的友元函数,该函数时类模板所有实例的友元函数,可以访问全局对象,也可以使用全局指针访问非全局对象,可以创建自己的对象,也可以访问独立于对象模板的静态数据成员
#include <iostream>

using namespace std;

template <class T>
class A{
private:
    T x1,x2;
    static T x3;
public:
    A(T x1,T x2):x1(x1),x2(x2){}
    friend void func();
};
//这里进行特化赋值
template<>
int A<int>::x3 = 10;

template<>
double A<double>::x3 = 100;


void func(){
    cout<<A<int>::x3<<endl;//10
    cout<<A<double>::x3<<endl;//100
    A<char> a('A','a');
    cout<<a.x1<<" "<<a.x2<<endl;//A a
}

int main(){
    func();
    return 0;
}
  • 如果func()中有一个特定类型的参数,则只能访问特定类型的数据
#include <iostream>

using namespace std;

template <class T>
class A{
private:
    T x1,x2;
    static T x3;
public:
    A(T x1,T x2):x1(x1),x2(x2){}
    friend void func(A<T> a1);
};
//这里进行特化赋值
template<>
int A<int>::x3 = 10;

template<>
double A<double>::x3 = 100;


void func(A<int> b){
    cout<<A<int>::x3<<endl;//10
//    cout<<A<double>::x3<<endl;//100此时就不可以访问double类型了
    A<char> a('A','a');//可以正常创建别的类型的对象,因为这个创建是在任何地方都可以
//    cout<<a.x1<<" "<<a.x2<<endl;//A a 这里也不可以访问了,因为不是char类型的友元函数
}

int main(){
    func(A<int>(1,2));
    return 0;
}

约束模板友元函数

  • 这样的友元函数本身就是一个函数模板,但其实例化类型取决于类被实例化时的类型(被约束),每个类的实例化都会产生一个与之匹配的具体化的友元函数
#include <iostream>

using namespace std;

template <class T>
void func(T x1, T x2);

template <class T>
class A{
private:
    T x1,x2;
public:
    A(T x1, T x2):x1(x1),x2(x2){}
    friend void func<T>(T x1,T x2);//这里也可以写成friend void func<>(T x1, T x2);因为可以推断出T的类型来
};

template <class T>
void func(T x1,T x2){
    A<T> a1(x1,x2);
    cout<<a1.x1<<" "<<a1.x2<<endl;
    cout<<sizeof(A<T>)<<endl;
}

int main(){
    func(1,2);//1 2      8
    func<double>(1,2);// 1 2     16

}

非约束模板友元函数

  • 在类内部声明友元函数模板,友元函数的模板形参与类模板的形参没有关系,此时友元函数为类模板的非约束模板友元函数
#include <iostream>

using namespace std;

template <class T>
void func(T x1, T x2);

template <class T>
class A{
private:
    T x1,x2;
public:
    A(T x1, T x2):x1(x1),x2(x2){}

    template<class U,class V>
    friend void func(U u, V v);
};

template <class U, class V>
void func(U u, V v){
    cout<<u.x1<<endl;
    cout<<v.x1<<endl;
}

int main(){
    A<int> a1(1,2);
    A<double> a2(2.3,4.5);
    func(a1,a2);//1  2.3
}

模板的特化

  • 模板特化:在原模板类的基础上,针对特殊类型所进行的特殊化的实现,分为函数模板特化和类模板特化

类模板特化

  • 类模板的特化分为全特化和偏特化
    • 全特化:对类模板参数列表的类型全部都确定
    • 偏特化:对类模板的参数列表中的部分参数进行确定化。分为部分特化和参数进一步限制
#include <iostream>

using namespace std;


template <class A, class B>
class C{
public:
    C(){
        cout<<"template<class A, class B> class C"<<endl;
    }
};

//全特化
template <>
class C<int,double>{
public:
    C(){
        cout<<"template<> class C<int,double>"<<endl;
    }
};

//偏特化
template <class A>
class C<A,int>{
public:
    C(){
        cout<<"template<class A> class C<A,int>"<<endl;
    }
};

//偏特化不一定指的是特化部分参数,而是对模板类型的进一步限制
template <class A, class B>
class C<A*,B*>{
public:
    C(){
        cout<<"template<class A,class B> class C<A*,B*>"<<endl;
    }
};

int main(){
    C<int,int> c1;//template<class A> class C<A,int>
    C<double,double> c2;//template<class A, class B> class C
    C<int,double> c3;//template<> class C<int,double>
    C<int*,double> c4;//template<class A, class B> class C
    C<int*,double*> c5;//template<class A,class B> class C<A*,B*>
}

函数模板特化文章来源地址https://www.toymoban.com/news/detail-476795.html

  • 函数模板只支持全特化,不支持偏特化
#include <iostream>

using namespace std;

template <class T1,class T2>
int compare(const T1& v1, const T2& v2){
    cout<<"template <class T>"<<endl;
    return 0;
}

template <>
int compare<int,int>(const int& v1, const int& v2){
    cout<<"template<>"<<endl;
    return 0;
}

//不支持偏特化
//template <class T1>
//int compare<T1,int>(const T1& v1, const int& v2){
//    cout<<"template<class T1>"<<endl;
//    return 0;
//}

int main(){
    compare(1,1);//template<>
    compare(1.2,2.3);//template <class T>
}
  • 但是函数偏特化的功能也不是不能实现,并且有两种方式进行实现
//方式1
//将第二个参数为int的情况排除掉
//然后再写一个专门的一个参数的模板,这样可以实现函数模板的功能
#include <iostream>
#include <type_traits>

template <typename A, typename B>
typename std::enable_if<!std::is_same<B, int>::value>::type f(A a, B b) {
    std::cout << "template <typename A, typename B>" << std::endl;
}

template <typename A>
void f(A a, int b) {
    std::cout << "template <typename A>" << std::endl;
}

int main() {
    f(10, 5);  // template <typename A>
    f(10, 5.5);  // template <typename A, typename B>
    return 0;
}
//方式2
//使用结构体进行封装
#include <iostream>

using namespace std;

template<class A,class B>
struct C{
    C(A a,B b){}
    void operator()() {
        std::cout << "template<class A,class B>" << std::endl;
    }
};
template <typename A>
struct C<A,int>{
    C(A a,int b){}
    void operator()() {
        std::cout << "template <typename A>" << std::endl;
    }
};

int main(){
    C<int,int>(10,5)();//template <typename A>
    C<int,double>(10,5.5)();//template<class A,class B>
    return 0;
}

到了这里,关于c++ 模板详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【C++】模板进阶—非类型模板参数、模板特化及模板的分离编译

    🚀 作者简介:一名在后端领域学习,并渴望能够学有所成的追梦人。 🚁 个人主页:不 良 🔥 系列专栏:🛸C++  🛹Linux 📕 学习格言:博观而约取,厚积而薄发 🌹 欢迎进来的小伙伴,如果小伙伴们在学习的过程中,发现有需要纠正的地方,烦请指正,希望能够与诸君一同

    2024年02月16日
    浏览(39)
  • 【C++学习】模板进阶——非类型模板参数 | 模板的特化 | 分离编译

    🐱作者:一只大喵咪1201 🐱专栏:《C++学习》 🔥格言: 你只管努力,剩下的交给时间! 模板我们之前一直都在使用,尤其是在模拟STL容器的时候,可以说,模板给类增加了更多的可能性,是C++最重要的部分之一。下面本喵来更深入的讲解一下模板。 在上面代码中,创建了

    2023年04月13日
    浏览(38)
  • 【C++初阶(十)】C++模板(进阶) ---非类型模板参数、模板的特化以及模板的分离编译

    本专栏内容为:C++学习专栏,分为初阶和进阶两部分。 通过本专栏的深入学习,你可以了解并掌握C++。 💓博主csdn个人主页:小小unicorn ⏩专栏分类:C++ 🚚代码仓库:小小unicorn的代码仓库🚚 🌹🌹🌹关注我带你学习编程知识 模板参数可分为类型形参和非类型形参。 类型形

    2024年01月18日
    浏览(38)
  • 【C++】泛型编程 ① ( 函数模板 | 函数模板概念 | 函数模板意义 | 函数模板定义语法 | 函数模板调用语法 | 显式类型调用 | 自动类型推导 )

    在 C++ 语言中 , 泛型编程 的 核心就是 函数模板 和 类模板 ; 函数模板 Function Template 是 C++ 语言 中的 重要特性 ; 函数模板概念 : 建立一个 \\\" 通用函数 \\\" , 不指定该函数的 函数返回值类型 和 函数参数类型 , 仅使用 \\\" 虚拟类型 \\\" 代表 上述 两种类型 , 该 \\\" 通用函数 \\\" 就是 \\\" 函数模

    2024年02月19日
    浏览(39)
  • 【C++】泛型编程 ③ ( 函数模板 与 普通函数 调用规则 | 类型匹配 | 显式指定函数模板泛型类型 )

    上一篇博客 【C++】泛型编程 ② ( 函数模板与普通函数区别 ) 中 , 分析了 函数参数 类型匹配 下的 普通函数 与 函数模板 的调用规则 ; 为 函数模板 重载了 普通函数 , 普通函数有指定的类型 ; 传入实参 , 调用 普通函数 还是 模板函数 , 是有一定的规则的 ; 普通函数 与 传入实

    2024年02月21日
    浏览(43)
  • 小议C++函数签名与模板返回类型

    题记:什么事情都要追问一个为什么,真正理解了为什么,才能活学活用。 下面的代码能编译通过吗? 答案肯定是编译不过。因为下面两个函数的“签名”是一样的: 在 C++ 语言中,函数签名包含函数名称、函数参数类型、函数参数个数等信息,但是不包含返回值类型。 下

    2024年02月08日
    浏览(45)
  • C++中使用构造函数进行类型转换

    可给类提供重载的构造函数,即接受一个或多个参数的构造函数。这种构造函数常用于进行类型转换。请看下面的 Human 类,它包含一个将整数作为参数的重构构造函数: 这个构造函数让您能够执行下面的转换: 这样的转换构造函数让您能够执行隐式转换: 函数 DoSothing(Hum

    2024年02月04日
    浏览(35)
  • C++核心编程——详解函数模板

    纵有疾风起,人生不言弃。本文篇幅较长,如有错误请不吝赐教,感谢支持。 ①为什么有模板? 在C++程序中,声明变量、函数、对象等实体时,程序设计者需要指定数据类型,让编译器在程序运行之前进行类型检查并分配内存,以提高程序运行的安全性和效率。 但是这种强

    2024年02月09日
    浏览(39)
  • C++——详解类模板与友元函数

    纵有疾风起,人生不言弃。本文篇幅较长,如有错误请不吝赐教,感谢支持。 模板类的友元函数有三类: 1)非模板友元函数:友元函数不是模板函数,而是利用模板类参数生成的函数。 2)约束模板友元函数:模板类实例化时,每个实例化的类对应一个友元函数。 3)非约束

    2024年02月11日
    浏览(37)
  • Django的render()函数的三个主要参数详解,特别是第三个字典类型的参数context

    当在Django中使用 render() 函数时,它有三个主要参数: request , template_name ,和 context 。第三个参数,即 context ,是一个字典,用于将数据传递给模板以进行渲染。 在下面的代码中: request : 这是视图函数接收到的用户请求对象,包含了用户的HTTP请求信息,例如请求方法、G

    2024年02月11日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包