3.5函数模板

模板以template关键字和一个形参表开头

参数至少是有一个模板类型

#include <iostream>
using namespace std;

//T通用数据类型
template <typename T>
T MAX(T *p, const int n)
{
    T maxdata(p[0]);

    for (int i = 0; i < n; i++)
    {
        if (maxdata < p[i])
        {
            maxdata = p[i];
        }
    }

    return maxdata;
}

void main()
{
    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
    double b[10] = { 1,2,3,4,5,6,7,8,9,10 };

    std::cout << MAX(a, 10) << std::endl;
    std::cout << MAX(b, 10) << std::endl;

    system("pause");
}

函数参数不允许使用自动变量

//error C3533: 参数不能为包含“auto”的类型

#include <iostream>
using namespace std;

int putnum(auto num)//error C3533: 参数不能为包含“auto”的类型
{

}

void main()
{

    system("pause");
}

函数模板中可以使用inline

#include <iostream>
using namespace std;

template <class T>
inline T getX3(T x)
{
    return x*x*x;
}

void main()
{
    std::cout << getX3(1 + 2) << std::endl;//27

    system("pause");
}

函数模板根据类型覆盖

//模板为空，明确类型
template <>
void swap1(info &info1, info &info2)
{
std::cout << "特有函数模板" << std::endl;
info temp = info1;
info1 = info2;
info2 = temp;
}

不写上T

#include <iostream>
using namespace std;

//函数模板实现通用，可以根据自有数据类型，进行优化
//结构体可以直接赋值
//所有成员都是公有的类型可以赋值

struct info
{
    char name[100];
    double db;
    int data;
};

template <typename T>
void swap1(T &a, T &b)
{
    std::cout << "通用函数模板" << std::endl;
    T temp = a;
    a = b;
    b = temp;
}

//模板为空，明确类型
template <>
void swap1(info &info1, info &info2)
{
    std::cout << "特有函数模板" << std::endl;
    info temp = info1;
    info1 = info2;
    info2 = temp;
}

void main()
{
    info info1 = { "hello",20.9,10 };
    info info2 = { "world",9.2,1 };

    swap1(info1, info2);//交换两个结构体

    std::cout << info1.name << " " << info1.db << " " << info1.data << std::endl;
    std::cout << info2.name << " " << info2.db << " " << info2.data << std::endl;

    system("pause");
}

//如果类有私有成员变量，不可以用大括号初始化

//类的对象之间默认是可以直接赋值

//类、结构体都有一个默认赋值操作=浅拷贝

//深拷贝用得最多，函数模板的覆盖

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

//如果类有私有成员变量，不可以用大括号初始化
//类的对象之间默认是可以直接赋值
//类、结构体都有一个默认赋值操作=浅拷贝
//深拷贝用得最多，函数模板的覆盖

class info
{
private:
    int num;
public:
    char name[100];
    char *p;
    int data;    
    void set(int X)
    {
        this->num = X;
    }
    int get()
    {
        return this->num;
    }
};

template <typename T>
void swap1(T &a, T &b)
{
    std::cout << "通用函数模板" << std::endl;
    T temp = a;
    a = b;
    b = temp;
}

//模板为空，明确类型
template <>
void swap1(info &info1, info &info2)
{
    std::cout << "特有函数模板" << std::endl;
    info temp = info1;
    info1 = info2;
    info2 = temp;
}

//函数，对一个对象进行深拷贝，需要自己函数模板重载

void main()
{
    info info1;
    info info2;

    std::strcpy(info1.name, "hello");
    std::strcpy(info2.name, "world");
    info1.p = new char[10];
    std::strcpy(info1.name, "info1.p");
    info2.p = new char[10];
    std::strcpy(info2.name, "info2.p");
    info1.data = 102;
    info2.data = 201;
    info1.set(89);
    info2.set(98);

    swap1(info1, info2);

    std::cout << info1.name << " " << info1.p << info1.data << " " << info1.get() << " " << std::endl;
    std::cout << info2.name << " " << info1.p << info2.data << " " << info2.get() << " " << std::endl;

    system("pause");
}

//函数模板可以对类型进行优化重载，根据类型会覆盖

//如果仍然要使用模板函数，需要实例化

显式比较准则

函数模板名<模板参数>(参数列表)

add<int>(a, b);//T add，实例化

