C++中的Template

最新推荐文章于 2024-11-05 21:58:11 发布
最新推荐文章于 2024-11-05 21:58:11 发布
阅读量160 收藏
点赞数
分类专栏： c++ 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ThePaK/article/details/133223701
版权

模板的概念

建立通用的模具，大大提高复用性

模板不可直接使用

函数模板

函数模板语法

函数模板作用：

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

语法：

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

解释：

template -- 声明创建模板

typename -- 表明其后面的符号是一种数据类型，可以用class代替

T -- 通用的数据类型，名称可替换，通常为大写字母

//利用模板提供通用的交换函数
template<typename T>
void mySwap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
void test01()
{
    int a = 10;
    int b = 20;
    //利用模板实现交换
    //1. 自动类型推导
    mySwap(a, b);
    cout << "a = " << a << ", b = " << b << endl;
    //2. 显示指定类型
    mySwap<int>(a, b);
    cout << "a = " << a << ", b = " << b << endl;
    double c = 2.2;
    double d = 2.1;
    mySwap(c, d);
    cout << "c = " << c << ", d = " << d << endl;
}

注意事项：

自动类型推导，必须推导出一致的数据类型T，才可以使用

模板必须要确定出T的数据类型，才可以使用

template<typename T>
void mySwap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
test02()
{
    int a = 1;
    char b = 'c';
    mySwap(a, b);//推导不出一致的数据类型
}
template<typename T>
void func()
{
}
test02()
{
    func<int>(); //必须指定T的数据类型，不能只写func();
}

函数模板案例

案例描述：

//利用模板提供通用的交换函数
template<typename T>
void mySwap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
//打印数组模板
template<typename T>
void myPrint(T arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}
template<typename T>
void sort(T arr[], int len)
{
    for (int i = 0; i < len; ++i)
    {
        int max = i;
        for (int j = i + 1; j < len; ++j)
        {
            if (arr[max] < arr[j])
            {
                mySwap(arr[max], arr[j]);
            }
        }
        if (max != i)
        {
            mySwap(arr[max], arr[i]);
        }
    }
}
void test01()
{
    //测试char数组
    char charArr[] = "badcfe";
    int len = sizeof(charArr) / sizeof(char);
    sort(charArr, len);
    myPrint(charArr, len);

    //测试int数组
    int intArr[] = { 0, 5, 6, 4, 2, 8,5,9,3 };
    len = sizeof(intArr) / sizeof(int);
    sort(intArr, len);
    myPrint(intArr, len);
}

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

//普通函数
int myAdd01(int a, int b)
{
    return a + b;
}
//函数模板
template<typename T>
T myAdd02(T a, T b)
{
    return a + b;
}
void test01()
{
    int a = 10;
    char b = 'b'; //a -97, b - 98
    cout << myAdd01(a, b) << endl;
    //自动类型推导，不会发生隐式类型转换
    //cout << myAdd02(a, b) << endl; //报错
    //显示指定类型，会发生隐式类型转换
    cout << myAdd02<int>(a, b) << endl; 
}

建议使用显示指定类型方式

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

调用规则：

//普通函数
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 test01()
{
    int a = 10;
    int b = 20;
    myPrint(a, b); //调用普通函数
    //空模板参数列表
    myPrint<>(a, b);
    myPrint(a, b, 12);
    //更好的匹配
    char c = 'a';
    char d = 'a';
    myPrint(c, d); //调用函数模板
}

模板的局限性

class Person
{
public:
    Person(string name, int age)
    {
        m_Name = name;
        m_Age = age;
    }
    //方法1. 重载加号
    /*bool operator==(Person p)
    {
        if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
        {
            return true;
        }
        return false;
    }*/
    string m_Name;
    int m_Age;
};
template<typename T>
bool myCompare(T a, T b)
{
    if (a == b)
    {
        return true;
    }
    else
    {
        return false;
    }
}
//方法2. 为特定类型提供具体的化的模板
template<> bool myCompare(Person a, Person b)
{
    if (a.m_Name == b.m_Name && a.m_Age == b.m_Age)
    {
        return true;
    }
    else
    {
        return false;
    }
}
void test01()
{
    Person p1("Tom", 10);
    Person p2("Tom", 10);
    bool ret = myCompare(p1, p2);
    if (ret)
    {
        cout << "p1==p2" << endl;
    }
    else
    {
        cout << "p1!=p2" << endl;
    }
}

类模板

类模板语法

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

语法：

template<typename T>
类

解释：

template -- 声明创建模板

typename -- 表明其后面的符号是一种数据类型，可以用class代替

T -- 通用的数据类型，名称可替换，通常为大写字母

template<typename nameType, typename ageType>
class Person
{
public:
    Person(nameType name, ageType age)
    {
        m_Name = name;
        m_Age = age;
    }
    void showPerson()
    {
        cout << "名称：" << this->m_Name << ", 年龄：" << this->m_Age << endl;
    }
    nameType m_Name;
    ageType m_Age;
};


void test01()
{
    Person<string, int> p1("Tom", 10);
    Person<string, int> p2("Joy", 20);
    p1.showPerson();
    p2.showPerson();

}

