C++ 模板 详细解析

已于 2022-07-20 20:10:04 修改
阅读量307 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2022-06-20 16:56:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangcheng_BI/article/details/125374254
版权
本文深入探讨了C++中的模板概念，包括函数模板和类模板的定义、调用规则及其与普通函数的区别。详细阐述了模板的局限性，如自定义类型的具体化需求。同时，介绍了类模板的特性，如成员函数的延迟创建，以及如何作为函数参数、在继承中的应用。此外，还讨论了类模板成员函数的外部实现和友元函数的内外部实现。通过实例展示了模板在实际编程中的广泛应用。
摘要由CSDN通过智能技术生成

目录

模板定义：

函数模板：

定义语法：

普通函数与函数模板区别：

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

局限性：

类模板：

定义：

类模板与函数模板的区别：

类模板对象作函数参数：

类模板与继承：

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

类模板份文件实现:

类模板友元函数内外实现：

模板定义：

函数模板不是一个实在的函数，编译器不能为其生成可执行代码。定义函数模板后只是一个对函数功能框架的描述，当它具体执行时，将根据传递的实际参数决定其功能。模板分为函数模板和类模板。

函数模板：

定义语法：

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

注意:在使用模板时，必须要能够推导出一致的数据类型T;模板必须要确定T的数据类型。其有两种调用方式：自动类型推导和显示指定类型俩种方式。

#include<iostream>
using namespace std;
template<typename T>//声明一个模板，告诉编译器T是一个通用数据类型 
    void myswap(T &a,T &b)
    {
        T temp=a;
        a=b;
        b=temp;
    } 
void test()
{
    int a=1;
    int b=2;
    myswap<int>(a,b);//自动类型推导
    cout<<a<<" "<<b<<endl;
    myswap(a,b);//显示指定类型
    cout<<a<<" "<<b<<endl;

}
template<typename T>
void func()
{
    cout<<"func()"<<endl;
}
int main()
{ 
    func<int>();
    test();
    return 0;
}

普通函数与函数模板区别：

1.普通函数可以发生隐式类型转换
2.函数模板若采用自动类型推导，则不能发生隐式类型转换
3.函数模板若采用显示指定类型，则可以发生隐式转换

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

1.如果都可以调用，则优先调用普通函数；
2.可以通过空模板参数列表强制调用函数模板
3.函数模板也可以发生重载
4.如果函数模板可以产生更好的匹配，则优先调用函数模板

#include <iostream>
using namespace std;
void func(int a ,int b)
{
    cout<<"普通函数"<<endl;
}

template<typename T>
void func(T a,T b)
{
    cout<<"函数模板"<<endl;
}

template <typename T>
void func(T a,T b,T c)
{
    cout<<"函数模板重载"<<endl;
}


int main()
{
    int a=10;
    int b=20;
    int c=30;
    func(a,b);//普通函数
    func<>(a,b);//函数模板
    func(a,b,c);//函数模板重载
    char d='c';
    char e='e';
    func(e,d);//函数模板可以实现更好的匹配
    return 0;


}

局限性：

模板函数并不是万能的，特别是对于自定义数据类型，这个时候我们应该使用具体化的函数模板。

#include <iostream>
#include<string>
using namespace std;
class person
{
    public:
    string name;
    int age;
    person(string name,int age)
    {
        this->age=age;
        this->name=name;
    }
};
template<typename T>
bool mycompare(T &a,T &b)
{
    return 0;
}

template<> bool mycompare(person &a,person &b)//具体化函数模板来调用person自定义数据类型
{
    if (a.age==b.age&& a.name==b.name)
    {
        cout<<"相等"<<endl;
        return true;
    }
    else
    {
        cout<<"不相等"<<endl;
        return false;
    }
}

int main()
{
    person p1("张三",20);
    person p2("李四",20);
    bool res=mycompare(p1,p2);
    return 0;
}

类模板：

定义：

template<class T>

类模板与函数模板的区别：

1.类模板没有自动类型推导的使用方式
2.类模板在模板参数列表中可以有默认参数

#include <iostream>
#include<string>
using namespace std;
template<class Nametype,class Agetype=int>//可以有默认参数
class Person
{
    public:
    Person(Nametype name,Agetype age)
    {
       this-> name=name;
       this->age=age;
 
   }
   void print()
   {
       cout<<this->age<<" "<<this->name<<endl;
   }
   Nametype name;
   Agetype age;
};

int main()
{
    Person <string,int> p1("赵四",42);//不能Perosn p("赵四",42);
    Person<string>p2("刘能",40);
    p1.print();
    p2.print();
    return 0;
}

类模板中成员函数的创建时机：普通类的成员函数一开始就被创建，而类模板要在调用时才会创建

