C++开发学习笔记3

C++ 中枚举的使用

在C++中，枚举常量（Enumeration Constants）是一种定义命名常量的方式。枚举类型允许我们为一组相关的常量赋予有意义的名称，并将它们作为一个独立的类型来使用。

以下是定义和使用枚举常量的示例：

enum Color {
    RED,
    GREEN,
    BLUE
};

int main() {
    Color myColor = RED;
    if (myColor == GREEN) {
        // 执行GREEN相关的逻辑
    } else if (myColor == BLUE) {
        // 执行BLUE相关的逻辑
    } else {
        // 执行默认逻辑（RED）
    }
    
    return 0;
}

在上述代码中，我们定义了一个名为Color的枚举类型，并声明了三个枚举常量RED、GREEN和BLUE。这些常量都属于Color类型，它们实际上是整数值，默认从0开始递增。

在main()函数中，我们创建了一个myColor变量，并将其初始化为RED枚举常量。我们可以使用if语句来检查myColor的值，根据不同的情况执行相应的逻辑。

需要注意的是，枚举常量是命名的整数值，并且可以通过名称进行比较和赋值操作。此外，我们也可以指定枚举常量的具体整数值，例如：

enum Status {
    OK = 200,
    NOT_FOUND = 404,
    INTERNAL_ERROR = 500
};

在这个示例中，我们为枚举常量OK、NOT_FOUND和INTERNAL_ERROR分别指定了整数值200、404和500。这样做可以在需要时将枚举常量与特定的整数值相关联。

总之，C++中的枚举常量提供了一种定义有意义的命名常量的方式，并使得代码更易读、更具可维护性。

C++ 中程序睡眠

在 C++ 中，可以使用 <thread> 头文件中的 sleep_for() 函数来实现睡眠功能。sleep_for() 函数接受一个时间段作为参数，指定程序需要休眠的时间长度。

下面是一个示例代码，展示了如何在 C++ 中使用 sleep_for() 函数实现睡眠功能：

#include <iostream>
#include <thread> // 包含 <thread> 头文件

int main() {
    std::cout << "开始执行程序" << std::endl;

    // 休眠 2 秒
    std::this_thread::sleep_for(std::chrono::seconds(2));

    std::cout << "休眠结束，继续执行程序" << std::endl;

    return 0;
}