类模板与函数模板区别

//类模板与函数模板区别  int 默认参数
template<typename nameType, typename ageType = int>
class Person
{
public:
    Person(nameType name, ageType age)
    {
        m_Name = name;
        m_Age = age;
    }
    void showPerson()
    {
        cout << "名称：" << this->m_Name << ", 年龄：" << this->m_Age << endl;
    }
    nameType m_Name;
    ageType m_Age;
};
void test01()
{
    //1. 类模板没有自动类型推导使用方式，函数模板有
    //Person p("Tom", 10); //错误，无法用自动类型推导
    Person<string, int> p1("Tom", 10); //正确，只能用显示指定类型
    p1.showPerson();
    //2. 类模板在模板参数列表中可以有默认参数，函数模板不可以有
    Person<string>p2("Joy", 20);
    p2.showPerson();
}

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

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才创建
class Person1
{
public:
    void showPerson1()
    {
        cout << "Person1 show" << endl;
    }
};
class Person2
{
public:
    void showPerson2()
    {
        cout << "Person2 show" << endl;
    }
};
template<typename T>
class MyClass
{
public:
    T obj;
    //类模板中的成员函数，并不是一开始就创建
    void func1()
    {
        obj.showPerson1();
    }
    void func2()
    {
        obj.showPerson2();
    }
};
void test01()
{
    MyClass<Person1> p;
    p.func1();
    //p.func2(); //编译会出错，说明函数调用才会去创建成员函数
}

类模板对象做函数参数

template<typename T1, typename T2>
class Person
{
public:
    Person(T1 name, T2 age)
    {
        m_Name = name;
        m_Age = age;
    }
    void showPerson()
    {
        cout << "姓名：" << this->m_Name << "，年龄：" << this->m_Age << endl;
    }
    T1 m_Name;
    T2 m_Age;
};
//方法1. 直接显示对象的数据类型
void printPerson(Person<string, int> p)
{
    p.showPerson();
}
void test01()
{
    Person<string, int> p1("孙悟空", 100);
    printPerson(p1);
}
//方法2. 参数模板化
template<typename T1, typename T2>
void printPerson2(Person<T1, T2>& p)
{
    p.showPerson();
    cout << "T1的数据类型为：" << typeid(T1).name() << endl;
    cout << "T2的数据类型为：" << typeid(T2).name() << endl;
}
void test02()
{
    Person<string, int> p1("沙和尚", 40);
    printPerson2(p1);
}
//方法3. 整个类模板化
template<typename T>
void printPerson3(T & p)
{
    p.showPerson();
    cout << "T的数据类型为：" << typeid(T).name() << endl;
}
void test03()
{
    Person<string, int> p1("唐僧", 30);
    printPerson3(p1);
}

类模板与继承

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

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 s;
};

void test01()
{
    Son p1;
    Son2<int, char> S2;
}

类模板成员函数类外实现

template<typename T1, typename T2>
class Person
{
public:
    Person(T1 name, T2 age);
    void showPerson();
    T1 m_Name;
    T2 m_Age;
};
//构造函数 类外实现
template<typename T1, typename T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
    m_Name = name;
    m_Age = age;
}
//成员函数 类外实现
template<typename T1, typename T2>
void Person<T1, T2>::showPerson()
{
    cout << "姓名：" << this->m_Name << "，年龄：" << this->m_Age << endl;
}
void test01()
{
    Person<string, int> P("tom", 20);
    P.showPerson();
}

类模板份文件编写

//第一种解决方式，直接包含 源文件
//#include "person.cpp"
//第二种解决方式，将.h和.cpp内容写到一起，将后缀名改为.hpp文件，类模板
#include "person.hpp"
void test01()
{
    Person<string, int> P("tom", 20);
    P.showPerson();
}

person.hpp

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

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

类模板与友元

全局函数类内实现：直接在类内声明友元即可

全局函数类外实现：需要提前让编译器知道全局函数的存在

//2. 全局函数配合友元 类外实现
//先做函数模板声明
template<class T1, class T2>
class Person;
//如果声明了函数模板，可以将实现写到后面，
//否则需要将实现体写到类的前面让编译器提前看到
template<class T1, class T2>
void printPerson2(Person<T1, T2> &p);
    
