C++模板编程

2021-04-13

模板编程主要涉及函数模板、类模板、成员函数模板以及泛化、全特化、偏特化的概念。

模板编程

模板本身概念比较简单，主要包含函数模板、类模板、类成员函数模板

比较麻烦的是友元函数模板和关于类模板的继承

函数模板

函数模板可以进行自动类型推导，如下所示：

template<class T>
T mymax(T a, T b){
    return a > b? a : b;
}

int main(){
    cout << mymax(1, 2) <<endl;
    cout << mymax(1.0, 2.0) <<endl;
    // 注意1.0被自动推断类型是double而不是float
    // 如果需要使用float需要自己明确指出类型为float 1.0f 形式
    cout << mymax<float>(1.0, 2) <<endl;
    // 错误，函数模板可以进行类型推导，
    // 但是必须精确匹配，如果需要进行自动类型转换则必须指定具体类型
    cout << mymax(1.0, 2) <<endl; 
    return 0;
}

函数重载调用优先级精确匹配的函数模板 > 可以精确匹配的函数模板 > 指定类型需要进行自动类型转换的函数模板 > 需要进行自动类型转换的普通函数。

类模板

类模板就是把类成员变量的类型用模板定义

template <class T>
class Book{
public:
    Book(T num, T price): num(num), price(price) {};
    friend ostream& operator << (ostream& os, Book& book){
        os << "Book num: " << book.num << " price: " << book.price << endl;
        return os;
    }
private:
    T num;
    T price;
};

int main(){
    Book<int> book(10, 100);
    cout << book << endl;
    return 0;
}

类成员函数模板

类成员模板就是把函数模板作为类的成员函数

template <class T>
class Book{
public:
    Book(T num, T price): num(num), price(price) {};
    friend ostream& operator << (ostream& os, Book& book){
        os << "Book num: " << book.num << " price: " << book.price;
        return os;
    }
    template <class T1>
    void showInfo(T1 t){
        cout << "The book info value: " << t;
    }

private:
    T num;
    T price;
};

int main(){
    Book<int> book(10, 100);
    cout << book << endl;
    book.showInfo(1);
    cout << endl;
    book.showInfo<float>(2.0);
    return 0;
}

泛化

上述的举例子都是泛化的例子

特化（全特化）

（全）特化则是模板的类型进行了具体化

类模板全特化

template <class T>
class Book{
public:
    Book(T num, T price): num(num), price(price) {
        cout << "template <class T>" << endl;
    };
    friend ostream& operator << (ostream& os, Book& book){
        os << "Book num: " << book.num << " price: " << book.price;
        return os;
    }
    template <class T1>
    void showInfo(T1 t){
        cout << "The book info value: " << t;
    }

private:
    T num;
    T price;
};

template <>
class Book<float>{
public:
    Book(float num, float price): num(num), price(price) {
        cout << "template <>" << endl;
    };
    friend ostream& operator << (ostream& os, Book& book){
        os << "Book num: " << book.num << " price: " << book.price;
        return os;
    }
    template <class T1>
    void showInfo(T1 t){
        cout << "The book info value: " << t;
    }

private:
    float num;
    float price;
};

int main(){
    Book<int> book1(10, 100); // 调用泛化版本
    Book<float> book2(10.0, 20.0); // 调用特化模板
    return 0;
}

函数模板全特化

template <class T>
void fun(T t1, T t2){
    cout << "template <class T>" << endl;
    cout << t1 << t2 << endl;
}

template <>
void fun(float t1, float t2){
    cout << "template <>" << endl;
    cout << t1 << t2 << endl;
}

int main(){
    fun(1.0f, 2.0f); // 调用泛化版本
    fun(1.0, 2.0); // 调用全特化版本
    return 0;
}

偏特化

类模板偏特化，重载时挑选最匹配的。

#include <iostream>
using namespace std;

template <class T1, class T2>
class Book{
public:
    Book(T1 num, T2 price): num(num), price(price) {
        cout << "template <class T1, class T2>" << endl;
    };
    friend ostream& operator << (ostream& os, Book& book){
        os << "Book num: " << book.num << " price: " << book.price;
        return os;
    }
    template <class T3>
    void showInfo(T3 t){
        cout << "The book info value: " << t;
    }

private:
    T1 num;
    T2 price;
};

template <class T2>
class Book<int, T2>{
public:
    Book(int num, T2 price): num(num), price(price) {
        cout << "template <class T2>" << endl;
    };
    friend ostream& operator << (ostream& os, Book& book){
        os << "Book num: " << book.num << " price: " << book.price;
        return os;
    }
    template <class T3>
    void showInfo(T3 t){
        cout << "The book info value: " << t;
    }

private:
    int num;
    T2 price;
};

template <>
class Book<int, float>{
public:
    Book(int num, float price): num(num), price(price) {
        cout << "template <>" << endl;
    };
    friend ostream& operator << (ostream& os, Book& book){
        os << "Book num: " << book.num << " price: " << book.price;
        return os;
    }
    template <class T1>
    void showInfo(T1 t){
        cout << "The book info value: " << t;
    }

private:
    int num;
    float price;
};

int main(){
    Book<int, float> book1(10, 100); // 调用全特化
    Book<int, int> book2(10, 100); // 调用偏特化
    Book<float, int> book3(10.0, 100); // 调用泛化版
    return 0;
}

C++标准中，模板函数不能偏特化，但是可以重载。但是发现我写了类似偏特化的版本没有报错，但是不会去调用它。

#include <iostream>
using namespace std;

// 泛化版本
template <class T1, class T2>
void fun(T1 t1, T2 t2){
    cout << "template <class T>" << endl;
    cout << t1 << t2 << endl;
}

// 全特化版本
template <>
void fun(float t1, float t2){
    cout << "template <>" << endl;
    cout << t1 << t2 << endl;
}

// 偏特化版本
template <class T>
void fun(int t1, T t2){
    cout << "template <>" << endl;
    cout << t1 << t2 << endl;
}
int main(){
    fun(1.0f, 2.0f); // 调用泛化版本
    fun(1.0, 2.0); // 调用全特化版本
    fun(1, 2.0f); // 调用泛化版本
    fun<int, float>(1, 2.0f); // 进行类型转换，调用全特化
    return 0;
}