1
// 函数模板--参数匹配
2
template<class T>
3
bool Less(T left, T right) {
4
    return left < right;  // 使用<运算符比较两个对象
5
}
6

7
class Date {
8
public:
9
    Date(int year, int month, int day)
10
        : _year(year), _month(month), _day(day) {}
11

12
    // 重载<运算符，用于日期比较
13
    bool operator<(const Date& d) const {
14
        if (_year < d._year) return true;
15
        if (_year == d._year && _month < d._month) return true;
16
        if (_year == d._month && _month == d._month && _day < d._day) return true;
17
        return false;
18
    }
19

20
private:
21
    int _year;
22
    int _month;
23
    int _day;
24
};
25

26
int main() {
27
    cout << Less(1, 2) << endl;  // 比较两个int，调用模板函数
28

29
    Date d1(2022, 7, 7);
30
    Date d2(2022, 7, 8);
31
    cout << Less(d1, d2) << endl;  // 比较两个Date对象，使用重载的<运算符
32

33
    Date* p1 = &d1;
34
    Date* p2 = &d2;
35
    cout << Less(p1, p2) << endl;  // 比较两个指针，比较的是地址而不是日期值
36
    return 0;
37
}

1
#include <iostream>
2
using namespace std;
3

4
// Date类的定义应该在这里
5
class Date {
6
public:
7
    Date(int year, int month, int day)
8
        : _year(year), _month(month), _day(day) {}
9

10
    bool operator<(const Date& d) const {
11
        if (_year < d._year) return true;
12
        if (_year == d._year && _month < d._month) return true;
13
        if (_year == d._year && _month == d._month && _day < d._day) return true;
14
        return false;
15
    }
16

17
private:
18
    int _year;
19
    int _month;
20
    int _day;
21
};
22

23
// 函数模板
24
template<class T>
25
bool Less(T left, T right) {
26
    return left < right;  // 通用比较模板
27
}
28

29
// 对Less函数模板进行特化（处理Date*类型）
30
template<>
31
bool Less<Date*>(Date* left, Date* right) {
32
    return *left < *right;  // 解引用后比较Date对象
33
}
34

35
int main() {
36
    cout << Less(1, 2) << endl;  // 调用通用模板
37

38
    Date d1(2022, 7, 7);
39
    Date d2(2022, 7, 8);
40
    cout << Less(d1, d2) << endl;  // 调用通用模板
41

42
    Date* p1 = &d1;
43
    Date* p2 = &d2;
44
    cout << Less(p1, p2) << endl;  // 调用特化版本
45
    return 0;
46
}

1
template<class T1, class T2>
2
class Data {
3
public:
4
    Data() {
5
        cout << "Data<T1, T2>" << endl;  // 通用模板构造函数
6
    }
7
private:
8
    T1 _d1;
9
    T2 _d2;
10
};
11

12
// 全特化版本：针对<int, char>类型组合
13
template<>
14
class Data<int, char> {
15
public:
16
    Data() {
17
        cout << "Data<int, char>" << endl;  // 特化版本构造函数
18
    }
19
private:
20
    int _d1;
21
    char _d2;
22
};
23

24
void TestVector() {
25
    Data<int, int> d1;      // 匹配通用模板
26
    Data<int, char> d2;     // 匹配全特化版本
27
}

1
#include <vector>
2
#include <algorithm>
3
using namespace std;
4

5
template<class T>
6
struct Less {
7
    bool operator()(const T& x, const T& y) const {
8
        return x < y;  // 仿函数对象，重载()运算符
9
    }
10
};
11

12
// 假设Date类已经定义并重载了<运算符
13

14
int main() {
15
    Date d1(2022, 7, 7);
16
    Date d2(2022, 7, 6);
17
    Date d3(2022, 7, 8);
18

19
    vector<Date> v1;
20
    v1.push_back(d1);
21
    v1.push_back(d2);
22
    v1.push_back(d3);
23
    // 直接排序Date对象，使用Date类的<运算符
24
    sort(v1.begin(), v1.end(), Less<Date>());
25

26
    vector<Date*> v2;
27
    v2.push_back(&d1);
28
    v2.push_back(&d2);
29
    v2.push_back(&d3);
30
    // 排序指针，比较的是地址而不是Date对象
31
    sort(v2.begin(), v2.end(), Less<Date*>());
32
    return 0;
33
}