类模板对象作函数参数：

1.指定传入类型
2.参数模板化
3.整个类模板化

#include <iostream>
#include<string>
using namespace std;
template<class T1,class T2>
class Person
{
    public:
    T1 name;
    T2 age;
    Person(T1 name,T2 age)
    {
        this->name=name;
        this->age=age;
    }
    void print()
    {
        cout<<"姓名"<<name<<"年龄"<<age<<endl;
    }
};
void printperson1(Person<string,int>p)//指定传入类型
{
    cout<<"姓名"<<p.name<<"年龄"<<p.age<<endl;
}
template<class T>
void printperson2(T p)//整个类模板化
{
    cout<<"姓名"<<p.name<<"年龄"<<p.age<<endl;
}
template<class T1,class T2>//参数模板化
void printperson3(Person<T1,T2>p)
{

    cout<<"姓名"<<p.name<<"年龄"<<p.age<<endl;
}
 int main()
 {
     Person<string,int>p1("赵四",43);
     printperson1(p1);
     Person<string ,int>p2("刘能",42);
     printperson2(p2);
     Person<string,int>p3("谢广坤",44);
     printperson3(p3);
     return 0;
 }

类模板与继承：

1.当子类继承的父类是一个模板时，子类在声明的时候，需要指出父类中T的类型
2.如果想要灵活指出父类中T的类型，子类也需要变为类模板

#include<iostream>
#include<string>
using namespace std;
 template<class T>
 class base
 {
     T m;
 };

class son1:public base<int>
{

};

template<class T1,class T2>
class son2:public base<T2>
{
    T1 obj;
};


 int main()
 {
     son1 s1;
     son2<int ,char>s2;
     return 0;
 }

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

#include <iostream>
#include<string>
using namespace std;
template<class T1,class T2>
class Person
{
    public:
    T1 name;
    T2 age; 
    Person(T1 name,T2 age);
    void showperson();
};
template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age)
{
    this->age=age;
    this->name=name;
}
template<class T1,class T2>
void Person<T1,T2>::showperson()
{
    cout<<name<<" "<<age<<endl;
}
int main()
{
    Person <string ,int>p("Tom",10);
    p.showperson();
    return 0;

}

类模板分文件实现:

1.直接引用源文件
2.源文件和头文件写一起，成.hpp文件

方法一：

//person.h
#pragma once
#include<iostream>
#include<string>
using namespace std;
template<class T1,class T2>
class Person
{
    public:
    T1 name;
    T2 age;
    Person(T1 name,T2 age);
    void showperson();
};

//person.cpp
#include "person.h"
#include<iostream>
using namespace std;
template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age)
{
    this->age=age;
    this->name=name;
}
template<class T1,class T2>
void Person<T1,T2>::showperson()
{
    cout<<name<<" "<<age<<endl;
}
#include<iostream>
#include"person.cpp"
using namespace std;

int main()
{
    Person <string ,int>p("Jack",10);
    p.showperson();
    return 0;

}

方法二：

//person.hpp

#pragma once
#include<iostream>
#include<string>
using namespace std;
template<class T1,class T2>
class Person
{
    public:
    T1 name;
    T2 age;
    Person(T1 name,T2 age);
    void showperson();
};

template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age)
{
    this->age=age;
    this->name=name;
}
template<class T1,class T2>
void Person<T1,T2>::showperson()
{
    cout<<name<<" "<<age<<endl;
}
#include<iostream>
#include"person.hpp"
using namespace std;

int main()
{
    Person <string ,int>p("Jack",10);
    p.showperson();
    return 0;

}

类模板友元函数内外实现：

另外，还有类模板友元函数的类内类外实现，类内友元函数实现和上面的一样，照猫画虎而已，但类外实现有些许复杂。

#include <iostream>
#include<string>
using namespace std;
template<class T1,class T2>
class Person;
template<class T1,class T2>
void print_person2(Person<T1,T2>p)
{
    cout<<p.name<<" "<<p.age<<endl;
}
template <class T1,class T2>
class Person
{
    friend void print_person1(Person<T1,T2> p)//类内实现
    {
        cout<<p.name<<" "<<p.age<<endl;
    }
    public:
    Person(T1 name ,T2 age)
    {
        this->name=name;
        this->age=age;
    }
    friend void print_person2<>(Person<T1,T2>p);//类外实现,需要加载空模板参数列表，而且需要让编译器提前知道这个函数的存在
    private:
    T1 name;
    T2 age;
};

void test01()
{
    Person<string ,int>p1("Tom",10);
    print_person1(p1);
}
void test02()
{
    Person <string ,int>p2("Jack",6);
    print_person2(p2);
}
int main()
{
    test01();
    test02();
    return 0;
}