add<int>(db1, db2);//T add，实例化

add<double>(db1, db2);//T add，实例化

#include <iostream>
using namespace std;

//函数模板可以对类型进行优化重载，根据类型会覆盖
//如果仍然要使用模板函数，需要实例化

template <class T>//函数模板
T add(T a, T b)
{
    std::cout << "T add" << std::endl;
    return a + b;
}

int add(int a, int b)//一般函数
{
    std::cout << "int add" << std::endl;
    return a + b;
}

void main()
{
    int a(10), b(20);

    double db1(10.9), db2(10.8);

    add(a, b);//int add

    add(db1, db2);//T add

    add<int>(a, b);//T add，实例化

    add<int>(db1, db2);//T add，实例化

    add<double>(db1, db2);//T add，实例化

    system("pause");
}

函数可变参数通用类型，函数模板

//通用可变参数模板

//可处理不限定个数的参数，处理不同类型

//根据不同的需求，采用不同的设计

//设计可以修改原来的数据的，不要加上const，要引用，void showall(const &value, Args &...args)

//设计可以修改副本，不要const，不要引用，void showall(T value, Args...args)

//设计不可以修改原来的数据，且不能修改副本void showall(const T value, const Args...args)

//设计引用原来的数据，但不可以修改void showall(const T &value, const Args &...args)

#include <iostream>
using namespace std;

//通用可变参数模板
//可处理不限定个数的参数，处理不同类型

void showall()//空函数，必须保留，作用：接口作用，最后结束递归
{

}

//根据不同的需求，采用不同的设计
//设计可以修改原来的数据的，不要加上const，要引用，void showall(const &value, Args &...args)
//设计可以修改副本，不要const，不要引用，void showall(T value, Args...args)
//设计不可以修改原来的数据，且不能修改副本void showall(const T value, const Args...args)
//设计引用原来的数据，但不可以修改void showall(const T &value, const Args &...args)

template <typename T, typename...Args>
void showall(const T &value, const Args &...args)
{
    std::cout << value << std::endl;
    showall(args...);//继续传递，递归
    std::cout << std::endl;
}

void main()
{
    int num1(10), num2(9), num3(11);

    double db1(10.8), db2(10.9);

    char str[40] = "hello";

    char ch = 'A';
    
    showall(num1);

    showall(num1, num2, num3);

    showall(db1, db2, num1, ch);

    showall(db1, db2, num1, ch, str);

    system("pause");
}

函数模板重载，array数组作为参数

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

template <typename T>
void showarray(std::array<T, 10> myarray, int n)//对象数组
{
    std::cout << "对象数组" << std::endl;
    for (int i = 0; i < n; i++)
    {
        std::cout << myarray[i] << " ";
    }
    std::cout << std::endl;
}

template <typename T>
void showarray(std::array<T *, 10> myarray, int n)//指针数组
{
    std::cout << "指针数组" << std::endl;
    for (int i = 0; i < n; i++)
    {
        std::cout << *myarray[i] << " ";
    }
    std::cout << std::endl;
}

void main()
{
    std::array<int, 10>intarray = { 1,2,3,4,5,6,7,8,9,10 };//创建一个数组，数组的元素类型是int

    std::array<int *, 10>pintarray;//创建一个数组，数组的元素类型是int *

    std::array<int **, 10>ppintarray;//创建一个数组，数组的元素类型是int **

    for (int i = 0; i < 10; i++)
    {
        pintarray[i] = &intarray[i];//赋值
    }

    for (int i = 0; i < 10; i++)
    {
        ppintarray[i] = &pintarray[i];//赋值
    }

    showarray(intarray, 10);//对象数组

    showarray(pintarray, 10);//指针数组

    showarray(ppintarray, 10);//指针数组

    system("pause");
}

面试：

typename与class区别

关键字typename作为类型前的标识符号

template <class T>
class MyClass
{
    typename T::SubType * ptr;
    //typename指出SubType是T中定义的一个类型，因此ptr是一个指向T::SubType的指针
    //如果不加上typename，表达式被认为是T中的静态成员SubType和ptr的乘积
};

C++的一般规则是，除了以typename修饰以外，template内的任何标识符号都被视为一个值value，而非一个类型type

typename的第二个作用：在模板声明中替换关键字class

template <typename T>
class MyClass;

软件工程规范，用typename，不用class