1
class Base {
2
public:
3
    // 虚析构函数
4
    // 如果一个类要作为基类，并且可能会通过基类指针删除派生类对象，
5
    // 那么它的析构函数应该声明为 virtual。
6
    // 这样可以确保在删除派生类对象时，先调用派生类的析构函数，然后再调用基类的析构函数。
7
    // = default; 表示使用编译器生成的默认实现。
8
    virtual ~Base() = default;
9

10
    // 纯虚函数 (Pure Virtual Function)
11
    // 纯虚函数在基类中没有实现，它强制派生类必须提供该函数的具体实现。
12
    // const 表示该成员函数不会修改类的成员变量。
13
    // = 0; 表明这是一个纯虚函数。
14
    virtual int function(int x) const = 0;
15

16
    // 普通虚函数 (示例)
17
    virtual void printType() {
18
        cout << "This is Base class" << endl;
19
    }
20
};
21

22
class Derived : public Base {
23
public:
24
    // 覆盖 (override) 基类的虚析构函数
25
    // ~Derived() override { cout << "Derived destructor called" << endl; } // C++11 override 关键字
26
    ~Derived() { /* cout << "Derived destructor called" << endl; */ } // 也可以不加 override
27

28
    // 实现基类中的纯虚函数
29
    // C++11 中推荐使用 override 关键字明确表示这是对基类虚函数的覆盖
30
    int function(int x) const override {
31
        return x * x;
32
    }
33

34
    // 覆盖基类的普通虚函数
35
    void printType() override {
36
        cout << "This is Derived class" << endl;
37
    }
38
};
39

40
// 示例用法：
41
// int main() {
42
//     // Base b; // 错误！Base 是抽象类，不能实例化
43
//
44
//     Derived d;
45
//     cout << "d.function(5): " << d.function(5) << endl; // 输出 25
46
//
47
//     Base* ptr_b = &d; // 基类指针指向派生类对象
48
//     cout << "ptr_b->function(10): " << ptr_b->function(10) << endl; // 输出 100 (调用 Derived::function)
49
//     ptr_b->printType(); // 输出 "This is Derived class" (调用 Derived::printType)
50
//
51
//     // 如果 Base 的析构函数不是 virtual，通过基类指针 delete 派生类对象可能导致资源泄漏
52
//     // Base* ptr_heap = new Derived();
53
//     // delete ptr_heap; // 正确调用 Derived 和 Base 的析构函数
54
//
55
//     return 0;
56
// }

1
#include <stdexcept> // 为了使用 std::out_of_range
2

3
template <typename T, int i> // T 是类型参数，i 是非类型参数 (整数常量)
4
class TestClass {
5
public:
6
    T buffer[i]; // T 类型的数组，其大小由非类型参数 i 决定
7

8
    // 构造函数 (示例)
9
    TestClass() {
10
        // 可以在这里初始化 buffer，例如：
11
        // for(int k = 0; k < i; ++k) {
12
        //     buffer[k] = T(); // 使用 T 类型的默认构造函数初始化
13
        // }
14
    }
15

16
    // 成员函数声明
17
    T getData(int j);
18

19
    // 另一个成员函数示例
20
    void setData(int j, T value) {
21
        if (j >= 0 && j < i) {
22
            buffer[j] = value;
23
        } else {
24
            // 处理越界，例如抛出异常
25
            throw std::out_of_range("Index out of bounds in setData");
26
        }
27
    }
28

29
    int getSize() const {
30
        return i;
31
    }
32
};
33

34
// 类模板的成员函数定义在类外时，需要再次声明模板参数列表
35
template <typename T, int i>
36
T TestClass<T, i>::getData(int j) {
37
    if (j >= 0 && j < i) {
38
        return *(buffer + j); // 等价于 buffer[j]
39
    } else {
40
        // 处理越界，例如抛出异常或返回默认值
41
        throw std::out_of_range("Index out of bounds in getData");
42
        // 或者 return T(); // 返回 T 类型的默认构造值
43
    }
44
}
45

46
// 示例用法：
47
// int main() {
48
//     TestClass<int, 10> intTest; // T 为 int, i 为 10
49
//     intTest.setData(0, 100);
50
//     intTest.setData(5, 500);
51
//
52
//     cout << "intTest.getData(0): " << intTest.getData(0) << endl; // 输出 100
53
//     cout << "intTest.getData(5): " << intTest.getData(5) << endl; // 输出 500
54
//     cout << "Size of intTest buffer: " << intTest.getSize() << endl; // 输出 10
55
//
56
//     TestClass<double, 5> doubleTest; // T 为 double, i 为 5
57
//     doubleTest.setData(2, 3.14);
58
//     cout << "doubleTest.getData(2): " << doubleTest.getData(2) << endl; // 输出 3.14
59
//
60
//     // TestClass<int, 0> zeroSizeTest; // 通常 i 必须大于 0，否则 buffer[0] 是非法的
61
//
62
//     try {
63
//         cout << intTest.getData(10) << endl; // 会抛出异常
64
//     } catch (const std::out_of_range& e) {
65
//         cerr << "Exception: " << e.what() << endl;
66
//     }
67
//
68
//     return 0;
69
// }