在上面的示例中，我们通过调用 std::this_thread::sleep_for() 函数并传入 `std::chrono::seconds

C++ 如何释放内存

在C++中，可以使用以下几种方法来释放动态分配的内存：

1. 使用delete释放单个对象的内存：

   int* ptr = new int;  // 动态分配一个整数对象的内存
   // 使用分配的内存
   delete ptr;  // 释放内存

2. 使用delete[]释放数组的内存：

   int* arr = new int[5];  // 动态分配一个整数数组的内存
   // 使用分配的内存
   delete[] arr;  // 释放内存

3. 使用free函数释放通过malloc、calloc或realloc分配的内存：

   int* ptr = (int*)malloc(sizeof(int));  // 分配内存
   // 使用分配的内存
   free(ptr);  // 释放内存

需要注意的是：

• 动态分配的内存必须由相应的释放函数进行释放，以避免内存泄漏。
• 在释放内存之后，不要再访问已释放的内存块，以免发生未定义行为。
• 删除或释放空指针是安全的，因此在释放内存之后最好将指针设置为nullptr，以防止误用。

另外，使用智能指针（如std::unique_ptr和std::shared_ptr）等现代C++特性可以更方便地管理内存，并避免手动释放内存的问题。这些智能指针会在不再需要时自动释放它们持有的内存。

C++ 参数传递方式

在C++中，有两种主要的参数传递方式：值传递和引用传递。

1. 值传递：
   • 值传递是将实际参数的副本传递给函数或方法。
   • 在值传递中，函数或方法使用参数的副本进行操作，对原始参数没有影响。
   • 在函数或方法内部，会为参数的副本分配新的内存空间，并在函数或方法调用结束后释放该空间。
   • 值传递不会改变原始参数的值。

示例代码：

void modifyValue(int x) {
    x = 10;  // 修改参数的副本
}

int main() {
    int num = 5;
    modifyValue(num);  // 值传递
    // num 的值仍然是 5，没有被修改
    return 0;
}

2. 引用传递：
   • 引用传递是将实际参数的引用传递给函数或方法。
   • 在引用传递中，函数或方法使用参数的引用直接对原始参数进行操作。
   • 在函数或方法内部，没有为参数分配新的内存空间，它直接引用了原始参数的内存空间。
   • 引用传递可以改变原始参数的值。

示例代码：

void modifyValue(int& x) {
    x = 10;  // 直接修改原始参数
}

int main() {
    int num = 5;
    modifyValue(num);  // 引用传递
    // num 的值被修改为 10
    return 0;
}

需要注意的是，无论是值传递还是引用传递，都会在函数或方法调用结束后自动释放传递的参数。但是，在引用传递中，由于直接引用了原始参数的内存空间，所以可以对其进行修改并影响原始参数的值。而值传递只是操作了参数的副本，不会改变原始参数的值。

关于析构函数的特性

C++ 的析构函数（Destructor）是一种特殊的成员函数，用于在对象被销毁时执行清理工作。它的实现原理如下：

1. 析构函数的命名规则是在类名前加上一个波浪线（~），后接类名，例如~ClassName。
2. 析构函数没有参数，也不能被重载，每个类只能有一个析构函数。
3. 当对象被销毁时（例如离开作用域、delete 操作符释放动态分配的内存），编译器会自动调用对象的析构函数。
4. 对象的析构函数按照创建对象的顺序逆序调用，即最后创建的对象先调用析构函数。
5. 析构函数可以显式定义，也可以使用编译器生成的默认析构函数。
6. 如果显式定义了析构函数，编译器就不会生成默认的析构函数。
7. 在析构函数中，可以执行必要的清理工作，如释放动态分配的内存、关闭打开的文件、释放资源等。

在程序运行过程中，当对象即将被销毁时，编译器会自动插入对析构函数的调用。这样可以确保在对象生命周期结束时进行清理操作，避免资源泄漏和内存泄漏问题。

需要注意的是，在有继承关系的类中，基类的析构函数应该声明为虚函数，以便子类能够正确调用其自身的析构函数。这是因为在使用基类指针或引用指向派生类对象时，如果基类的析构函数不是虚函数，那么就无法通过基类指针或引用来调用派生类的析构函数，从而导致资源无法正确释放。

总结：C++ 的析构函数通过编译器自动调用，在对象销毁时执行必要的清理工作，它的实现原理包括命名规则、调用顺序等。合理使用析构函数可以确保资源的正确释放，避免内存泄漏和资源泄漏问题的发生。

C++ 的析构函数实际上是由编译器自动生成和调用的，其实现原理如下：

1. 自动调用：当对象的生命周期结束时，编译器会自动调用适当的析构函数。这可以发生在以下几种情况下：

   • 对象离开其作用域：当对象在函数中定义，并且超出了其作用域范围时，编译器会自动调用该对象的析构函数。
   • 动态分配内存的对象被释放：如果通过new关键字动态创建了对象并进行了内存分配，在使用delete操作符释放内存时，编译器会自动调用该对象的析构函数。
   • 对象被销毁：当一个对象作为另一个对象的成员时，当包含它的对象被销毁时，编译器会自动调用该成员对象的析构函数。

2. 生成默认析构函数：如果没有显式定义析构函数，编译器会自动生成一个默认的析构函数。默认析构函数的实现为空，即不执行任何操作。

3. 显式定义析构函数：在需要进行一些清理工作的情况下，可以显式地在类中定义析构函数。在析构函数的定义中，可以编写所需的清理代码，例如释放动态分配的内存、关闭文件、释放资源等。

4. 调用顺序：在具有继承关系的类中，当派生类对象被销毁时，会先自动调用派生类的析构函数，然后再调用基类的析构函数。这样可以确保在对象层次结构中的每个类都能够执行必要的清理工作，并按照正确的顺序进行。

需要注意的是，如果在基类中将析构函数声明为虚函数（使用virtual关键字），则在通过基类指针或引用删除派生类对象时，会调用正确的析构函数。这是因为虚析构函数允许动态绑定，在运行时选择正确的析构函数。

总结：C++ 的析构函数实际上是由编译器自动生成和调用的，它的实现原理涉及自动调用、默认生成、显式定义和调用顺序等方面。合理使用析构函数可以确保资源的正确释放，避免内存泄漏和资源泄漏问题的发生。

C++ 全局变量

C++ 中的全局变量是在函数外部定义的变量，可以在程序的任何地方使用。全局变量在整个程序中都是可见的，可以被多个函数或模块使用。

在C++中，全局变量的声明通常放在头文件中，并且在源文件中进行定义和初始化。全局变量可以有不同的存储类别（如 static、extern 等），它们决定了全局变量的作用域和生命周期。

以下是一个示例：

// 头文件 global_var.h
extern int globalVar; // 声明全局变量

// 源文件 main.cpp
#include "global_var.h"

int globalVar = 10; // 定义并初始化全局变量

void func()
{
    // 在这里可以使用全局变量 globalVar
}

int main()
{
    // 在这里也可以使用全局变量 globalVar
    return 0;
}

需要注意的是，全局变量的使用应该谨慎，因为它们具有全局作用域，可能会导致代码的可读性和维护性下降。过多地依赖全局变量可能会增加代码之间的耦合性，使程序难以理解和调试。因此，在设计程序时，应尽量避免过度使用全局变量。

C++ 数组的长度

在 Qt C++ 中，数组的长度可以使用 sizeof 运算符来获取。以下是示例代码：

#include <iostream>

int main() {
    int arr[] = {1, 2, 3, 4, 5};

    int length = sizeof(arr) / sizeof(arr[0]);
    // 在此处可以使用 length 进行后续操作

    return 0;
}

在上述示例中，length 变量将保存数组 arr 的长度，即5。通过 sizeof(arr) 获取整个数组的字节大小，再除以 sizeof(arr[0]) 获取单个元素的字节大小，从而计算出数组的长度。

请注意，这种方法仅适用于静态数组，对于动态分配的数组或指针，你需要另外维护一个变量来记录其长度。

C++ 哪些参数需要释放内存

在C++中，需要手动释放内存的参数主要包括以下几种情况：

1. 动态分配的内存：当你使用new关键字分配内存时，需要使用delete关键字手动释放内存。例如：

int* p = new int;
// 使用指针p指向的内存
delete p; // 释放内存

2. 动态分配的数组：当你使用new[]关键字分配数组内存时，需要使用delete[]关键字手动释放内存。例如：

int* arr = new int[10];
// 使用数组arr中的元素
delete[] arr; // 释放内存

3. 文件指针：当你使用fopen函数打开文件并返回一个FILE*指针时，需要使用fclose函数关闭文件并释放相关资源。例如：

FILE* file = fopen("example.txt", "r");
// 使用文件指针file进行文件操作
fclose(file); // 关闭文件并释放资源

4. 动态分配的对象：当你使用new关键字动态分配一个对象时，需要使用delete关键字手动释放对象的内存。例如：

class MyClass {
    // 类定义
};

MyClass* obj = new MyClass;
// 使用对象obj
delete obj; // 释放对象内存

需要注意的是，在C++中，只有手动分配的内存需要手动释放。对于自动分配的内存，例如局部变量或静态变量，不需要手动释放，因为它们的内存管理由系统自动处理。

同时，还有一些情况下需要注意内存的释放，例如在使用第三方库或操作系统提供的资源时，可能需要按照相应的规则进行内存的释放。具体的释放方式取决于所使用的库或资源的要求和文档。

总之，对于通过new、new[]或特定函数分配的内存，需要在使用完毕后手动释放对应的资源，以避免内存泄漏和资源浪费。

BaseServer server(); 这种需要delete server 吗

在C++中，当你使用 new 关键字创建对象时，你需要使用 delete 关键字手动释放内存。但是，在你提供的代码片段 BaseServer server(); 中，并没有使用 new 关键字来创建对象，而是直接调用了 BaseServer 的默认构造函数来创建对象。

在这种情况下，对象 server 是在栈上自动分配的，它的内存会在它超出作用域时自动释放。因此，你不需要使用 delete 关键字来手动释放这个对象的内存。

简而言之，当你使用默认构造函数创建对象，并且在栈上自动分配内存时，不需要手动释放内存。内存的释放将由系统自动处理。

但是，如果你在使用 new 关键字创建对象时，例如 BaseServer* server = new BaseServer();，这时你需要使用 delete 关键字手动释放内存，例如 delete server;。这是因为使用 new 关键字在堆上分配的内存需要手动释放，否则会发生内存泄漏。

总结来说，根据你提供的代码片段 BaseServer server();，你不需要手动释放内存。内存的释放将由系统自动处理。

C++中对于指针应该注意哪些问题

在C++中，使用指针是一项强大而灵活的特性，但也需要特别注意一些问题。下面是一些指针使用中需要注意的问题：

1. 野指针：指针未经初始化或已释放的指针称为野指针。使用野指针可能导致访问非法内存，引发程序崩溃或产生不可预测的结果。确保在使用指针之前，将其初始化为有效的内存地址，或者将其设置为nullptr。

2. 空指针：空指针是指不指向任何有效对象或函数的指针。使用空指针可能导致解引用错误，因此在使用指针之前，要确保它不为空。

3. 内存泄漏：内存泄漏是指在程序中分配了内存但没有释放，导致无法再次使用该内存。为避免内存泄漏，确保在不再需要使用指针指向的内存时，使用delete或delete[]释放相应的内存。

4. 重复释放：**重复释放同一块内存可能导致程序崩溃或不可预测的行为。**确保每个new或new[]操作都有相应的delete或delete[]操作，并且只释放一次。

5. 悬空指针：悬空指针是指指向已释放内存的指针。在释放内存后，要避免继续使用指向该内存的指针。可以通过将指针设置为nullptr来避免悬空指针。

6. 指针算术：指针算术允许对指针进行加法、减法等操作。但要谨慎使用指针算术，确保不会越界访问或操作无效的内存地址。

7. 引用悬挂：当指针指向的对象在使用之前被释放时，指针将变为悬挂指针。避免在指针仍然有效的情况下使用已释放的对象。

8. 野指针和空指针的检查：在使用指针之前，始终对指针进行有效性检查，以避免野指针和空指针引发的错误。

9. 堆栈和堆内存：**在C++中，栈上分配的变量将在其作用域结束时自动释放，而堆上使用new操作符分配的内存需要手动释放。**确保在不再需要使用堆上分配的内存时，使用delete或delete[]释放相应的内存。

10. 使用智能指针：C++11引入了智能指针，如std::shared_ptr和std::unique_ptr，它们可以更安全地管理动态内存，减少人工释放内存的错误。

以上是使用指针时需要注意的一些常见问题。遵循良好的指针使用习惯，可以减少内存错误和程序崩溃的风险。

遍历List

在 C++ 中，有多种方式可以遍历 std::list。以下是几种常见的方法：

1. 使用迭代器

   #include <iostream>
   #include <list>
   using namespace std;
   
   int main() {
       list<int> myList = {1, 2, 3, 4, 5};
       
       for (auto it = myList.begin(); it != myList.end(); ++it) {
           cout << *it << " ";
       }
       cout << endl;
       
       return 0;
   }

2. 使用范围-based for 循环

   #include <iostream>
   #include <list>
   using namespace std;
   
   int main() {
       list<int> myList = {1, 2, 3, 4, 5};
       
       for (const auto& value : myList) {
           cout << value << " ";
       }
       cout << endl;
       
       return 0;
   }

无论使用哪种方式，都可以对 std::list 进行遍历，并输出其中的元素。

override 的作用是什么

override 是 C++11 引入的一个关键字，用于显式地标记一个成员函数（包括虚函数）覆盖（重写）了基类中的同名函数。它的作用有两个方面：

1. 编译器检查：使用 override 关键字可以告诉编译器，我们有意重写了基类中的同名函数。如果基类中不存在这个函数，或者函数签名与基类中的函数不匹配，编译器会发出错误。这样可以帮助我们在编译时捕获潜在的错误，例如拼写错误、函数参数不匹配等。

2. 代码可读性和可维护性：在代码中使用 override 关键字可以使代码更加清晰和易于理解。通过显式地标记覆盖关系，我们可以清楚地知道派生类中的函数是有意重写了基类中的函数，而不是一个新的函数或者误用了函数名。

以下是一个示例，演示了在派生类中使用 override 关键字的情况：

class Base {
public:
    virtual void foo();
    virtual void bar(int x);
};

class Derived : public Base {
public:
    void foo() override; // 显式重写基类的虚函数
    void bar(int x) override; // 显式重写基类的虚函数
    // void foo() override; // 错误：没有对应的基类函数可重写
    // void baz() override; // 错误：没有对应的基类函数可重写
};

在上述示例中，Derived 类通过使用 override 关键字明确表示它重写了 Base 类中的 foo() 和 bar(int x) 函数。如果没有正确地重写基类函数，或者函数签名不匹配，编译器将会报错。

总之，override 关键字可以提供更好的代码检查和可读性，帮助我们避免一些潜在的错误，并使代码更易于理解和维护。

const char *type 转 int

要将 const char* 类型的字符串转换为 int 类型，可以使用标准库函数 std::stoi() 或 std::atoi() 进行转换。这两个函数都可以将字符串转换为整数。

下面是使用 std::stoi() 函数的示例代码：

#include <iostream>
#include <string>

int main() {
    const char* str = "12345";
    int intValue = std::stoi(str);

    std::cout << "Converted value: " << intValue << std::endl;

    return 0;
}

在这个示例中，我们将字符串 "12345" 转换为整数。std::stoi() 函数会自动解析字符串中的有效数字，并将其转换为整数。转换后的整数值存储在 intValue 变量中。

另外，如果你只需要简单地将字符串转换为整数，也可以使用 std::atoi() 函数。以下是使用 std::atoi() 函数的示例代码：

#include <iostream>
#include <cstdlib>

int main() {
    const char* str = "12345";
    int intValue = std::atoi(str);

    std::cout << "Converted value: " << intValue << std::endl;

    return 0;
}

std::atoi() 函数将字符串转换为一个整数，但是它对于错误处理相对较弱。如果字符串无效或无法转换为整数，它会返回0。

在使用这些函数进行转换时，请确保字符串中的内容是有效的整数表示，并且没有超出目标类型的范围。如果字符串无法转换为整数，将会引发异常（std::invalid_argument 或 std::out_of_range），你可以适当地处理这些异常以避免程序崩溃。

希望这个解答对你有帮助。如果还有其他问题，请随时提问。

extern 含义及用法

C++中的extern关键字用于声明外部变量或函数。它的作用是告诉编译器该变量或函数是在其他地方定义的，而不是在当前文件中定义的。

extern关键字可以有以下用法：

1. 声明外部全局变量：在一个文件中使用extern关键字声明一个全局变量，然后在另一个文件中定义该全局变量。这样可以在C++中的extern关键字用于声明外部变量或函数。它的作用是告诉编译器该变量或函数是在其他地方定义的，而不是在当前文件中定义的。

extern关键字可以有以下用法：

1. 声明外部全局变量：在一个文件中使用extern关键字声明一个全局变量，然后在另一个文件中定义该全局变量。这样可以在多个文件中共享同一个全局变量。例如：

   // File1.cpp
   extern int globalVariable; // 声明外部全局变量
   
   // File2.cpp
   int globalVariable = 10; // 定义外部全局变量
   ​```

