c++入门学习⑧——模板

#include<iostream>
#include<string>
using namespace std;
template<class T>
void Swap(T &a,T &b)
{
    T temp = b;
    b = a;
    a = temp;
}
void test1()
{
    int a = 1;
    int b = 2;
    Swap(a, b);
    cout << "a:" << a << endl;
    cout << "b:" << b << endl;
}
int main()
{
    test1();
    system("pause");
    return 0;
}

这里构建了一个函数模板——用于交换两个数的值

由这个代码，我们可以了解函数模板的语法以及用法：

先写这一行代码：

template<class T>或者是template<typename T>(注：这里的T可以换成其他的)

而下面紧接着的函数——就是所谓的模板函数，而在模板函数中传入参数是刚才定义的T类型
void Swap(T &a,T &b)
{
T temp = b;
a = temp;
b = a;
}

而在使用时，可以直接传入两个int类型的，在程序运行时，函数也会正常调用

使用方式

函数模板使用有两个方法：

自动类型推导
显示指定类型

第一种类型就是直接传入数据，函数模板会自己推导的

第二种类型就是调用函数时，直接在函数名之后加上<指定类型>

注意事项

当然刚才所介绍的语法以及调用并不是函数模板使用时的全部，它还有一些事项需要注意：

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

下面来用代码来分别讲解一下

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

当我在刚才的代码中加入一个double类型的数据，然后把它传入Swap函数，

结果它显示出错了——出错原因是这个函数模板自动推导出来的类型是int和double，但是T只能代表一个数据类型，这时候如果传入不同的数据类型，则会出错

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

这个条件很容易解释，如果一个函数的参数无法确定参数，那么如何对其进行运行呢？

函数模板和普通函数区别

普通函数调用可以发生隐式类型转换
函数模板用自动类型推导，不可以发生隐式类型转换
函数模板用显示指定类型，可以发生隐式类型转换

我们还是同样的一条一条解释：

1.普通函数调用可以发生隐式类型转换

注意：这个类型转换不是传入的所有的都会转化为对应数据类型的参数，要看情况。

代码示例：

#include<iostream>
using namespace std;
//普通函数调用可以发生隐式类型转换

int add(int a, int b)
{
    return a + b;
}
void test1()
{
    int a = 1;
    int b = 2;
    char c = 'c';
    cout << "a+b=" << add(a,b) << endl;//3
    cout << "a+c=" << add(a,c) << endl;//100
}
int main()
{
    test1();
    system("pause");
    return 0;
}

2.函数模板用自动类型推导，不可以发生隐式类型转换

当我们在上面的函数上添加一行代码template<class T>然后把所有int改为T，

就会发现，程序开始报错：

3.函数模板用显示指定类型，可以发生隐式类型转换

那函数模板可不可以发生隐形类型转换呢？——答案是可以

当我们使用显示指定类型，在函数调用时在函数名后面加上指定类型，

程序正常运行。

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

函数模板和普通模板的调用规则一样吗?

当普通函数和函数模板都可以实现时，调用谁呢?如果调用其中一个，那么另一个该怎么去调用呢？可以强制调用另一个吗？

我们先写个代码来看一下：

#include<iostream>
#include<string>
using namespace std;

template<class T>
T add(T a, T b)
{
    return a + b;
}
int add(int a, int b)
{
    return a + b + b;
}
void test1()
{
    int a = 1;
    int b = 2;
    cout << "a+b=" << add(a,b) << endl;//5
}
int main()
{
    test1();
    system("pause");
    return 0;
}

当函数模板和普通函数同时存在，而且传入参数都可以实现时，输出时，发现是——调用的是普通函数产生的结果。

由此产生第一条规则：

如果函数模板和普通函数都可以实现，优先调用普通函数

那如何在这种情况下调用函数模板呢？

——添加一个空模板参数列表<>

第二条规则：

可以通过空模板参数列表来强制调用函数模板

当调用时，函数模板是较于普通函数更好的匹配，则优先调用函数模板：

例如：

第三条规则是：

如果函数模板可以产生更好的匹配，优先调用函数模板

第四条规则是：

函数模板也可以发生重载

总结：

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

⭐注意：实际开发中不会同时出现这两个函数——避免二义性

局限性

当自定义数据类型使用模板函数时，会出错，这是因为函数模板有一定的局限性，它无法去判断自定义数据类型如何通过模板工作，因此遇到这种情况，我们该如何解决这个局限性呢？