C++模板详解
程序猿老樊的博客
05-31 2441
一．C++模板的定义：        模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。 模板是一种对类型进行参数化的工具； 二．使用模板的目的： 　  能够使得程序员编写与类型无关的代码。比如编写了一个交换两个整型int 类型的swap函数，这个函数就只能实现int 型，对double，字符这些
C++ | 模板详解
ZY-JIMMY
03-10 1822
文章目录模板的基本概念概述什么是模板什么是函数模板什么是类模板模板的实例化模板的参数列表模板类型参数模板非类型参数模板的特例化（特化/专用化）函数模板类模板 模板的基本概念 概述 问题：怎么理解C++里边的多态？ 静态的多态(编译时期的多态)：函数重载，模板 动态的多态(运行时期的多态)：继承中的虚函数 模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模...
详解 C++中的模板
最新发布
我叫柱子哥
09-24 1448
这篇文章主要介绍C++中的模板。模板是一系列相关函数的模型或样板，这些函数的源代码形式相同，只是所针对的数据类型不同。在开发过程中，我们经常遇到这种情况，有两个或者两个以上的函数，其功能是相同的，仅仅是数据类型的不同。上面的三个函数都实现了对数据的加法运算，唯一不同的是参数类型不同。这样的函数可以采用函数模板实现简便化。类模板是通过引入模板参数来定义类的。在类模板的声明中，使用 template 关键字标识模板类型参数，然后在类的定义中可以使用这些模板参数，就像使用普通的数据类型一样。
c++中模板详解
测试0901-1
10-27 288
前言： 在C++ template中已经详细的通过实践说明了c++ template的用法，也在typename 和class在template中的区别中解释了template中typename和class的区别。 这一文结合自己的想法做一个总结。 1、 函数模板和模板函数 函数模板是...
C++中函数模板的用法详细解析
01-20
本文将详细解析C++中函数模板的用法。 函数模板的基本概念是创建一个通用函数模板，其中形参的类型并不具体指定，而是使用一个占位符（如`typename T`或`class T`）来代表。当调用函数模板时，编译器会根据传入的...
C++函数模板与类模板实例解析
01-20
本文针对C++函数模板与类模板进行了较为详尽的实例解析，有助于帮助读者加深对C++函数模板与类模板的理解。具体内容如下： 泛型编程（Generic Programming）是一种编程范式，通过将类型参数化来实现在同一份代码上...
C++进阶(十) : 模板【详解】
王木木
09-09 2042
模板是C++的高级特性，掌握模板的使用，将大大提升C++的开发效率，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型，模板分为两大类，即函数模板、类模板，C++已经为我们提供了标准模板库（STL），在定义模板时，经常看到template，它为模板关键字，尖括号’&amp;lt;&amp;gt;’中为模板参数，模板参数主要由两种，一种是模板类型参数，例如i...
模板
WINCOL的专栏
10-16 788
1. 模板的概念。我们已经学过重载(Overloading)，对重载函数而言,C++的检查机制能通过函数参数的不同及所属类的不同。正确的调用重载函数。例如，为求两个数的最大值，我们定义MAX()函数需要对不同的数据类型分别定义不同重载(Overload)版本。//函数1.int max(int x,int
「C++」模板详解
NanlinW的博客
11-19 373
文章目录模板引言模板基本概念什么是模板？模板分类函数模板函数模板概念函数模板使用方式函数模板实例化函数参数的匹配原则类模板类模板基本概念类模板使用方式类模板实例化 模板引言 假如现在需要实现一个交换整数的函数，很简单就能实现，但是如果没有说交换类型，那么可能需要写各种类型的重载，函数重载虽然可以实现，但是这么做很麻烦，函数的复用性很低，且代码的可维护性比较低，一个出错可能让所有重载都错。 void Swap(int& left, int& right) { int temp =
C++ — 模板的详解
goodman_lqifei的博客
04-10 240
 我们经常听到C++，模板这个概念。就我自己的理解，模板其实就是为复用而生，模板就是实现代码复用 机制的一种工具，它可以实现类型参数化，即把类型定义为参数，从而实现了真正的代码可重用性。模版 可以分为两类，一个是函数模版，另外一个是类模版。 举个最简单的例子，当你编写一个交换int型的swap函数，当你要交换double就得重新写一个，这里就尴尬 了。使用模板的目的就是要让这
C++：模板详解（函数模板+类模板）
Moomin的博客
04-08 436
模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。 模板是创建泛型类或函数的蓝图或公式。库容器，比如迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。 每个容器都有一个单一的定义，比如 向量，我们可以定义许多不同类型的向量，比如 vector 或 vector 。可以使用模板来定义函数和类， 函数模板 template <class type> re...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值