C++ 函数模板与类模板

函数模板

函数模板是统用的函数描述，其使用泛型定义函数，其中泛型可被具体类型（如 int、double）替换。

调用模板函数，可以使用自动类型推导或显式指定类型。

语法：

template <typename T>
ret-type func(parameter list)
{
   // 函数的主体
}

注意事项：

自动类型推导，必须推导出一致的数据类型才可以使用
模板必须确定 T 的数据类型才可以使用
class 可以替换 typename ，typename 是新标准中的关键字。

示例 1：

下面的代码定义了一个 mySwap 函数模板，可以交换两个参数的内容。

#include <iostream>

using namespace std;

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

int main() {
    int a = 10;
    int b = 20;
    cout << "交换前" << endl << "a = " << a << " b = " << b << endl;

    // 自动类型推导
    mySwap(a, b);
    cout << "使用自动类型推导交换后" << endl << "a = " << a << " b = " << b << endl;

    // 显示指定类型
    mySwap<int>(a, b);
    cout << "使用显示指定类型交换后" << endl << "a = " << a << " b = " << b << endl;

    return 0;
}

示例 2：

下面代码基于函数模板实现了选择排序（升序）

#include <iostream>

using namespace std;

// 打印数组
template<typename T>
void printArray(T arr[], int len) {
    for (int i = 0; i < len; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}
// 交换 a 和 b
template<typename T>
void mySwap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

// 选择排序（升序）
template<typename T>
void selectionSort(T arr[], int len) {
    for (int i = 0; i < len - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < len; j++) {
            if (arr[min_idx] > arr[j]) {
                min_idx = j;
            }
        }
        // 交换
        mySwap(arr[min_idx], arr[i]);
    }
}

void testCharArr() {
    char char_array[] = "gbafdce";
    int len = sizeof(char_array) / sizeof(char_array[0]) - 1; // 去除 '\0'

    cout << "排序前 ";
    printArray(char_array, len);

    selectionSort(char_array, len);

    cout << "排序后 ";
    printArray(char_array, len);
}


void testIntArr() {
    int int_arr[] = { 9, 5, 0, 4, 3, 7, 6, 1, 8, 2 };
    int len = sizeof(int_arr) / sizeof(int_arr[0]);
    cout << len << endl;
    cout << "排序前 ";
    printArray(int_arr, len);

    selectionSort(int_arr, len);

    cout << "排序后 ";
    printArray(int_arr, len);
}
int main()
{
    testCharArr();
    testIntArr();
}

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

普通函数在调用时可以发生自动类型转换（隐式类型转换）
函数模板调用时，若是自动类型推导，不会发生隐式类型转换，若是显式指定类型，可以发生隐式类型转换

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

重名普通函数与函数模板，优先调用普通函数
若函数模板参数更匹配，优先调用函数模板
可以通过空模板参数列表来强制调用函数模板（func<>()）
函数模板可以发生重载

示例：

#include <iostream>

using namespace std;

template<typename T>
void func(T a) {
    cout << "函数模板被调用" << endl;
}
void func(int a) {
    cout << "普通函数被调用" << endl;
}

int main()
{
    int a = 10;
    char b = '0';

    func(a);   // 调用普通函数
    func<>(a); // 调用函数模板
    func(b);   // 调用函数模板
}

模板的局限性

模板不是万能的，有些类型需要具体化方式做实现

例如，下面的函数模板 compare 无法比较 Person 类

class Person{
public:
    string m_name;
    int m_age;
}

template<typename T>
bool compare(T &a, T &b){
    return a == b ? true : false;
}

解决方法 1：

重载 Person 的 == 运算符。

解决方法 2：

重载函数模板，实现具体化调用

template<>
bool compare(Person &a, Person &b){
    return (a.m_name == b.m_name && a.m_age == b.m_age) ? true : false;
}

类模板

语法：

template <typename T>
class ClassName {
	....
}

类模板与函数模板的区别

类模板没有自动类型推导
类模板的模板参数列表可以友默认参数

示例：

#include <iostream>
#include <string>

using namespace std;

template<class NameType, class AgeType = int>
class Person {
public:
    Person(NameType name, AgeType age) {
        m_name = name;
        m_age = age;
    }

    void show() {
        cout << "Name: " << m_name << " Age: " << m_age << endl;
    }

    NameType m_name;
    AgeType m_age;
};

int main()
{
    // 类模板没有自动类型推导
    // Person p("孙悟空", 1000); // 解除注释报错
    Person<string, int> p1("孙悟空", 1000);
    p1.show();

    // 类模板的模板参数列表可以友默认参数
    Person<string> p2("猪八戒", 999);
    p2.show();
}

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

普通类中的成员函数在一开始就创建
类模板中成员函数在调用时创建

类模板对象作函数参数

指定传入类型（最常用）
参数模板化
整个类模板化

#include <iostream>
#include <string>

using namespace std;

template<class NameType, class AgeType>
class Person {
public:
    Person(NameType name, AgeType age) {
        m_name = name;
        m_age = age;
    }

    void show() {
        cout << "Name: " << m_name << " Age: " << m_age << endl;
    }

    NameType m_name;
    AgeType m_age;
};

// 指定传入类型
void printPerson1(Person<string, int> p) {
    p.show();
}