2. 声明外部函数：使用extern关键字可以在一个文件中声明一个外部函数，然后在另一个文件中定义该函数。这样可以在多个文件中共享同一个函数。例如：

   // File1.cpp
   extern void externalFunction(); // 声明外部函数
   
   // File2.cpp
   void externalFunction() { // 定义外部函数
       // 函数实现
   }
   ​```

3. 引用外部变量：使用extern关键字可以在一个文件中引用另一个文件中定义的外部变量。这样可以使用其他文件中定义的变量而无需重新定义。例如：

   // File1.cpp
   extern int globalVariable; // 声明外部全局变量
   
   // File2.cpp
   int globalVariable = 10; // 定义外部全局变量
   
   // File3.cpp
   extern int globalVariable; // 引用外部全局变量
   ​```

请注意，extern关键字的具体用法和作用范围取决于具体的上下文和使用场景。它可以用于不同的文件之间、不同的源文件之间以及在不同的编译单元之间共享变量和函数。

extern 与 static 有什么区别

extern和static是C++中两个具有不同作用的关键字。

1. extern关键字用于声明外部变量或函数，表示该变量或函数是在其他地方定义的。它的作用是告诉编译器该变量或函数的定义在其他文件或编译单元中，并在当前文件中进行引用。extern关键字通常用于全局变量和函数的声明，以便在多个文件中共享这些变量和函数。

   // File1.cpp
   extern int globalVariable; // 声明外部全局变量
   
   // File2.cpp
   int globalVariable = 10; // 定义外部全局变量
   ​```
   
   在这个例子中，`extern`关键字在File1.cpp中声明了一个外部全局变量，然后在File2.cpp中定义了该全局变量。这样可以在多个文件中共享同一个全局变量。

2. static关键字有多种用途，其中一个是用于限制变量或函数的作用域。当static关键字用于全局变量时，它表示该变量的作用域仅限于当前文件，即使在其他文件中也无法访问该变量。当static关键字用于函数时，它表示该函数的作用域仅限于当前文件，即该函数只能在当前文件中调用。

   // File1.cpp
   static int staticVariable = 5; // 声明并定义静态全局变量
   
   // File2.cpp
   int main() {
       // 无法访问File1.cpp中定义的静态全局变量
       return 0;
   }
   ​```
   
   在这个例子中，`static`关键字用于定义一个静态全局变量`staticVariable`，它的作用域仅限于File1.cpp文件，无法在其他文件中访问。

