• C/C++模板类模板与函数模板区别,以及用法详解


    类模板

    类模板语法

    类模板作用:

    • 建立一个通用类,类中的成员 数据类型可以不具体制定,用一个虚拟的类型来代表。

    语法:

    1. template<typename T>

    解释:

    template --- 声明创建模板

    typename --- 表面其后面的符号是一种数据类型,可以用class代替

    T --- 通用的数据类型,名称可以替换,通常为大写字母

    示例:

    1. #include <string>
    2. //类模板
    3. template<class NameType, class AgeType>
    4. class Person
    5. {
    6. public:
    7. Person(NameType name, AgeType age)
    8. {
    9. this->mName = name;
    10. this->mAge = age;
    11. }
    12. void showPerson()
    13. {
    14. cout << "name: " << this->mName << " age: " << this->mAge << endl;
    15. }
    16. public:
    17. NameType mName;
    18. AgeType mAge;
    19. };
    20. void test01()
    21. {
    22. // 指定NameType 为string类型,AgeType 为 int类型
    23. Person<string, int>P1("孙悟空", 999);
    24. P1.showPerson();
    25. }
    26. int main() {
    27. test01();
    28. system("pause");
    29. return 0;
    30. }

    总结:类模板和函数模板语法相似,在声明模板template后面加类,此类称为类模板

    类模板与函数模板区别

    类模板与函数模板区别主要有两点:

    1. 类模板没有自动类型推导的使用方式
    2. 类模板在模板参数列表中可以有默认参数(只有类模板可以)

    示例:

    1、类模板没有自动类型推导的使用方式

    1. #include <string>
    2. //类模板
    3. template<class NameType, class AgeType>
    4. class Person
    5. {
    6. public:
    7. Person(NameType name, AgeType age)
    8. {
    9. this->mName = name;
    10. this->mAge = age;
    11. }
    12. void showPerson()
    13. {
    14. cout << "name: " << this->mName << " age: " << this->mAge << endl;
    15. }
    16. public:
    17. NameType mName;
    18. AgeType mAge;
    19. };
    20. //1、类模板没有自动类型推导的使用方式
    21. void test01()
    22. {
    23. // Person p("孙悟空", 1000); // 错误 类模板使用时候,不可以用自动类型推导
    24. Person <string ,int>p("孙悟空", 1000); //必须使用显示指定类型的方式,使用类模板
    25. p.showPerson();
    26. }
    27. int main() {
    28. test01();
    29. system("pause");
    30. return 0;
    31. }

    2、类模板在模板参数列表中可以有默认参数

    1. #include <string>
    2. //类模板
    3. template<class NameType, class AgeType = int> //类模板在模板参数列表中可以有默认参数
    4. class Person
    5. {
    6. public:
    7. Person(NameType name, AgeType age)
    8. {
    9. this->mName = name;
    10. this->mAge = age;
    11. }
    12. void showPerson()
    13. {
    14. cout << "name: " << this->mName << " age: " << this->mAge << endl;
    15. }
    16. public:
    17. NameType mName;
    18. AgeType mAge;
    19. };
    20. //2、类模板在模板参数列表中可以有默认参数
    21. void test02()
    22. {
    23. Person <string> p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数
    24. p.showPerson();
    25. }
    26. int main() {
    27. test02();
    28. system("pause");
    29. return 0;
    30. }

    总结:

    • 类模板使用只能用显示指定类型方式
    • 类模板中的模板参数列表可以有默认参数

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

    类模板中成员函数和普通类中成员函数创建时机是有区别的:

    • 普通类中的成员函数一开始就可以创建
    • 类模板中的成员函数在调用时才创建(ps:这一特性在类模板分文件编写时会产生问题)

    示例:

    1. class Person1
    2. {
    3. public:
    4. void showPerson1()
    5. {
    6. cout << "Person1 show" << endl;
    7. }
    8. };
    9. class Person2
    10. {
    11. public:
    12. void showPerson2()
    13. {
    14. cout << "Person2 show" << endl;
    15. }
    16. };
    17. template<class T>
    18. class MyClass
    19. {
    20. public:
    21. T obj;
    22. //下面两个成员函数可以编译成功,因为类模板中的成员函数,并不是一开始就创建的,而是在模板调用时再生成,不会报错。
    23. void fun1()
    24. {
    25. obj.showPerson1();
    26. }
    27. void fun2()
    28. {
    29. obj.showPerson2();
    30. }
    31. };
    32. void test01()
    33. {
    34. MyClass<Person1> m;//可以编译成功,但是下面只能调用fun1(),调用fun2()报错
    35. m.fun1();
    36. //m.fun2();//编译会出错,说明函数调用才会去创建成员函数
    37. }
    38. int main() {
    39. test01();
    40. system("pause");
    41. return 0;
    42. }

    总结:类模板中的成员函数并不是一开始就创建的,因为无法确定数据类型,在调用时才去创建

    类模板对象做函数参数

    学习目标:

    • 类模板实例化出的对象,向函数传参的方式

    一共有三种传入方式:

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

    示例:

    1. #include <string>
    2. //类模板
    3. template<class NameType, class AgeType = int>
    4. class Person
    5. {
    6. public:
    7. Person(NameType name, AgeType age)
    8. {
    9. this->mName = name;
    10. this->mAge = age;
    11. }
    12. void showPerson()
    13. {
    14. cout << "name: " << this->mName << " age: " << this->mAge << endl;
    15. }
    16. public:
    17. NameType mName;
    18. AgeType mAge;
    19. };
    20. //1、指定传入的类型
    21. void printPerson1(Person<string, int> &p)
    22. {
    23. p.showPerson();
    24. }
    25. void test01()
    26. {
    27. Person <string, int >p("孙悟空", 100);
    28. printPerson1(p);
    29. }
    30. //2、参数模板化
    31. template <class T1, class T2>
    32. void printPerson2(Person<T1, T2>&p)
    33. {
    34. p.showPerson();
    35. cout << "T1的类型为: " << typeid(T1).name() << endl;//查看该变量的数据类型
    36. cout << "T2的类型为: " << typeid(T2).name() << endl;
    37. }
    38. void test02()
    39. {
    40. Person <string, int >p("猪八戒", 90);
    41. printPerson2(p);
    42. }
    43. //3、整个类模板化
    44. template<class T>
    45. void printPerson3(T & p)
    46. {
    47. cout << "T的类型为: " << typeid(T).name() << endl;
    48. p.showPerson();
    49. }
    50. void test03()
    51. {
    52. Person <string, int >p("唐僧", 30);
    53. printPerson3(p);
    54. }
    55. int main() {
    56. test01();
    57. test02();
    58. test03();
    59. system("pause");
    60. return 0;
    61. }

    总结:

    • 通过类模板创建的对象,可以有三种方式向函数中进行传参
    • 使用比较广泛是第一种:指定传入的类型

    PS:查看数据类型函数typeip().name()

    注意string类型返回值很长!

    应用:

    结合实际操作来看,第一种很常用,因为在传入之后只需要进行操作就行,不需要再考虑判定其是字符还是数字的问题。

    第二种是保证其在一个类别中的万能性,比如你想对任意数据类型的数组作交换,但只想写一种函数,就可以用,但相对的会费脑子,在日常打代码一个复制粘贴改改就能写,但需要想的很远,等同于你象棋开局走一步就能达到到将死对面的所有情况你都要想,而且维护方面也是个问题,因此更常用的是第一种,以上还仅是在函数模板的基础上得到的结论,更别说在类模板的函数传入了。

    第二种是将函数变为函数模板,目的是为了使用函数模板的自动类型指导。

    第三种是直接将整个类模板作为一个类,2是将类模板里的类作为函数模板的类,2.3根本目的还是使用函数模板的自动类型推导。

  • 相关阅读:
    Golang sync.Pool
    汽车电子专栏目录一览
    图像处理那些算法
    【Python】Lambda表达式
    为什么需要在微服务中使用链路追踪?Spring Cloud 可以选择哪些微服务链路追踪方案?
    Linux:进程的状态理解
    使用docker搭建squoosh
    【PTHREAD】线程退出与取消
    [附源码]JAVA毕业设计考研驿站网站(系统+LW)
    可视化学习:WebGL实现缩放平移
  • 原文地址:https://blog.csdn.net/m0_69824302/article/details/134430304