1
#include <iostream>
2
#include <string>
3
using namespace std;
4
// 函数模板
5
template <class T>
6
T maximum(T a, T b) {
7
    return (a > b) ? a : b;
8
}
9
// 类模板
10
template <class T, int Size = 10>  // 支持默认模板参数
11
class Array {
12
private:
13
    T data[Size];
14
public:
15
    Array() {}
16

17
    T& operator[](int index) {
18
        return data[index];
19
    }
20
    const T& operator[](int index) const {
21
        return data[index];
22
    }
23
    int getSize() const {
24
        return Size;
25
    }
26
};
27
// 类模板显式特化
28
template <>
29
class Array<bool, 10> {
30
private:
31
    char data[2];  // 优化：用位存储bool
32
public:
33
    // 特化实现...
34
    Array() { /* 初始化代码 */ }
35

36
    bool& operator[](int index) {
37
        // 特化的operator[]实现
38
        static bool dummy = false;
39
        return dummy;
40
    }
41

42
    int getSize() const {
43
        return 10;
44
    }
45
};
46

47
int main() {
48
    // 函数模板使用
49
    int maxInt = maximum(10, 20);
50
    double maxDouble = maximum(3.14, 2.71);
51
    string maxString = maximum(string("apple"), string("banana"));
52

53
    // 类模板使用
54
    Array<int, 5> intArray;
55
    for (int i = 0; i < intArray.getSize(); i++) {
56
        intArray[i] = i * 10;
57
    }
58

59
    cout << "Max int: " << maxInt << endl;
60
    cout << "Max double: " << maxDouble << endl;
61
    cout << "Max string: " << maxString << endl;
62

63
    return 0;
64
}

1
using System;
2
// 泛型类
3
public class GenericList<T> {
4
    private T[] items;
5
    private int count;
6
    public GenericList(int capacity) {
7
        items = new T[capacity];
8
        count = 0;
9
    public void Add(T item) {
10
        if (count < items.Length) {
11
            items[count++] = item;
12
        }
13
    public T this[int index] {
14
        get {
15
            return items[index];
16
    public int Count {
17
        get { return count; }
18
// 泛型方法
19
public static class GenericHelper {
20
    public static T Maximum<T>(T a, T b) where T : IComparable<T> {
21
        return a.CompareTo(b) > 0 ? a : b;
22
    }
23
}
24

25
class Program {
26
    static void Main() {
27
        // 泛型类使用
28
        GenericList<int> intList = new GenericList<int>(5);
29
        intList.Add(10);
30
        intList.Add(20);
31
        intList.Add(30);
32

33
        // 泛型方法使用
34
        int maxInt = GenericHelper.Maximum(10, 20);
35
        string maxString = GenericHelper.Maximum("apple", "banana");
36
        Console.WriteLine("Max int: " + maxInt);
37
        Console.WriteLine("Max string: " + maxString);
38
        for (int i = 0; i < intList.Count; i++) {
39
            Console.WriteLine("List item " + i + ": " + intList[i]);
40
        }
41
    }
42
}
43
### 3. 模板与泛型结合使用示例
44
```cpp
45
// 此示例展示了在C++/CLI中结合使用模板和泛型
46
// compile with: /clr
47
using namespace System;
48

49
// 泛型类
50
generic <class ItemType>
51
ref class MyGeneric {
52
private:
53
    ItemType m_item;
54
public:
55
    MyGeneric(ItemType item) : m_item(item) {}
56

57
    void F() {
58
        Console::WriteLine("F");
59
    }
60
};
61

62
// 模板类，包装泛型类
63
template <typename T>
64
public ref class MyRef {
65
private:
66
    MyGeneric<T>^ ig;
67
public:
68
    MyRef(T t) {
69
        ig = gcnew MyGeneric<T>(t);
70
        ig->F();
71
    }
72
};
73

74
int main() {
75
    // 实例化模板，间接使用泛型
76
    MyRef<int>^ mref = gcnew MyRef<int>(11);
77
    return 0;
78
}