除了作用域的不同，static关键字还可以用于局部变量和函数，表示只初始化一次并保持其值的持久性。

总结而言，extern关键字用于声明外部变量和函数，以在不同文件或编译单元中共享。而static关键字用于限制变量和函数的作用域，并可用于保持局部变量和函数的持久性。

浮点数无论小数位是多少都向上取整

如果你想要将一个浮点数无论小数位是多少都向上取整，可以使用 std::ceil() 函数。这个函数位于 <cmath> 头文件中，可以对浮点数进行向上取整操作。

以下是一个示例代码，演示如何使用 std::ceil() 函数将浮点数向上取整：

#include <iostream>
#include <cmath>

int main() {
    double number = 3.14;
    double roundedNumber = std::ceil(number);

    std::cout << "Original Number: " << number << std::endl;
    std::cout << "Rounded Number: " << roundedNumber << std::endl;
   //转为int
    std::cout << "Rounded int: " << static_cast<int>(std::ceil(number)) << std::endl;

    return 0;
}

在上述示例中，我们定义了一个浮点数 number，其值为 3.14。然后，我们使用 std::ceil() 函数将其向上取整，并将结果存储在 roundedNumber 变量中。

最后，我们使用 std::cout 输出原始数字和取整后的结果。

运行上述代码将输出：