template<class T1, class T2>
class Person
{
    //1. 全局函数配合友元 类内实现
    friend void printPerson(Person<T1, T2> &p)
    {
        cout << "姓名：" << p.m_Name << "，年龄：" << p.m_Age << endl;
    }
    //全局函数配合友元 类外实现
    //加空模板参数列表
    //如果全局函数是类外实现，需要让编译器提前知道这个函数的存在
    friend void printPerson2<>(Person<T1, T2> &p);
public:
    Person(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
private:
    T1 m_Name;
    T2 m_Age;
};
template<typename T1, typename T2>
void printPerson2(Person<T1, T2>& p)
{
    cout << "姓名：" << p.m_Name << "，年龄：" << p.m_Age << endl;
}

void test01()
{
    Person<string, int> P("tom", 20);
    printPerson(P);
    Person<string, int> P2("joy", 34);
    printPerson2(P2);
}

类模板案例

ThePaK
关注
专栏目录
c++中template对字符串的处理方法
09-04
在C++编程语言中，`template`是一种泛型编程机制，允许我们编写可应用于多种数据类型的函数或类。模板能够极大地提高代码的复用性和灵活性，使得程序员无需为每种特定类型都编写相同功能的代码。当我们谈论`template...
C++中template的使用
05-08
在C++编程语言中，`template`是一种强大的特性，它允许程序员编写通用代码，从而能够处理多种数据类型而无需重复代码。本文将深入探讨如何在C++中使用`template`来创建类模板和函数模板，这将极大地提高代码的复用性...
C++--模板（template）详解—— 函数模板与类模板
m0_73634434的博客
09-22 998
class类模板名//类内成员定义类成员函数声明和定义分离class Datepublic:Date();int _month;int _day;//普通类：类名和类型一样//类模板：类名和类型不一样//类模板 类名：Date 类型：Date (类型是类名加):_year(1),_month(1),day(1)类模板中函数放在类外进行定义时，需要加模板参数列表。
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++中Template的用法
king9666的博客
01-16 1959
模板（Template） 指C++程序设计设计语言中采用类型作为参数的程序设计，支持通用程序设计。C++ 的标准库提供许多有用的函数大多结合了模板的观念，如STL以及IO Stream。 函数模板 函数模板定义一族函数。 //template1.cpp #include <iostream> template<typename T> void swap(T &a,...
C++中 模板Template的使用
顺其自然~专栏
01-13 1万+
1、在c++Template中非常多地方都用到了typename与class这两个关键字，并且好像能够替换，是不是这两个关键字全然一样呢? 答：class用于定义类，在模板引入c++后，最初定义模板的方法为：template，这里class关键字表明T是一个类型。后来为了避免class在这两个地方的使用可能给人带来混淆，所以引入了typename这个关键字。它的作用同class一样表明后面的符号为一个类型。这样在定义模板的时候就能够使用以下的方式了： template.在模板定义语法中关键字class与ty
C++中的Template常见用法
GOLOJO的博客
06-04 1638
C++中的模板（template）是一种非常强大的工具，用于泛型编程和代码复用。模板可以分为函数模板、类模板、别名模板、变量模板、模板模板参数等。这些模板能够处理任意类型的数据，提高代码的灵活性和可重用性。
C++模板（template）
TU^的博客
08-04 2701
【优点】1、 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生2、 增强了代码的灵活性【缺陷】1、 模板会导致代码膨胀问题，也会导致编译时间变长2、 出现模板编译错误时，错误信息非常凌乱，不易定位错误。
C++模板（template）详解
2301_81261654的博客
03-09 8680
原因是在链接过程中，编译器找不到模板函数的定义，因为在使用模板时，.h文件中的模板的声明知晓了模板参数的类型，但在.cpp文件中的模版不知道，所以.cpp中模板的定义没法实例化,也就没法在编译阶段生成一份经过实例化的具体的代码，这将导致程序在链接阶段找不到模板函数的实现而报链接错误。这样一来，在调用Add函数的时候，其本质上是调用了上面的经过实例化的模板函数，这样做的好处就是，程序员就可以不用对每一种数据类型都去实现对应的函数，大大提高了效率，而且只实现这么一份通用的模板函数可以使其更易于维护。
c++中template的用法
zhong29的博客
09-18 9343
  https://blog.csdn.net/lezardfu/article/details/56852043#%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8 Template 基础篇-函数模板 为什么要有泛型编程 函数模板定义 普通函数模板 成员函数模板 为什么成员函数模板不能是虚函数virtual 实参推断 如何使用 ...
C++ template 的使用和技巧
qq_32639369的博客
03-22 1814
模板是泛型编程的基础，泛型编程即以一种独立于任何特定类型的方式编写代码。
C++ template的使用
weixin_39640298的博客
05-15 1万+
1、template的使用 C++ 的高级玩法，当然包含了模板。模板（template）是实现代码重用机制的一种工具，它可以实现类型参数化，把类型定义为参数（模板元编程），从而实现了真正的代码可重用性。 模板是用来批量生成功能和形式都几乎相同的代码的。编译器就能在需要的时候，根据模板自动生成程序的代码。从同一个模板自动生成的代码，形式几乎是一样的。 模板就像一个做饼干的模具，至于饼干是什么味道，则...
C++ Template 电子版 pdf
05-02
C++ Template之中的Template理念的三个方面：其本、其道、其用。本立道生、道以为用。本书以Template的基本概念和原理开始，辅以Template的高级概念，并使用一半篇幅讲述Template的设计和实际编程技法中的应用。语言...
算法基础-链表
August的专栏
11-05 233
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 338
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
最新发布
passer__jw767的博客
11-05 323
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 1996
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
二叉树(一)
m0_74340589的博客
11-05 448
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
c++中template编写
05-24
在 C++ 中，模板（template）是一种通用的程序设计工具，可以用来生成任意类型的代码，以满足不同的需求。模板可以用于函数、类、结构体等各种程序实体的定义中。 模板的基本语法为： ```c++ template T function...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值