Hello，C++（7）函数模板和类模板

函数模板和类模板

1、介绍

1）C++提供两种模板机制：函数模板、类模板

2）作用：使类型参数化，又称参数模板

使得程序（算法）可以从逻辑功能上抽象，将数据类型作为参数传递。

总结：

• 模板把函数或类要处理的数据类型参数化，表现为参数的多态性，称为类属。
• 模板用于表达逻辑结构相同，但具体数据元素类型不同的数据对象的通用行为。

所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。

凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。

在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。

2、函数模板

1）应用场景：函数的业务逻辑一样，但函数的参数类型不一样

　　函数模板的本质：类型参数化

2）语法

函数模板声明形式 ：

template    < 类型形式参数表 >    
类型形式参数的形式为：
            typename T1 ,  typename T2 , …… , typename Tn 
                或    class T1 ,  class T2 , …… , class Tn  

函数模板定义：

template    < 类型形式参数表 >
类型 函数名 （形式参数表）{
　　语句序列
}

3）举例

#include <iostream>
using namespace std;

//template 关键字告诉C++编译器 我要开始泛型了.你不要随便报错  
//数据类型T 参数化数据类型
template <typename T>
void myswap(T &a, T &b)
{
    T t;
    t = a;
    a = b;
    b = t;
}

void main()
{
    //char a = 'c';
    
    int  x = 1;
    int     y = 2;
    myswap(x, y); //自动数据类型 推导的方式 （不常用，不太好用，看懂即可不推荐使用）

    float a = 2.0;
    float b = 3.0;

    myswap(a, b); //自动数据类型 推导的方式 
    myswap<float>(a, b); //显示类型调用 

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

4）注意

每个模板函数前面都要加函数模板声明：template<class T>

模板函数的调用方式：

sortArray<char, int>(a, num); //显示类型调用 模板函数 <>

3、函数模板遇上函数重载

函数模板和普通函数在一起，调用规则：

         1 模板函数可以像普通函数一样被重载

         2  C++编译器优先考虑普通函数

         3 如果函数模板可以产生一个更好的匹配，那么选择模板

         4 可以通过空模板实参列表的语法限定编译器只通过模板匹配

函数模板和普通函数的本质区别结论：

　　1、函数模板不允许自动类型转化

　　2、普通函数能够进行隐式的自动类型转换

举例：

#include "iostream"
using namespace std;


int Max(int a, int b)
{
    cout<<"int Max(int a, int b)"<<endl;
    return a > b ? a : b;
}

template<typename T>
T Max(T a, T b)
{
    cout<<"T Max(T a, T b)"<<endl;
    return a > b ? a : b;
}

template<typename T>
T Max(T a, T b, T c)
{
    cout<<"T Max(T a, T b, T c)"<<endl;
    return Max(Max(a, b), c);
}


void main()
{
    int a = 1;
    int b = 2;

    cout<<Max(a, b)<<endl; //当函数模板和普通函数都符合调用时,优先选择普通函数
    cout<<Max<>(a, b)<<endl; //若显示使用函数模板,则使用<> 类型列表

    cout<<Max(3.0, 4.0)<<endl; //如果 函数模板产生更好的匹配 使用函数模板

    cout<<Max(5.0, 6.0, 7.0)<<endl; //重载

    cout<<Max('a', 100)<<endl;  //调用普通函数 可以隐式类型转换 
    system("pause");
    return ;
}

结论： 函数模板不提供隐式的数据类型转换，必须是严格的匹配，而普通函数可以隐式转换数据类型。

4、函数模板小结

模板函数进行编译时，编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译；在调用的地方对参数替换后的代码进行编译。

编译器并不是把函数模板处理成能够处理任意类型的函数，编译器从函数模板通过具体类型产生不同的函数。

我们使用函数模板，根据具体类型的参数化，就能适用于不同类型的变量交换，达到了代码复用的效果。

下边来深入理解下函数模板：

    - 对于函数模板中使用的类型不同，编译器会产生不同的函数

    - 编译器会对函数模板进行两次编译

    - 第一次是对函数模板本身进行编译，包括语法检查等（生成函数体）

    - 第二次是对参数替换后的代码进行编译，这就相当于编译普通函数一样，进行类型规则检查等。（根据类型生成函数头）

需要注意的是

    - 函数模板是不允许隐式类型转换的，调用时类型必须严格匹配

5、类模板

类模板与函数模板的定义和使用类似，当有两个或多个类，其功能是相同的，仅仅是数据类型不同，

如下面语句声明了一个类：

• 类模板用于实现类所需数据的类型参数化
• 类模板在表示如数组、表、图等数据结构显得特别重要，

 这些数据结构的表示和算法不受所包含的元素类型的影响

举例：

//类的类型参数化 抽象的类
//单个类模板
template<typename T>
class A 
{
public:
    A(T t)
    {
        this->t = t;
    }

    T &getT()
    {
        return t;
    }
protected:
public:
    T t;
};
void main()
{
   //模板中如果使用了构造函数,则遵守以前的类的构造函数的调用规则
    A<int>  a(100); 
    a.getT();
    printAA(a);
    return ;
}

6、继承中的类模板语法

示例：

//结论: 子类从模板类继承的时候,需要让编译器知道 父类的数据类型具体是什么(数据类型的本质:固定大小内存块的别名)A<int> 
//
class B : public A<int>//（需要调用父类的构造函数，所以用参数列表来做）
{
public:
    B(int i) : A<int>(i)
    {

    }
    void printB()
    {
        cout<<"A:"<<t<<endl;
    }
protected:
private:
};

//模板与上继承
//怎么样从基类继承  
//若基类只有一个带参数的构造函数,子类是如何启动父类的构造函数
void pintBB(B &b)
{
    b.printB();
}
void printAA(A<int> &a)  //类模板做函数参数 
{ 
     //
    a.getT();
}

void main()
{
    A<int>  a(100); //模板类中如果使用了构造函数,则遵守以前的类的构造函数的调用规则 
    a.getT();
    printAA(a);

    B b(10);
    b.printB();


    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

类模板有三种方式：

• 类模板语法知识体系梳理

• 所有的类模板函数写在类的内部

• 所有的类模板函数写在类的外部，在一个cpp中

  • 这种方式下：Main文件里要包含.cpp需要把所有.h和.cpp文件放在同一个项目里，main文件要进行两次编译。

尽量用1、3方式。

注意三个地方具体化：
1、参数具体化加<T>

2、返回值具体化加<T>

3、函数名 要不要加类的域名作用符

              

 注意：声明友元函数的时候：friend ostream& operator<< <T> (ostream &out, Complex<T> &c3) ;

全局函数不要加类的域名作用符，例如operator<<是全局函数

友元函数本来就不是类里面的，是全局函数 不需要加域名作用符

 

结论：

友元函数只用来进行左移友移操作符重载。

而且重载<<和>>操作符只能用友元函数，其他运算符重载都要用成员函数

不要滥用友元函数

             

8、总结

归纳以上的介绍，可以这样声明和使用类模板：

1) 先写出一个实际的类。由于其语义明确，含义清楚，一般不会出错。

2) 将此类中准备改变的类型名(如int要改变为float或char)改用一个自己指定的虚拟类型名(如上例中的numtype)。