Original Number: 3.14
Rounded Number: 4
Rounded int: 4

可以看到，原始数字 3.14 被向上取整为 4。

捕捉异常

在 C++ 中，异常处理是一种用于处理程序运行时错误的机制。C++ 使用 try、catch 和 throw 关键字来实现异常处理。当程序中发生异常时，可以通过抛出异常（throw）来中断程序的正常执行，并通过捕获异常（catch）来处理异常情况。

下面是一个简单的示例，演示了如何在 C++ 中捕获异常：

#include <iostream>

int divide(int a, int b) {
    if (b == 0) {
        throw "Division by zero!";
    }
    return a / b;
}

int main() {
    int a = 10;
    int b = 0;

    try {
        int result = divide(a, b);
        std::cout << "Result: " << result << std::endl;
    } catch (const char* msg) {
        std::cerr << "Exception caught: " << msg << std::endl;
    }

    return 0;
}

在这个示例中，divide() 函数用于执行整数除法操作。如果除数 b 为 0，则会抛出一个字符串类型的异常。在 main() 函数中，我们使用 try 块来包裹可能抛出异常的代码块，并使用 catch 块来捕获异常并处理它。

在 catch 块中，我们可以指定捕获的异常类型。在这个示例中，我们捕获了一个指向 const char* 类型的异常，并将异常信息输出到标准错误流中。

