C++ template笔记

模板

• 模板
  • 一个框架, 可以通用, 但不能单独使用, 也不是万能的
• C++中除了面向对象编程思想之外, 还有另一种思想 泛型编程, 主要利用的就是模板技术
• C++提供了两种模板技术, 函数模板 和 类模板
• 目的
  • 提高代码复用性, 类型参数化

函数模板

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

(声明一个模板, 告诉编译器之后跟着的函数中T为通用数据类型, 不要报错)

• 两种方式使用函数模板
  • 自动类型推导 (直接传值即可)
  • 显示指定类型 (函数名和括号之间加一个<>指定类型)

函数模板使用注意事项

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

选择排序 函数模板实现

#include <iostream>
using namespace std;

template<typename T>
void mySwap(T& a, T& b)
{
    T temp = a;
    a = b;
    b = temp;
}

template<typename T>
void mySort(T arr[], int num)
{
    for (int i = 0; i < num; i++)
    {
        int max = i;
        for (int j = i + 1; j < num; j++)
        {
            if (arr[max] < arr[j])
            {
                max = j;
            }
        }
        if (max != i)
        {
            mySwap(arr[max], arr[i]);
        }
    }
}

template<typename T>
void printArr(T arr[], int num)
{
    for (int i = 0; i < num; i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;
}

void test01()
{
    char arrChar[] = "abcdef";
    int num = sizeof(arrChar) / sizeof(char) - 1;
    mySort(arrChar, num);
    printArr(arrChar, num);
}

void test02()
{
    int arrInt[] = {1, 4, 8, 2, 5, 7};
    int num = sizeof(arrInt) / sizeof(int);
    mySort(arrInt, num);
    printArr(arrInt, num);
}
int main()
{
    test01();
    test02();
    return 0;
}

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

• 普通函数调用时 会发生自动类型转换 (隐式类型转换)
• 函数模板使用自动类型推导 不会发生自动类型转换
• 函数模板使用显示指定类型 会发生自动类型转换
  • 参数为引用的时候 都不会发生隐式类型转换. 因为他们不是同一个level的, int char都是基本数据类型, 而int的引用不属于基本数据类型

#include <iostream>
using namespace std;

// 普通函数
int addInt1(int a, int b)
{
    return a + b;
}

// 函数模板
template<typename T>
T addInt2(T a, T b)
{
    return a + b;
}

void test01()
{
    int a = 10;
    int b = 20;
    char c = 'c';
    cout<<addInt1(a, c)<<endl;
    // 自动类型推导
    cout<<addInt2(a, b)<<endl;  // addInt2(a,c) 错误, 因为无法推导出一致的T, 并且不能发生隐式类型转换
    // 显示指定类型  以后调用模板的时候采用显示指定类型的方法, 自己确定通用类型T
    cout<<addInt2<int>(a, c)<<endl;
}

int main()
{
    test01();
    return 0;
}

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

• 如果函数模板和普通函数都可以调用, 优先调用普通函数
  • 即使普通函数只有声明, 没有实现, 编译器也会选择调用普通函数, 这个时候会报错
• 通过空的模板参数列表, 强制调用模板函数
  • 函数名<>(参数列表)
• 函数模板也可以发生函数重载
• 如果函数模板可以产生更好的匹配, 优先调用函数模板.
  • 普通函数需要隐式类型转换, 模板函数不用隐式类型转换, 则优先选择函数模板

• 既然提供了函数模板, 就不要再提供普通函数了, 否则会出现二义性.

模板的局限性

• 模板并不是万能的, 有些特定的数据类型, 需要用具体化的方式做特殊实现
  
  

• 利用具体化的模板, 可以解决自定义类型的通用化
• 学习模板并不是为了写模板, 而是为了在之后STL中能够运用系统提供的模板.

类模板

template <class T>
类

• 建立一个通用类, 类中的成员数据类型可以不具体指定, 用一个虚拟的类型来代表

类模板 与 函数模板 的区别

• 类模板没有自动类型推导, 只可以显示指定类型
• 类模板 在模板参数列表(<>中的内容)中可以有默认参数. 函数模板没有, 因为可以自动类型转换

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

• 普通类中的成员函数, 一开始就创建
  • 编译时期即会创建
• 类模板中的成员函数, 在调用时才创建
  • 编译时不会创建, 因为当数据类型为参数时, 不知道该对象有哪些属性行为, 因此只有在运行调用, 具体化模板参数列表时才会创建.

类模板对象做函数参数

• 指定传入类型
• 参数模板化
• 整个类模板化

• 类模板对象做为参数传入函数中有三种类型, 第一种指定传入类型最常用

类模板与继承

• 子类继承的父类如果是一个类模板, 子类在声明时, 需要指定出父类中T的类型

• 如果不指定, 编译器无法给子类分配内存

• 如果想灵活指定父类中T的类型, 子类也需要变成模板.

• typeid(变量).name() 可以返回变量类型的名字
  
  

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

• 类模板成员函数类外实现时, 需要加上模板参数列表.
  

类模板分文件编写

Person.hpp  函数声明
#pragma once
#include <iostream>
using namespace std;
...

Person.cpp  函数定义
#include “Person.hpp”
...

问题

• 类模板中成员函数创建时机是调用阶段, 导致份文件编写时链接不到
  • 直接包含hpp文件时, 编译阶段, 编译器回去查看hpp中的类模板里的函数声明, 但是并不会创建那些函数. 也就不会去找这两个函数的实现, 也就不会去看.cpp中的函数定义. 因此在链接调用时链接不到. (如果是普通类的函数, 就会其余文件中找函数的实现)
  • 如果直接包含cpp文件, 开头的#include<Person.hpp>, 让编译器看到了类模板里函数的声明和定义, 因此可以正常调用.
    解决
• 直接包含.cpp源文件
• 将声明和实现写在同一个文件, 后缀名改为.hpp(约定的名称, 不强制)

类模板与友元

• 全局函数类内实现 : 直接声明友元即可
• 全局函数类外实现 : 需要提前让编译器知道全局函数的存在