C++模板教程：函数模板与类模板入门

1
int maxInt(int a, int b) { return a > b ? a : b; }
2
double maxDouble(double a, double b) { return a > b ? a : b; }
3
string maxString(string a, string b) { return a > b ? a : b; }
4
// 每种类型都要写一遍，代码重复

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

4
// 函数模板：template <typename T>
5
template <typename T>
6
T myMax(T a, T b) {
7
    return a > b ? a : b;
8
}
9

10
int main() {
11
    // 隐式实例化：编译器推导 T
12
    cout << myMax(3, 7) << endl;        // T = int → 7
13
    cout << myMax(3.5, 2.8) << endl;    // T = double → 3.5
14
    cout << myMax('a', 'b') << endl;    // T = char → b
15

16
    // 显式指定类型
17
    cout << myMax<double>(3, 2.5) << endl;  // 3
18

19
    string s1 = "apple", s2 = "banana";
20
    cout << myMax(s1, s2) << endl;      // banana（字符串按字典序）
21
    return 0;
22
}

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

4
// 返回类型由参数推导
5
template <typename T>
6
T square(T x) {
7
    return x * x;
8
}
9

10
// 模板参数之间会统一（同一 T 必须一致）
11
template <typename T>
12
T add(T a, T b) {
13
    return a + b;
14
}
15

16
int main() {
17
    cout << square(5) << endl;        // 25
18
    cout << square(2.5) << endl;      // 6.25
19

20
    // 两个参数类型必须一致
21
    // add(3, 3.5);   // 错误！int 和 double 冲突
22
    cout << add<double>(3, 3.5) << endl;  // 6.5（显式指定）
23

24
    // 自动类型转换在显式指定时生效
25
    cout << add(3, 4) << endl;        // 7
26
    return 0;
27
}

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

4
// 多个类型参数
5
template <typename T, typename U>
6
T convert(U value) {
7
    return static_cast<T>(value);
8
}
9

10
// 返回类型�
11
� auto + decltype（C++11）
12
template <typename T, typename U>
13
auto addFlexible(T a, U b) -> decltype(a + b) {
14
    return a + b;
15
}
16

17
// C++14 简化：auto 自动推导
18
template <typename T, typename U>
19
auto multiply(T a, U b) {
20
    return a * b;
21
}
22

23
int main() {
24
    cout << convert<int>(3.9) << endl;       // 3
25
    cout << addFlexible(3, 4.5) << endl;     // 7.5
26
    cout << multiply(2.5, 4) << endl;        // 10
27
    return 0;
28
}

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

4
// 普通函数（精确匹配优先）
5
int myMax(int a, int b) {
6
    cout << "普通函数" << endl;
7
    return a > b ? a : b;
8
}
9

10
// 模板函数
11
template <typename T>
12
T myMax(T a, T b) {
13
    cout << "模板函数" << endl;
14
    return a > b ? a : b;
15
}
16

17
int main() {
18
    cout << myMax(3, 7) << endl;          // 普通函数（int 精确匹配）
19
    cout << myMax(3.5, 2.8) << endl;      // 模板函数（无普通函数匹配）
20
    cout << myMax<>(3, 7) << endl;        // 模板函数（<> 强制用模板）
21
    return 0;
22
}

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

4
// 类模板：存储任意类型
5
template <typename T>
6
class Box {
7
private:
8
    T value;
9

10
public:
11
    Box(T v) : value(v) {}
12

13
    void set(T v) { value = v; }
14
    T get() const { return
15
 value; }
16

17
    void show() const {
18
        cout << "值: " << value << endl;
19
    }
20
};
21

22
int main() {
23
    Box<int> intBox(42);
24
    Box<string> strBox("Hello");
25
    Box<double> dblBox(3.14);
26

27
    intBox.show();     // 值: 42
28
    strBox.show();     // 值: Hello
29
    dblBox.show();     // 值: 3.14
30

31
    intBox.set(100);
32
    cout << intBox.get() << endl;   // 100
33
    return 0;
34
}

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

4
template <typename T>
5
class Calculator {
6
private:
7
    T a, b;
8

9
public:
10
    Calculator(T x, T y);
11
    T add() const;
12
    T subtract() const;
13
};
14

15
// 类外定义：需要重复 template 前缀
16
btract() const;
17
};
18

19
// 类外定义：需要重复 template 前缀
20
template <typename T>
21
Calculator<T>::Calculator(T x, T y) : a(x), b(y) {}
22

23
template <typename T>
24
T Calculator<T>::add() const {
25
    return a + b;
26
}
27

28
template <typename T>
29
T Calculator<T>::subtract() const {
30
    return a - b;
31
}
32