除了基本的字符串异常，C++ 还支持使用自定义的异常类来进行异常处理。可以定义自己的异常类，并在 throw 和 catch 块中使用这些类来处理异常。

总的来说，异常处理是一种重要的编程技巧，能够帮助程序员更好地处理程序中的错误情况，提高程序的健壮性和可靠性。

模板类

在C++中，模板类是一种通用的类模板，允许你编写通用代码，而不必为每种特定类型重复编写代码。通过使用模板类，你可以编写一次代码，然后根据不同的数据类型使用该代码。下面是一个简单的示例，展示了如何定义和使用一个简单的模板类：

#include <iostream>

// 定义一个简单的模板类
template <class T>
class MyTemplateClass {
private:
    T data;

public:
    MyTemplateClass(T value) {
        data = value;
    }

    void displayData() {
        std::cout << "Data: " << data << std::endl;
    }
};

int main() {
    // 使用模板类实例化不同类型的对象
    MyTemplateClass<int> intObj(5);
    intObj.displayData();

    MyTemplateClass<std::string> stringObj("Hello, World!");
    stringObj.displayData();

    return 0;
}

在上面的示例中，我们定义了一个名为MyTemplateClass的模板类，其中包含一个数据成员和一个成员函数。通过使用关键字template <class T>，我们告诉编译器MyTemplateClass是一个模板类，T是一个模板参数，可以是任意数据类型。在main函数中，我们实例化了两个不同类型的MyTemplateClass对象：一个是整数类型，另一个是字符串类型。

通过使用模板类，你可以有效地编写通用代码，以处理不同类型的数据，从而提高代码的重用性和灵活性。请注意，模板类的实现通常位于头文件中，因为编译器需要访问模板类的定义以实例化特定类型的模板。