3) 在类声明前面加入一行，格式为：

    template <class 虚拟类型参数>

如：

    template <class numtype> //注意本行末尾无分号

    class Compare

    {…}; //类体

4) 用类模板定义对象时用以下形式：

    类模板名<实际类型名> 对象名;

    类模板名<实际类型名> 对象名(实参表列);

如：

    Compare<int> cmp;

    Compare<int> cmp(3,7);

5) 如果在类模板外定义成员函数，应写成类模板形式：

   template <class 虚拟类型参数>

   函数类型 类模板名<虚拟类型参数>::成员函数名(函数形参表列) {…}

9、关于类模板的几点说明：

1) 类模板的类型参数可以有一个或多个，每个类型前面都必须加class，如：

    template <class T1,class T2>

    class someclass

    {…};

在定义对象时分别代入实际的类型名，如：

    someclass<int,double> obj;

2) 和使用类一样，使用类模板时要注意其作用域，只能在其有效作用域内用它定义对象。

3) 类模板可继承

10、类模板中的static关键字

• 从类模板实例化的每个模板类有自己的类模板数据成员，该模板类的所有对象共享一个static数据成员
•  和非模板类的static数据成员一样，模板类的static数据成员也应该在文件范围定义和初始化
•  每个模板类有自己的类模板的static数据成员副本

示例：

template<typename T>
class TA
{
public:
    static T a;
public:
    TA()
    {

    }
};
template<typename T>
T TA<T>::a = 10;

int main()
{
    //说明static属于的是具体类型的类
    TA<int> Oa;
    Oa.a += 10;
    cout << Oa.a << endl;
    TA<int> Ob;
    cout << Ob.a << endl;

    TA<char> Ca;
    cout << (int)Ca.a << endl;

    return 0;
}

结论：

static属于类模板实例化的模板类。实例化的模板类有多个,则static成员分别属于多个模板类。即模板类有自己的static成员,互不干扰。