这里有两种方法：

1.运算符重载，把运算符重载后，函数模板就可以让自定义数据类型正常使用了，因为系统直到了如何应对这个自定义数据了

2.具体化这个函数模板：template<> 返回值函数名（自定义数据类型函数参数）{函数体}

举例说明：

bool xd(person &p1, person &p2)
{
if (pl.m namep2.m name &&plmmagep2.m_age)
{
return true;
}
else
{
return false;
}
}

一般情况来说，使用第二种较为方便

类模板

介绍完函数模板，下面来介绍类模板。

注意：

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

语法

还是先写template <class/typedef T>

后面紧跟着类——为类模板

示例：

template<class A,class B>
class people
{
public:
    A m_age;
    B m_name;
};

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

⭐对于类模板来说，它的成员函数是与一般类相比有所区别

——创建时机不一样
普通类中的成员函数——开始时就可以创建
类模板中的成员函数——在调用时才创建

类模板实例化对象

#include<iostream>
#include<string>
using namespace std;

template<class T,class A>
class people
{
public:
    people(T age, A name)
    {
        this->m_age = age;
        this->m_name = name;
    }
    T m_age;
    A m_name;
};

void test1()
{
    people<int,string> a(12, "小红");
}
int main()
{
    test1();
    system("pause");
    return 0;
}

这么长的一段代码——其实重点就只有几行——

类名 <参数列表> 类对象名称（初始化内容）；

类模板实例化对象做函数参数

当类模板对象作为函数参数时，如何传入，其注意事项有哪些？

这里先介绍传入方式——有三种
1.指定传入的类型⭐（一般用这个）
2.参数模板化 ---将对象中的参数变为模板进行传递
3.整个类模板化 ---将这个对象类型模板化进行传递

下面来用一段代码来解释一下

、

当创建一个输出函数，然后把这个对象传入时，发生了错误

而第一种方式是：加上参数列表

方法2：把这个参数变为模板传递

方法3：把这个传入的类模板化

完整代码：

#include<iostream>
#include<string>
using namespace std;

template<class T,class A>
class people
{
public:
    people(T age, A name)
    {
        this->m_age = age;
        this->m_name = name;
    }
    T m_age;
    A m_name;
};
//1.指定传入的类型
void out1(people<int,string> & a)
{
    cout << a.m_name << endl;
    cout << a.m_age  << endl;
}
//2.参数模板化-- - 将对象中的参数变为模板进行传递
template<class A1,class B1>
void out2(people<A1,B1> & a)
{
    cout << a.m_name << endl;
    cout << a.m_age << endl;
}

//3.整个类模板化-- - 将这个对象类型模板化进行传递
template<class T>
void out3(T& a)
{
    cout << a.m_name << endl;
    cout << a.m_age << endl;
}
void test1()
{
    people<int,string> a(12, "小红");
    out1(a);
    out2(a);
    out3(a);
}
int main()
{
    test1();
    system("pause");
    return 0;
}

类模板成员类外实现

类模板成员是否可以实现类内声明，类外初始化呢？和普通函数一样，加上作用域就可以了吗？

答案是❌发生错误

这里分为两类函数讲解——构造函数和成员函数

构造函数：

解决方案如下：

普通成员函数：

如上，无论是哪一个，都需要先写template<默认参数列表>

然后函数都需要写上作用域，然后再在类名后加上<默认参数列表>

类模板分文件编写

在实际开发中通常会把声明和实现一个放在头文件，一个放在源文件，如果我们把类模板的实现和声明拿出来，放在people.h和people.cpp中，然后这个原本的代码加上#include“people.h”再次运行，是否可以达到想要的效果？

❌

刚才我们谈到，类模板的创建时机和普通函数并不相同，只有在调用它的时候才会创建，而现在这个代码包含的是头文件——头文件只有声明无实现，编译器根本不知道函数实现的代码，因此错误。

那解决方案呢？

1.把包含的文件改成#include"people.cpp"

2.把people.h和people.cpp合并并命名为people.hpp

类模板和继承

当类模板遇到继承会发生怎样的反应？
1.当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
如果不指定，编译器无法给子类分配内存（因为子类继承了这个父类中的未知变量——T类型，分配内存需要知道需要的内存空间）
2.如果想灵活指定出父类中t的类型，子类也需变为类模板

当要继承的父类是类模板时，子类往往需要添加点代码：

指定父类中默认参数的类型，例如：在后面写下指定的类型