C++中的Template

最新推荐文章于 2024-05-10 09:36:12 发布
最新推荐文章于 2024-05-10 09:36:12 发布
阅读量108 收藏
点赞数
分类专栏： 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++中template对字符串的处理方法
09-04
主要介绍了c++中template对字符串的处理方法,需要的朋友可以参考下
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的使用
顺其自然~专栏
01-13 1万+
1、在c++Template中非常多地方都用到了typename与class这两个关键字，并且好像能够替换，是不是这两个关键字全然一样呢? 答：class用于定义类，在模板引入c++后，最初定义模板的方法为：template，这里class关键字表明T是一个类型。后来为了避免class在这两个地方的使用可能给人带来混淆，所以引入了typename这个关键字。它的作用同class一样表明后面的符号为一个类型。这样在定义模板的时候就能够使用以下的方式了： template.在模板定义语法中关键字class与ty
C++中Template的用法
king9666的博客
01-16 1884
模板（Template） 指C++程序设计设计语言中采用类型作为参数的程序设计，支持通用程序设计。C++ 的标准库提供许多有用的函数大多结合了模板的观念，如STL以及IO Stream。 函数模板 函数模板定义一族函数。 //template1.cpp #include <iostream> template<typename T> void swap(T &a,...
C++模板（template）详解
2301_81261654的博客
03-09 2333
原因是在链接过程中，编译器找不到模板函数的定义，因为在使用模板时，.h文件中的模板的声明知晓了模板参数的类型，但在.cpp文件中的模版不知道，所以.cpp中模板的定义没法实例化,也就没法在编译阶段生成一份经过实例化的具体的代码，这将导致程序在链接阶段找不到模板函数的实现而报链接错误。这样一来，在调用Add函数的时候，其本质上是调用了上面的经过实例化的模板函数，这样做的好处就是，程序员就可以不用对每一种数据类型都去实现对应的函数，大大提高了效率，而且只实现这么一份通用的模板函数可以使其更易于维护。
c++中template的用法
zhong29的博客
09-18 9110
  https://blog.csdn.net/lezardfu/article/details/56852043#%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8 Template 基础篇-函数模板 为什么要有泛型编程 函数模板定义 普通函数模板 成员函数模板 为什么成员函数模板不能是虚函数virtual 实参推断 如何使用 ...
C++ template 模板详解
BadSheepC
07-14 2621
在这里，type 是函数所使用的数据类型的占位符名称。这个名称可以在函数定义中使用。其中template和class是关键字，class可以用typename 关键字代替，在这里typename 和class没区别，括号中的参数叫模板形参，模板形参和函数形参很相像，模板形参不能为空。一但声明了模板函数就可以用模板函数的形参名声明类中的成员变量和成员函数，即可以在该函数中使用内置类型的地方都可以使用模板形参名。模板形参需要调用该模板函数时提供的模板实参来初始化模板形参...
C++ template的使用
weixin_39640298的博客
05-15 1万+
1、template的使用 C++ 的高级玩法，当然包含了模板。模板（template）是实现代码重用机制的一种工具，它可以实现类型参数化，把类型定义为参数（模板元编程），从而实现了真正的代码可重用性。 模板是用来批量生成功能和形式都几乎相同的代码的。编译器就能在需要的时候，根据模板自动生成程序的代码。从同一个模板自动生成的代码，形式几乎是一样的。 模板就像一个做饼干的模具，至于饼干是什么味道，则...
C++中template的使用以及常见问题
reason的博客
01-23 2635
原文：https://www.cnblogs.com/jiading/p/9838024.html 模板的声明有两种：template &lt;typename Type&gt;或者template&lt;class Type&gt;。虽然建议使用typename以避免二义性，但是这两种实际上是都可以的。 模板只作用于其下方的一个类或者函数，所以在类外实现成员函数时要对每一个函数都在之前进行模...
C++中的template
木盏
10-19 1721
今天面一家独角兽公司的时候，被面试官问到这个问题。所幸之前的C++基础还记得一些，基本回答上来了。于是写一个blog来强化一下。 函数模板 函数模板实际上，解决了一个函数多态性过程中所遇到的问题。实际上主要解决的就是形参类型不一的问题。 因为C++是一种静态语言，不像Python那样数据类型等运行起来了再确定，我们用函数或者用变量都必须确定类型。函数需要确定返回值类型，这就使得函数在使用起来...
C++ .template 关键字
Erick Lv的笔记
01-06 1846
template 关键字除了用于作为模板声明之外，还有一个作用，显式说明模板成员函数，这一点类似于typename 显式说明成员类型。给出代码实例： #include <iostream> template<typename T, size_t N> class Collection { public: template<size_t I> void setValue(T &&t) { data[I] = t; }
C++中template的使用
05-08
详细介绍了使用template制作类模板和函数模板的方法。
C++中的模板template小结
08-19
主要介绍了C++中的模板template的相关知识，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
C++ Template应用详解
08-31
本篇文章主要介绍了C++ Template应用详解，模板（Template）指C++程序设计设计语言中采用类型作为参数的程序设计，支持通用程序设计。
Java 7大排序
最新发布
m0_74270127的博客
05-10 704
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
算法基础01一快速排序，归并排序，二分
m0_74340589的博客
05-06 143
假设两个有效序列 两个指针指向开头 新数组来存答案。1.快速 排序 基于分治。
StarryCoding 算法小白周赛2 题解与代码（含视频题解）
qq_29495615的博客
05-04 960
因为他会按照“拜访时间安排表”的顺序拜访每一位好友，而无法成功拜访某一好友时，必定是出现靠后拜访的时间早于靠前拜访的，或者两次拜访的时间相同，所以问题的本质就是判断数组是否。），应该删除这个数还是前一个数，因为我们想要的是让后面的数的合法值域更大，所以我们需要最小化留下的那个数，也就是说，如果靠后的数。如果某个数比前一个数小，那么肯定不行，我们需要考虑删去这个元素。如果大于，则最好不要更改，给后面的元素更多的空间。由于数的范围很小，假如这个数合法，我们直接从此数。,能保证加的数量是最少的，并且。
Golang | Leetcode Golang题解之第67题二进制求和
weixin_66442839的博客
05-04 655
Golang | Leetcode Golang题解之第67题二进制求和
【算法基础】第六章：贪心
m0_65787507的博客
05-07 887
给定 N个闭区间 [a,b]，请你在数轴上。输出选择的点的最小数量。位于区间端点上的点也算作区间内。① 所有区间按右端点从小到大排序② 遍历每一个区间，如果当前区间的左与前一个区间的右有交集，则只需要一个点就可以覆盖掉两个区间。
c++中template编写
05-24
在 C++ 中，模板（template）是一种通用的程序设计工具，可以用来生成任意类型的代码，以满足不同的需求。模板可以用于函数、类、结构体等各种程序实体的定义中。 模板的基本语法为： ```c++ template T function...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值