33
int main() {
34
    Calculator<int> ci(10, 3);
35
    cout << "int 加法: " << ci.add() << endl;       // 13
36

37
    Calculator<double> cd(5.5, 2.2);
38
    cout << "double 减法: " << cd.subtract() << endl;  // 3.3
39
    return 0;
40
}

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

4
template <typename T, int MAX_SIZE = 100>
5
class Stack {
6
private:
7
    T data[MAX_SIZE];
8
    int top;
9

10
public:
11
    Stack() : top(-1) {}
12

13
    bool push(const T &value) {
14
        if (top >= MAX_SIZE - 1) return false;
15
        data[++top] = value;
16
        return true;
17
    }
18

19
    bool pop(T &value) {
20
        if (top < 0) return false;
21
        value = data[top--];
22
        return true;
23
    }
24

25
    bool isEmpty() const { return top < 0; }
26
    int size() const { return top + 1; }
27
};
28

29
int main() {
30
    // 非类型模板参数：指定大小
31
    Stack<string, 10> stringStack;
32
    stringStack.push("C++");
33
    stringStack.push("Python");
34
    stringStack.push("Java");
35

36
    while (!stringStack.isEmpty()) {
37
        string item;
38
        stringStack.pop(item);
39
        cout << item << " ";
40
    }
41
    cout << endl;   // Java Python C++
42
    return 0;
43
}

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

5
// 默认模板参数：T2 默认 int
6
template <typename T, typename T2 = int>
7
class Pair {
8
private:
9
    T first;
10
    T2 second;
11

12
public:
13
    Pair(T f, T2 s) : first(f), second(s) {}
14

15
    void show() const {
16
        cout << first << ", " << second << endl;
17
    }
18
};
19

20
int main() {
21
    Pair<string> p1("张三", 25);        // 第二参数默认 int
22
    Pair<string, double> p2("分数", 88.5);   // 显式指定
23

24
    p1.show();   // 张三, 25
25
    p2.show();   // 分数, 88.5
26
    return 0;
27
}

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

4
// 非类型模板参数：秬速编译期常量（int、枨举、指针等）
5
template <int N>
6
int arraySum(int (&arr)[N]) {
7
    int sum = 0;
8
    for (int i = 0; i < N; i++) sum += arr[i];
9
    return sum;
10
}
11

12
template <int W, int H
13
>
14
class Rectangle {
15
public:
16
    static const int area = W * H;   // 编译期计算
17
};
18

19
int main() {
20
    int scores[] = {85, 90, 78};
21
    cout << "数组大小: " << arraySum(scores) << endl;  // 253（N 自动推导为 3）
22

23
    cout << "矩形面积: " << Rectangle<4, 5>::area << endl;  // 20
24
    return 0;
25
}

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

5
template <typename T>
6
class DataManager {
7
private:
8
    T *items;
9
    int capacity;
10
    int count;
11

12
    void resize() {
13
        capacity *= 2;
14
        T *newItems = new T[capacity];
15
        for (int i = 0; i < count; i++) newItems[i] = items[i];
16
        delete[] items;
17
        items = newItems;
18
    }
19

20
public:
21
    DataManager(int cap = 4) : capacity(cap), count(0) {
22
        items = new T[capacity];
23
    }
24

25
    ~DataManager() { delete[] items; }
26

27
    void add(const T &item) {
28
        if (count >= capacity) resize();
29
        items[count++] = item;
30
    }
31

32
    T get(int index) const {
33
        return items[index];
34
    }
35

36
    int size() const { return count; }
37

38
    T max() const {
39
        T result = items[0];
40
        for (int i = 1; i < count; i++) {
41
            if (items[i] > result) result = items[i];
42
        }
43
        return result;
44
    }
45

46
    void showAll() const {
47
        for (int i = 0; i < count; i++) {
48
            cout << items[i] << " ";
49
        }
50
        cout << endl;
51
    }
52
};
53

54
int main() {
55
    // 整数管理器
56
    DataManager<int> intManager;
57
    intManager.add(85);
58
    intManager.add(92);
59
    intManager.add(78);
60
    intManager.add(95);
61
    intManager.add(88);    // 触发扩容
62
    cout << "整数列表: ";
63
    intManager.showAll();
64
    cout << "最大值: " << intManager.max() << endl;
65
    cout << "个数: " << intManager.size() << endl;
66

67
    // 字符串管理器
68
    DataManager<string> strManager;
69
    strManager.add("C++");
70
    strManager.add("Python");
71
    strManager.add("Java");
72
    cout << "字符串列表: ";
73
    strManager.showAll();
74
    cout << "最大值: " << strManager.max() << endl;
75
    return 0;
76
}