• 【C++提高编程-02】----C++泛型编程之类模板实战

    🎩 欢迎来到技术探索的奇幻世界👨‍💻

    📜 个人主页：@一伦明悦-CSDN博客

    ✍🏻 作者简介： C++软件开发、Python机器学习爱好者

    🗣️ 互动与支持：💬评论      👍🏻点赞      📂收藏     👀关注+

    如果文章有所帮助，欢迎留下您宝贵的评论，

    点赞加收藏支持我，点击关注，一起进步！

    前言             

            在C++中，泛型编程是一种编程范式，其核心思想是编写与数据类型无关的通用代码，以实现对不同数据类型的操作和算法。它主要利用的技术是模板。

            泛型编程的优点：

                    代码复用： 泛型编程使得代码能够被多次使用，不需要为每种数据类型单独编写相似的代码。

                    灵活性： 泛型编程可以适应不同类型的数据，使得代码更加灵活和通用。

                    类型安全： 使用模板的泛型编程可以在编译期间进行类型检查，提高代码的安全性和可靠性。

    正文 

    01-类模板简介           

            在C++中，类模板是 C++ 中的一种特性，它允许我们编写通用的类，以便能够在不同数据类型上工作，从而实现代码的复用性和灵活性。类模板的定义以关键字 template 开始，然后是模板参数列表，接着是类的定义。

            下面是一个简单的类模板示例，实现了一个泛型的栈（stack）数据结构：在这个示例中，template  声明了一个类模板，T 是一个占位符，代表任意类型。在类定义中，我们使用了类型 T 来定义存储元素的数组和栈的操作。这样，我们可以创建不同类型的栈，如 Stack 或 Stack，以便通过模板实例化实现不同类型的数据处理。

    1. template <class T>
    2. class Stack {
    3. private:
    4.     T data[100];
    5.     int top;
    6. public:
    7.     Stack() : top(-1) {}
    8.  
    9.     void push(const T& value) {
    10.         if (top < 99) {
    11.             data[++top] = value;
    12.         } else {
    13.             std::cout << "Stack is full!";
    14.         }
    15.     }
    16.  
    17.     T pop() {
    18.         if (top >= 0) {
    19.             return data[top--];
    20.         } else {
    21.             std::cout << "Stack is empty!";
    22.             return T(); // 返回 T 类型的默认值
    23.         }
    24.     }
    25.  
    26.     bool isEmpty() {
    27.         return top == -1;
    28.     }
    29. };

            下面是一个使用上述类模板的示例代码：在这个示例中，我们使用 Stack 实例化类模板，并将整型数据依次压入栈中，然后弹出并打印出栈内的元素。通过类模板，我们可以方便地实现通用的数据结构和算法，以适用于不同的数据类型。

    1. int main() {
    2.     Stack<int> intStack;
    3.     intStack.push(10);
    4.     intStack.push(20);
    5.     intStack.push(30);
    6.  
    7.     while (!intStack.isEmpty()) {
    8.         std::cout << intStack.pop() << " ";
    9.     }
    10.  
    11.     return 0;
    12. }

            下面给出具体代码分析应用过程：

            这段代码定义了一个类模板 Person，其中包含两个模板参数 NameType 和 AgeType，分别表示姓名和年龄的数据类型。在类模板内部，定义了一个构造函数和一个 show 方法，用于初始化成员变量并展示姓名和年龄信息。

            在 test01 函数中，我们实例化了一个 Person 类型的对象 p1，姓名为 “Tom”，年龄为 18，并调用其 show 方法展示信息。

            在 main 函数中，调用了 test01 函数来测试类模板的使用，并最后通过 system("pause") 暂停程序运行。

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. // 类模板
    6. template<class NameType,class AgeType>  // 这里NameType和AgeType就像T一样，定义了一个模板式的类型
    7. class Person
    8. {
    9. public:
    10. 	Person(NameType name, AgeType age)
    11. 	{
    12. 		this->m_Name = name;  // 这里写this是为方便寻找成员变量，不写也可
    13. 		this->m_Age = age;
    14.  
    15. 	}
    16. 	void show()
    17. 	{
    18. 		cout << "name=" << m_Name << "age = " << m_Age << endl;
    19. 	}
    20.  
    21.  
    22. 	NameType m_Name;
    23. 	AgeType  m_Age;
    24. };
    25.  
    26. void test01()
    27. {
    28. 	Personint>p1("Tom", 18);
    29. 	p1.show();
    30. }
    31.  
    32.  
    33. int main()
    34. {
    35. 	test01();
    36.  
    37.  
    38.  
    39. 	system("pause");
    40. 	return 0;
    41. }

            示例运行结果如下图所示：

    ​

    02-类模板和函数模板区别           

            类模板和函数模板是 C++ 中两种不同的模板形式，它们分别用于定义通用的类和函数。下面详细解释类模板和函数模板之间的区别：

             定义方式：类模板使用 template  或 template  的语法来定义模板类，其中 T 是类模板的占位符类型。函数模板使用 template  或 template  的语法来定义模板函数，其中 T 是函数模板的占位符类型。

             作用范围：类模板可以用于定义通用的类，其中类中的数据成员和成员函数可以使用模板参数。函数模板可以用于定义通用的函数，其中函数的参数类型和返回值类型可以使用模板参数。

             实例化：类模板在实例化时需要指定模板参数的具体类型，例如 Stack 或 Person。函数模板在调用时可以根据实参的类型推断出模板参数的具体类型，也可以显式指定类型，例如 func(value)。

             模板参数位置：类模板的模板参数可以出现在类的任意位置，用于定义类中的成员变量、成员函数等。函数模板的模板参数出现在函数名称之前，用于定义函数的参数类型和返回值类型。

             灵活性：类模板的灵活性更高，可以用于定义通用的数据结构和算法，实现更复杂的逻辑。函数模板通常用于定义通用的函数算法，更适合处理函数逻辑上的通用性需求。总体来说，类模板和函数模板都是 C++ 提供的用于实现通用编程的重要特性，通过模板编程，可以提高代码的复用性和灵活性，同时减少代码的重复编写。选择类模板还是函数模板取决于具体的需求和场景，它们分别适用于不同的抽象层次和代

    下面我们来分别实现一个类模板和一个函数模板，然后进行具体的代码分析：

    首先是类模板的代码示例：

    1. #include 
    2. using namespace std;
    3.  
    4. // 类模板
    5. template <class T>
    6. class Pair {
    7. private:
    8.     T first;
    9.     T second;
    10. public:
    11.     Pair(T f, T s) : first(f), second(s) {}
    12.  
    13.     void display() {
    14.         cout << "Pair: " << first << ", " << second << endl;
    15.     }
    16. };
    17.  
    18. int main() {
    19.     Pair<int> intPair(10, 20);
    20.     Pair strPair("Hello", "World");
    21.  
    22.     intPair.display();
    23.     strPair.display();
    24.  
    25.     return 0;
    26. }

    接下来是函数模板的代码示例：

    1. #include 
    2. using namespace std;
    3.  
    4. // 函数模板
    5. template <class T>
    6. T maximum(T a, T b) {
    7.     return (a > b) ? a : b;
    8. }
    9.  
    10. int main() {
    11.     int num1 = 10, num2 = 20;
    12.     double double1 = 3.14, double2 = 2.71;
    13.  
    14.     cout << "Maximum of integers: " << maximum(num1, num2) << endl;
    15.     cout << "Maximum of doubles: " << maximum(double1, double2) << endl;
    16.  
    17.     return 0;
    18. }

            在上面的代码中，我们定义了一个类模板 Pair 和一个函数模板 maximum。类模板 Pair 表示一对值，它包含两个模板参数，可以用不同类型的数据来实例化。函数模板 maximum 接受两个参数，并返回它们中较大的值。

            在 main 函数中，我们分别创建了两个类模板实例 intPair 和 strPair，以及通过函数模板调用找到了不同类型数据的最大值。

            通过这两个例子，我们可以看到类模板和函数模板的使用方式和特点。类模板适用于定义通用的类，而函数模板适用于定义通用的函数。它们都能通过模板参数实现对不同数据类型的操作，提高代码的复用性和灵活性。

            下面给出具体代码分析应用过程：

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. // 类模板和函数模板区别
    6. template<class NameType, class AgeType>  // 这里NameType和AgeType就像T一样，定义了一个模板式的类型
    7. class Person
    8. {
    9. public:
    10. 	Person(NameType name, AgeType age)
    11. 	{
    12. 		this->m_Name = name;  // 这里写this是为方便寻找成员变量，不写也可
    13. 		this->m_Age = age;
    14.  
    15. 	}
    16. 	void show()
    17. 	{
    18. 		cout << "name=" << m_Name << "age = " << m_Age << endl;
    19. 	}
    20.  
    21.  
    22. 	NameType m_Name;
    23. 	AgeType  m_Age;
    24. };
    25.  
    26. void test01()
    27. {
    28. 	Personint>p1("Tom", 18);
    29. 	p1.show();
    30. }
    31.  
    32. /*  1. 类模板没有自动类型推导的使用方式   必须要有显示数据类型Person
    33.     2. 类模板在模板参数列表中可以有默认参数
    34. */
    35.  
    36. int main()
    37. {
    38. 	test01();
    39.  
    40. 	system("pause");
    41. 	return 0;
    42. }

             示例运行结果如下图所示：

    03-类模板中成员函数创建时机           

            在类模板中，成员函数的创建时机是在类被实例化时。当我们实例化一个类模板的对象时，编译器会根据具体的模板参数类型生成对应的类定义及其成员函数的实现，这意味着每个具体类型的模板参数都会对应一个特定版本的类模板及其中的成员函数。

            下面我们通过一个简单的代码示例来说明类模板中成员函数的创建时机：

            在下面的代码中，我们定义了一个类模板 MyClass，包含一个模板参数 T 和成员函数 display，用于显示保存的数据。在 main 函数中，我们实例化了两个不同类型的 MyClass 对象：intObj 是整型类型，strObj 是字符串类型。

            当编译器遇到 MyClass 和 MyClass 两个具体的实例化时，会创建两个不同的类定义，并为每个实例化生成相应的成员函数实现。因此，成员函数的创建时机是在类模板被实例化时，根据具体的模板参数类型生成对应的函数定义。

            这种特性使得类模板可以根据不同类型的需求生成不同的类定义和成员函数实现，实现了通用性和灵活性。

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. // 类模板
    6. template <class T>
    7. class MyClass {
    8. public:
    9.     MyClass(T value) : data(value) {}
    10.  
    11.     void display() {
    12.         cout << "Value: " << data << endl;
    13.     }
    14.  
    15. private:
    16.     T data;
    17. };
    18.  
    19. int main() {
    20.     MyClass<int> intObj(10);
    21.     MyClass strObj("Hello");
    22.  
    23.     intObj.display();
    24.     strObj.display();
    25.  
    26.     return 0;
    27. }

     04-类模板对象做函数参数           

           类模板对象可以作为函数参数，通过这种方式可以实现对不同类型的类模板对象进行处理，从而提高代码的复用性和灵活性。当类模板对象作为函数参数传递时，需要指明模板参数类型，以确保编译器能够正确生成相应的函数实现。

    /*1. 指定传入的类型 --- 直接显示对象的数据类型
    2. 参数模板化 --- 将对象中的参数变为模板进行传递
    3. 整个类模板化 --- 将这个对象类型 模板化进行传递
    */

            下面是一个简单的代码示例，演示了如何在函数中接受类模板对象作为参数：

            在这段代码中，我们定义了一个类模板 Box，包含一个模板参数 T 和一个成员函数 getValue 返回存储的值。然后，我们定义了一个函数 displayValue，接受一个类型为 Box 的类模板对象作为参数，并在函数内部展示对象中的值。

            在 main 函数中，我们分别创建了两个不同类型的 Box 对象 intBox 和 strBox，然后将它们作为参数传递给 displayValue 函数进行展示。

            通过这种方式，我们可以实现对不同类型的类模板对象进行统一的处理，增强了代码的通用性和灵活性。

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. // 类模板
    6. template <class T>
    7. class Box {
    8. public:
    9.     Box(T val) : value(val) {}
    10.  
    11.     T getValue() {
    12.         return value;
    13.     }
    14.  
    15. private:
    16.     T value;
    17. };
    18.  
    19. // 函数接受类模板对象作为参数
    20. template <class T>
    21. void displayValue(Box box) {
    22.     cout << "Value in the box: " << box.getValue() << endl;
    23. }
    24.  
    25. int main() {
    26.     Box<int> intBox(10);
    27.     Box strBox("Hello");
    28.  
    29.     displayValue(intBox);
    30.     displayValue(strBox);
    31.  
    32.     return 0;
    33. }

    05-类模板与继承          

           类模板和继承在 C++ 中可以结合使用，以实现对模板的进一步扩展和特化。通过继承，可以在子类中继承父类模板的通用特性，并在此基础上进行一些特定的功能扩展或修改。

            以下是一个示例代码，演示了类模板与继承的结合应用：

            在下面的代码中，我们定义了一个类模板 Box，表示一个简单的箱子，包含一个存储值的成员。然后，我们定义了一个派生类 SpecialBox，通过继承自 Box，它包含了一个额外的特殊值 specialValue。在 displaySpecialValue 函数中，我们展示了特殊值的内容。

            在 main 函数中，我们分别实例化了 SpecialBox 和 SpecialBox 对象，并展示了其基类继承来的值，并调用了派生类的特有函数 displaySpecialValue。

            通过类模板和继承的结合使用，我们可以实现对模板类的进一步特化和定制，使代码更具灵活性和扩展性。

    1. #include 
    2. using namespace std;
    3.  
    4. // 类模板
    5. template <class T>
    6. class Box {
    7. public:
    8.     Box(T val) : value(val) {}
    9.  
    10.     T getValue() {
    11.         return value;
    12.     }
    13.  
    14. private:
    15.     T value;
    16. };
    17.  
    18. // 派生类继承自类模板
    19. template <class T>
    20. class SpecialBox : public Box {
    21. public:
    22.     SpecialBox(T val, T specialVal) : Box(val), specialValue(specialVal) {}
    23.  
    24.     void displaySpecialValue() {
    25.         cout << "Special Value in the Special Box: " << specialValue << endl;
    26.     }
    27.  
    28. private:
    29.     T specialValue;
    30. };
    31.  
    32. int main() {
    33.     SpecialBox<int> specialIntBox(10, 100);
    34.     SpecialBox specialStrBox("Hello", "Special");
    35.  
    36.     cout << "Value in the specialIntBox: " << specialIntBox.getValue() << endl;
    37.     specialIntBox.displaySpecialValue();
    38.  
    39.     cout << "Value in the specialStrBox: " << specialStrBox.getValue() << endl;
    40.     specialStrBox.displaySpecialValue();
    41.  
    42.     return 0;
    43. }

     06-类模板成员函数的类外实现       

           在 C++ 中，类模板的成员函数通常可以直接在类定义内部进行实现，也可以在类外部进行实现。如果希望将类模板的成员函数的定义从类模板的定义中分离出来，可以在类外部进行实现。

            下面是一个示例代码，演示了如何在类外部实现类模板的成员函数：

            在下面的代码中，我们定义了一个类模板 Calculator，包含两个模板参数，分别代表运算数字的类型。我们在类外部实现了 add 和 subtract 两个成员函数，分别用于加法和减法运算。

            在函数实现时，我们使用了类似 template  的语法来指定实现的是 class template Calculator 中的成员函数。这样可以将成员函数的定义与类模板的定义分开，提高代码的可读性和维护性。

            在 main 函数中，我们分别实例化了 Calculator 和 Calculator 对象，并调用了类模板的成员函数进行加法和减法运算。

            通过将类模板的成员函数的实现分离到类外部，我们可以更灵活地管理类模板的实现细节，并提高代码的可维护性。

    1. #include 
    2. using namespace std;
    3.  
    4. // 类模板的声明
    5. template <class T>
    6. class Calculator {
    7. public:
    8.     Calculator(T num1, T num2) : number1(num1), number2(num2) {}
    9.     
    10.     T add();
    11.     T subtract();
    12. };
    13.  
    14. // 类外部实现类模板的成员函数
    15. template <class T>
    16. T Calculator::add() {
    17.     return number1 + number2;
    18. }
    19.  
    20. template <class T>
    21. T Calculator::subtract() {
    22.     return number1 - number2;
    23. }
    24.  
    25. int main() {
    26.     Calculator<int> intCalc(10, 5);
    27.     Calculator<double> doubleCalc(3.5, 2.1);
    28.     
    29.     cout << "Adding: " << intCalc.add() << endl;
    30.     cout << "Subtracting: " << doubleCalc.subtract() << endl;
    31.     
    32.     return 0;
    33. }

            下面给出具体代码分析应用过程：这段代码展示了一个类模板 Person，其中包含一个构造函数和一个成员函数 show，并且这两个函数的实现被分别放在类的外部。

            在类模板 Person 中，模板参数分别为 T1 和 T2，用来表示 m_Name 和 m_Age 的数据类型。构造函数 Person(T1 name, T2 age) 接受一个名字和一个年龄作为参数，并将其赋值给类中的成员变量 m_Name 和 m_Age。而成员函数 show() 用于展示对象的名字和年龄。

            在类的外部，通过 Person::Person(T1 name, T2 age) 的方式实现了构造函数，将参数赋值给类的成员变量。同样，在类外部实现了成员函数 Person::show()，用来显示对象的名字和年龄。

            在 main 函数中，通过实例化 Person 创建了一个 Person 对象 p，传入名字 “Tom” 和年龄 18。然后调用 p.show() 函数展示 p 对象的名字和年龄。

            通过类模板和类外实现的结合，可以更好地实现代码的重用和维护，提高了代码的可读性和灵活性。

    1. #include
    2. using namespace std;
    3. #include
    4.  
    5. // 类模板的成员函数的类外实现
    6. template<class T1 ,class T2>
    7.  
    8. class Person
    9. {
    10. public:   // 这里必须对成员函数声明时必须给出权限设置，因为默认时私有的，外部无法访问
    11.  
    12. 	Person(T1 name, T2 age);
    13. // 	{
    14. // 		this->m_Name = name;
    15. // 		this->m_Age = age;
    16. // 
    17. // 	}
    18.  
    19. 	void show();
    20. // 	{
    21. // 		cout << "a" << m_Name << "b" << m_Age << endl;
    22. // 	}
    23. 	// 现在无论构造函数还是成员函数都是在类内实现，需要在类外实现
    24.  
    25. 	T1 m_Name;
    26. 	T2 m_Age;
    27. };
    28.  
    29. // 类外实现构造函数  这个以后编写代码都是在头文件和.cpp文件中，用处很大
    30. template<class T1,class T2>
    31. Person::Person(T1 name, T2 age)  // Person这句可以看作时类模板的成员函数的类外实现
    32. {
    33.  	{
    34. 		this->m_Name = name;
    35. 		this->m_Age = age;
    36.  
    37. 	}
    38. }
    39.  
    40. // 成员函数类外实现
    41. template<class T1, class T2>
    42. void Person::show()
    43. {
    44. 	cout << "a" << m_Name << "b" << m_Age << endl;
    45. }
    46.  
    47. void test01()
    48. {
    49. 	Personint>p("Tom", 18);
    50. 	p.show();
    51. }
    52.  
    53. int main() {
    54. 	test01();
    55.  
    56. 	system("pause");
    57. 	return 0;
    58. }

            示例运行结果如下图所示： 

    总结             

          类模板是 C++ 中一种强大的特性，允许我们编写通用的类，以便用不同的数据类型进行实例化。以下是类模板的总结要点：

            定义类模板：使用 template  或 template  来定义类模板，其中 T 是类型参数，可以在类的定义中使用该参数来表示不特定的数据类型。例如 template class MyTemplate { /* 类定义 */ };。

            实例化类模板：通过指定实际的数据类型，可以实例化类模板为具体的类，例如 MyTemplate obj1; MyTemplate obj2;。

            类模板成员函数：类模板可以包含成员函数，这些成员函数也可以是模板函数，可以在类的内部定义或外部定义。

            类模板特化：可以针对特定的数据类型制定特殊的实现，从而实现类模板的特化。例如 template <> class MyTemplate { /* 特化实现 */ };。

            多个模板参数：类模板可以有多个模板参数，例如 template class Pair { /* 类定义 */ };。

            模板模板参数：模板还可以作为另一个模板的参数，称为模板模板参数，在实现更复杂的类模板时非常有用。

            使用限制：类模板不能将成员变量直接声明为 static，每个类模板的实例化都是独立的，具有相同的成员函数但独立的成员变量。

            通过使用类模板，我们可以编写出更加通用、灵活和可重用的类，以更好地适应不同数据类型的需求。

  • 相关阅读:
    2002NOIP普及组真题 4. 过河卒
    嵌入式笔试面试刷题(day11)
    Spring Kafka生产者实现
    Git的下载与安装
    spring 面试题总结
    CANoe-什么是Vector Tool Platform（全网唯一讲明白的文章）
    TDengine+OpenVINO+AIxBoard，助力时序数据分类
    Python3 异步编程简介
    2021祥云杯PassWordBox_ProVersion
    ES6语法新特性(下)
  • 原文地址：https://blog.csdn.net/m0_59951855/article/details/139127547