1
#include <memory> // 为了使用 std::unique_ptr
2

3
// 假设 GtLever 函数的声明 (具体实现未知，仅为示例)
4
// 它接收一个 T 类型的数组，数组长度 n，以及一个 T 类型的 lever 值
5
template <class T>
6
void GtLever(const T* arr, int n, T lever) {
7
    cout << "GtLever called with lever: " << lever << " and array: ";
8
    for (int i = 0; i < n; ++i) {
9
        cout << arr[i] << (i == n - 1 ? "" : ", ");
10
    }
11
    cout << endl;
12
    // 实际的 GtLever 逻辑会在这里
13
}
14

15
// 处理输入和调用 GtLever 的函数模板
16
template <class T> // T 是类型参数
17
void processInput(int length, int n_for_gtlever) { // 修改了第二个参数名以示区分
18
    // 使用智能指针 std::unique_ptr 管理动态分配的数组内存
19
    // std::unique_ptr<T[]> arr(new T[length]);
20
    // C++14 及以后版本推荐使用 std::make_unique
21
    std::unique_ptr<T[]> arr = std::make_unique<T[]>(length);
22

23
    cout << "Enter " << length << " elements of type " << typeid(T).name() << ":" << endl;
24
    for (int i = 0; i < length; i++) {
25
        cin >> arr[i];
26
    }
27

28
    T lever;
29
    cout << "Enter the lever value of type " << typeid(T).name() << ":" << endl;
30
    cin >> lever;
31

32
    // 调用 GtLever 函数
33
    // arr.get() 返回指向 unique_ptr所管理数组的原始指针
34
    GtLever(arr.get(), n_for_gtlever, lever); // 假设 GtLever 需要的长度是 n_for_gtlever
35
                                             // 如果 GtLever 处理整个 arr，则应传递 length
36
}
37

38
// 示例用法 (构造方法调用)：
39
// int main() {
40
//     int length, n;
41
//
42
//     cout << "Processing char input:" << endl;
43
//     cout << "Enter array length: ";
44
//     cin >> length;
45
//     cout << "Enter n for GtLever: ";
46
//     cin >> n;
47
//     processInput<char>(length, n); // 实例化函数模板，T 为 char
48
//
49
//     cout << "\nProcessing int input:" << endl;
50
//     cout << "Enter array length: ";
51
//     cin >> length;
52
//     cout << "Enter n for GtLever: ";
53
//     cin >> n;
54
//     processInput<int>(length, n); // 实例化函数模板，T 为 int
55
//
56
//     return 0;
57
// }

1
// 假设 T 是一个已定义的类型或模板参数
2
// template <typename T> // 如果 C1 本身是模板类
3
class C1 {
4
public:
5
    int num;
6
    std::unique_ptr<int[]> a; // 使用 int[] 作为示例，原代码是 T[]
7

8
    // 构造函数
9
    // 使用成员初始化列表来初始化 num 和智能指针 a
10
    // std::make_unique<T[]>(n) (C++14+) 是推荐的初始化方式
11
    C1(int n) : num(n), a(std::make_unique<int[]>(n)) {
12
        cout << "C1 constructor called. num = " << num << ". Array of size " << n << " allocated." << endl;
13
        // 可以在这里初始化数组 a 的内容
14
        for (int i = 0; i < n; ++i) {
15
            a[i] = i * 10; // 示例初始化
16
        }
17
    }
18

19
    // 析构函数 (由 unique_ptr 自动管理内存，通常不需要显式 delete)
20
    ~C1() {
21
        cout << "C1 destructor called. Memory for array will be automatically deallocated by unique_ptr." << endl;
22
    }
23

24
    void printArray() const {
25
        if (num > 0 && a) {
26
            cout << "Array contents: ";
27
            for (int i = 0; i < num; ++i) {
28
                cout << a[i] << (i == num - 1 ? "" : ", ");
29
            }
30
            cout << endl;
31
        } else {
32
            cout << "Array is empty or not allocated." << endl;
33
        }
34
    }
35
};
36

37
// 示例用法：
38
// int main() {
39
//     C1 obj1(5);
40
//     obj1.printArray();
41
//
42
//     // 当 obj1 离开作用域时，其析构函数被调用，
43
//     // unique_ptr a 会自动释放其管理的动态数组内存。
44
//
45
//     return 0;
46
// }

1
a.Clock::settime(h, m, s);
2
a.Clock::showtime();

1
a.settime(h, m, s);
2
a.showtime();