// 参数模板化
template<typename T1, typename T2>
void printPerson2(Person<T1, T2> p) {
    p.show();
    cout << "T1 的类型为：" << typeid(T1).name() << endl;
    cout << "T2 的类型为：" << typeid(T2).name() << endl;
}

template<typename T>
void printPerson3(T &p) {
    p.show();
    cout << "T 的类型为：" << typeid(T).name() << endl;
}

int main()
{
    Person<string, int> p("孙悟空", 1000);

    // 类模板没有自动类型推导
    printPerson1(p);

    // 参数模板化
    printPerson2(p);

    // 整个类模板化
    printPerson3(p);
}

类模板与继承

当子类继承的父类是一个类模板时，子类声明时需要指定父类中 T 的类型
若不指定，编译器无法分类内存
若想灵活指定父类中 T 的类型，子类也需变为类模板

示例：

template<typename T>
class Base {
public:
    T elem;
};

// 子类指定类型
class Son1 : public Base<int> {
};


// 灵活指定父类中 T 的类型
template<typename T1, typename T2>
class Son2 : public Base<T1> {
public:
    T2 elem2;
};

类模板成员函数类外实现

示例：

声明

template<typename NameType, typename AgeType>
class Person {
public:
    Person(NameType name, AgeType age);
    void show();

    NameType m_name;
    AgeType m_age;
};

定义

// 构造函数类外实现
template<typename NameType, typename AgeType>
Person<NameType, AgeType>::Person(NameType name, AgeType age) {
    m_name = name;
    m_age = age;
}

// 成员函数类外实现
template<typename NameType, typename AgeType>
void Person<NameType, AgeType>::show() {
    cout << "Name: " << m_name << " Age: " << m_age << endl;
}

类模板分文件编写

问题：类模板成员函数创建时机时在调用阶段，导致分文件编写时链接不到

解决方法1：直接包含 .cpp 源文件

解决方法2：将声明（class.h）和实现（.cpp）写在同一个文件中，改后缀名为 .hpp（.hpp 是约定俗成，非强制）

解决方法 1 示例：

person.h

#pragma once
#include <iostream>
#include <string>

using namespace std;

template<typename NameType, typename AgeType>
class Person {
public:
    Person(NameType name, AgeType age);
    void show();

    NameType m_name;
    AgeType m_age;
};

person.cpp

#include "person.h"

// 构造函数类外实现
template<typename NameType, typename AgeType>
Person<NameType, AgeType>::Person(NameType name, AgeType age) {
    m_name = name;
    m_age = age;
}

// 成员函数类外实现
template<typename NameType, typename AgeType>
void Person<NameType, AgeType>::show() {
    cout << "Name: " << m_name << " Age: " << m_age << endl;
}

main.cpp

#include "person.cpp"

int main() {
    Person<string, int> p("孙悟空", 1000);
    p.show();
}

解决方法 2 示例：

person.hpp

#pragma once
#include <iostream>
#include <string>

using namespace std;

template<typename NameType, typename AgeType>
class Person {
public:
    Person(NameType name, AgeType age);
    void show();

    NameType m_name;
    AgeType m_age;
};

// 构造函数类外实现
template<typename NameType, typename AgeType>
Person<NameType, AgeType>::Person(NameType name, AgeType age) {
    m_name = name;
    m_age = age;
}

// 成员函数类外实现
template<typename NameType, typename AgeType>
void Person<NameType, AgeType>::show() {
    cout << "Name: " << m_name << " Age: " << m_age << endl;
}

main.cpp

#include "person.hpp"

int main() {
    Person<string, int> p("孙悟空", 1000);
    p.show();
}

类模板与友元

全局函数类内实现，直接在类内声明友元即可

全局函数类外实现，需要提前让编译器知道全局函数的存在

示例：

#include <iostream>
#include <string>

using namespace std;

// 需要提前声明类模板和全局函数
template<typename NameType, typename AgeType>
class Person;
template<typename NameType, typename AgeType>
void show2(Person<NameType, AgeType> p);

template<typename NameType, typename AgeType>
class Person {
    // 全局函数类内实现
    friend void show(Person<NameType, AgeType> p) {
        cout << "Name: " << p.m_name << " Age: " << p.m_age << endl;
    }
    // 全局函数类外实现声明（需要加模板空参数列表“<>”，告诉编译器类外实现的是函数模板）
    friend void show2<>(Person<NameType, AgeType> p);
public:
    Person(NameType name, AgeType age);
private:
    NameType m_name;
    AgeType m_age;
};

// 构造函数类外实现
template<typename NameType, typename AgeType>
Person<NameType, AgeType>::Person(NameType name, AgeType age) {
    m_name = name;
    m_age = age;
}

// 全局函数类外实现
template<typename NameType, typename AgeType>
void show2(Person<NameType, AgeType> p) {
    cout << "Name: " << p.m_name << " Age: " <<p.m_age << endl;
}
int main() {
    Person<string, int>p("孙悟空", 1000);
    show(p);
    show2(p);
}

类模板中，全局函数类外实现需要注意

需要提前声明类模板和全局函数
需要加模板空参数列表“<>”，告诉编译器类外实现的是函数模板

posted @ 2021-02-21 16:54 Lambyte 阅读(70) 评论(0) 收藏举报

刷新页面返回顶部

Loading

Lambyte