• C++ 语言学习 day07 函数异常，模板，模板类

    1.1.函数的异常声明：
           在函数申明的时候，确定抛出异常的类型，增加代码的可读性，并且确定好丢的异常后，更好的捕获异常
           格式 ： 返回值  函数名(参数列表) throw(类型1，类型2，类型3 ){ }
          注意：如果不希望函数丢异常，则throw后直接加小括号

    代码：

    1. #include 
    2. using namespace std;
    3. void fun(int x)throw(int ,char)//可以抛出的异常单位
    4. {
    5.     if(x == 0)
    6.     {
    7.        // throw 1.3; 不行
    8.         throw 'a';
    9.  
    10.     }
    11. }
    12. void show()throw()
    13. {
    14.     throw 1;
    15. }
    16.  
    17. int main(int argc, char *argv[])
    18. {
    19.     try{
    20.         fun(0);
    21.         //show();
    22.     }
    23.     catch(char a)
    24.     {
    25.         cout << "我是int的异常 "<
    26.     }
    27.  
    28.     return 0;
    29. }


    2.自定义异常类
         定义一个类，可以用于throw中。
         （补充笔记）

    代码：

    1. #include <iostream>
    2. #include <cstring>
    3. #include <exception>
    4. using namespace std;
    5. class errorEx
    6. {
    7.  
    8.     int errId=0;
    9.     const char* errStr[4]={"","第一种错误","第二种错误","第三种错误"};
    10. public:
    11.     errorEx(int id = 0)
    12.     {
    13.         this->errId = id;
    14.         cout << "我是构造函数 id="<< this->errId <<endl;
    15.     }
    16.  
    17.     ~errorEx()
    18.     {
    19.         cout << "我是析构函数"<<endl;
    20.     }
    21.     errorEx  show()throw(errorEx);
    22.     string what()
    23.     {
    24.         if(errId == 1)
    25.         {
    26.             return errStr[1];
    27.         }
    28.         else if(errId == 2)
    29.         {
    30.             return errStr[2];
    31.         }
    32.         if(errId == 3)
    33.         {
    34.             return errStr[3];
    35.         }
    36.     }
    37.  
    38. };
    39. errorEx errorEx::show()throw(errorEx)
    40. {
    41.     if(this->errId != 0)
    42.     {
    43.         throw *this;
    44.     }
    45. }
    46.  
    47. class myexception:public exception
    48. {
    49. public:
    50.     myexception(){
    51.         cout << "我是构造"<<endl;
    52.     }
    53.     virtual const char* what() const throw()
    54.     {
    55.         return "我是myexception的异常";
    56.     }
    57.  
    58. };
    59. void fun()
    60. {
    61.     myexception er;
    62.     throw er;
    63. }
    64.  
    65. int main(int argc, char *argv[])
    66. {
    67.    try
    68.     {
    69.       // errorEx err(1);
    70.      //  err.show();
    71.        fun();
    72.     }
    73.     catch(errorEx& e)
    74.     {
    75.         cout << "catch"<<endl;
    76.         cout << e.what()<<endl;
    77.     }
    78.     catch(myexception& er)
    79.     {
    80.         try{
    81.         cout << er.what()<<endl;
    82.         }
    83.         catch(...)
    84.         {
    85.             cout << "..."<<endl;
    86.         }
    87.     }
    88.  
    89.     return 0;
    90. }
    91.  
    92.

    3.标准异常
         从标准的exception类继承的子类，处理异常。
          exception中定义好的异常
          std::bad_alloc     通过new抛出，
          std::domain_error  使用了无效的数字域
          std::length_error  当创建了一个太长的string会抛异常。
          std::overflow_error 数据类型上溢出
          std::underflow_error 数据类型下溢出
         定义标注异常
         class 异常类：public exception{}
         注意：一般情况下需要重写what方法。
          异常嵌套：在异常中 继续try和catch是可以的
    try
        {
           errorEx err(1);
           err.show();
        }
        catch(errorEx& e)
        {
            cout << "catch"<         cout << e.what()<     }
        catch(myexception& er)
        {
            try{
            cout << er.what()<         }
            catch(...)        {        }

    二、模板：
        1.泛型编程：用一个标志来表示类型，不是实际的类型。独立于任何特定类型的编程，c++的一个部分。
        PPT模板---他是一个框架，需要填写内容--方便开发，提高了复用度。
       2.函数模板：
       格式：template
                 返回值 函数名(参数){  }
       3.解释：
              template  ----- 声明创建模板
              typename ----- （也可以用class代替）表明后的类型是一个通用类型，或许叫做虚拟类型
              T1-------------- 通用类型或者虚拟类型，（理解成类型）可以在函数中直接当做普通类型使用。
       4. 函数模板的调用：
         3. 第一种：  函数名 <实际类型1，实际类型2>（参数列表）；
                        显式类型推导   fun(1,2);
          第二种： 函数名（参数）；
                        隐形类型推导 
        5.注意：显示类型推导 参数和推导的类型必须一致。
                  如果有普通函数和模板函数，在调用时可以用显示调用，省略类型的方式  swap<>(1,2)
        

    代码：

    1. #include <iostream>
    2.  
    3. using namespace std;
    4. //T代替一个类型，是一个类型的代词比如T代替int
    5. template <typename T1,typename T2>
    6. T2 add(T1 a,T2 b)
    7. {
    8.    return a+b;
    9. }
    10.  
    11. template<class T>
    12. void swap(T x,T y)
    13. {
    14.     T temp = x;
    15.     x = y;
    16.     y = temp;
    17.     cout <<"x1 = "<< x << "y1 = "<< y<<endl;
    18. }
    19.  
    20. void swap(int x,int y)
    21. {
    22.     int temp = x;
    23.     x = y;
    24.     y = temp;
    25.     cout <<"x = "<< x << "y = "<< y<<endl;
    26. }
    27.  
    28. int main(int argc, char *argv[])
    29. {
    30.     cout <<add('c',2.2)<<endl;
    31.  
    32.     swap<>(10,20);
    33.     cout << "Hello World!" << endl;
    34.     return 0;
    35. }
    36.  
    37. //写一个swap交换两个变量的函数，用函数模板实现，然后写一个swap的普通函数。
    38. // 在main中显示类型推导和隐式类型推导分别调用


       6.普通函数和函数模板的区别：
        函数只可以有一种数据类型相匹配。模板有多种类型
        隐式推导优先使用普通函数，只有普通函数不匹配才使用函数模板
        函数模板只有在调用时，才会构建函数，而普通函数是在编译时。
        普通函数调用时候可以发生自动类型转换，而函数模板不行。  


        
       7.函数模板重载
        和普通函数的重载相似。也是同一个作用域类函数名相同参数列表不同。
         以下是参数顺序不同的重载
         template void swap1(T2 a,T1 b)
          template void swap1(T1 a,T2 b)
         注意，在函数参数顺序不同的重载中，实例化的时候不可以是相同类型
         例如  swap1(1,2)则没法匹配哪个函数。
         以下是参数个数不同的重载
             template   void swap1(T1 a,T2 b)
             template  void swap1(T2 t)
             传入不同的参数，调用不同的版本
          练习：写比较 大小函数模板，传入2 3 4数值都可以比较都可以返回最大值

    代码：

    1.  
    2. #ifndef 0
    3. #include <iostream>
    4. using namespace std;
    5.  
    6.  
    7. template<typename T1>
    8. void pp(T1  a)
    9. {
    10.     cout<<"T0 = "<<a<<endl;
    11. }
    12. void pp(int a)//和上面的函数组成 隐式类型推导
    13. {
    14.  cout<<"pp ="<<a<<endl;
    15. }
    16.  
    17.  
    18. /* //重载的swap1
    19. template <class T1,class T2>
    20. void swap1(T1 a,T2 b)
    21. {
    22.     cout<<"1"<<endl;
    23. }
    24.  
    25. template<class T1,class T2>
    26. void swap1(T2 a,T1 b)
    27. {
    28.     cout<<"2"<<endl;
    29. }
    30.  
    31. template <typename T2>
    32. void swap1(T2 t)
    33. {
    34.     cout<<"3"<<endl;
    35. }
    36.  
    37. */
    38.  
    39. //写入一个可以比较数值大小的函数，传入的参数不限
    40. template <typename T1>
    41. T1 daxiao(T1 a,T1 b)
    42. {
    43.     if(a>b)
    44.     {
    45.         return a;
    46.     }
    47.     else
    48.     {
    49.         return b;
    50.     }
    51. }
    52.  
    53. template <typename T1>
    54. T1 daxiao(T1 a,T1 b,T1 c)
    55. {
    56.     if(a>b && a>c)
    57.     {
    58.         return  a;
    59.     }
    60.     if(b>a && b>c)
    61.     {
    62.         return  b;
    63.     }
    64.     if(c>b && c>a)
    65.     {
    66.         return  c;
    67.     }
    68.  
    69. }
    70.  
    71. template <typename T1>
    72. T1 daxiao(T1 a,T1 b,T1 c,T1 d)
    73. {
    74.     if(a>b && a>c && a>d)
    75.     {
    76.         return  a;
    77.     }
    78.     if(b>a && b>c && b>d)
    79.     {
    80.         return  b;
    81.     }
    82.     if(c>b && c>a  && c>d)
    83.     {
    84.         return  c;
    85.     }
    86.     if(d>a && d>b  && d>c)
    87.     {
    88.         return  d;
    89.     }
    90. }
    91.  
    92.  
    93.  
    94. int main(int argc, char *argv[])
    95. {
    96.     /*
    97.     pp(1);//隐式类型推导测试
    98.     pp('a');
    99.     */
    100.     /*重载函数的测试
    101.     swap1<int,double>(10,10.0);
    102.     swap1<int,double>(10.0,10);//<int->T1 double->T2>//类型匹配
    103.     swap1<int>(1);
    104.     */
    106.     /*
    107.     int a1=daxiao<int>(1,2);
    108.     int a2=daxiao<int>(2,3,1);
    109.     char a3=daxiao<char>('a','k','p','l');
    110.     cout<<"a1= "<<a1<<endl;
    111.     cout<<"a2= "<<a2<<endl;
    112.     cout<<"a3= "<<a3<<endl;
    113.     return 0;
    114.     */
    116.     return 0;
    117. }
    118. #endif


         
    8.函数模板特化
       定义：为了解决函数模板的局限性，在定义函数模板时候，直接确定好T的类型。也就是特定的类型模板。
        格式： template 返回值  函数名(类名& 对象){ }
        匹配：如果传入的是自定义类型，并且和特化版本匹配，会优先使用特化版本
        注意：如果特化后，类型确定才可以使用自定义类型中的成员变量和方法。

    代码：

    1. #include <iostream>
    2. #include <string>
    3. using namespace std;
    4. class person
    5. {
    6. public:
    7.     int age = 0;
    8.     string name;
    9. public:
    10.     person(int age,string name):age(age),name(name) {
    11.  
    12.     }
    13. };
    14.  
    15. template <class T>
    16. bool cmp(T a,T b)
    17. {
    18.     if(a == b)
    19.     {
    20.         return true;
    21.     }
    22.     return false;
    23. }
    24.  
    25.  
    26. //函数模板特化
    27. template<class T>
    28. bool cmp(person& a,person& b)
    29. {
    30.     if(cmp<int>(a.age,b.age) && cmp<string>(a.name,b.name))
    31.     {
    32.         return true;
    33.     }
    34.     return false;
    35. }
    36.  
    37.  
    38. void fun1()
    39. {
    40.     int a = 10;
    41.     int b = 12;
    42.     cout << cmp(a,b)<<endl;
    43.  
    44. }
    45. void fun2()
    46. {
    47.     person a(10,"danny");
    48.     person b(20,"wang");
    49.     cmp<person>(a,b);
    50.  
    51. }
    52.  
    53. int main(int argc, char *argv[])
    54. {
    55.   fun2();
    56.     return 0;
    57. }

    9.多文件实现函数模板
         在定义函数或者类的时候，会.h和cpp文件，定义和申明分开。
         出现连接错误的原因：函数模板是在调用时确定的版本，而调用时.h中没有函数实现，出现连接错误，找不到函数体。
         如果分开后，编译会出现连接错误。
         第一种办法：在main中#include  和 #include
         第二种办法：模板的定义和申明都放在.h头文件中。
     10. 函数模板的嵌套
         定义：在函数模板中调用另外一个函数模板
         练习：写两个Mymax函数模板重载，三个参数中调用两个参数的版本比较
        
    11.函数模板的非类型参数
         希望传入函数一个特定的确定参数，但不希望放在小括号中。
         可以通过非类型参数实现。在模板<>中加了一个参数，但这个参数不是类型参数，是具体的某一个值。
         格式：template
                   返回值 函数名(T& 变量)
          例如：template
                     void showArr(T* arr);
          注意：在上例子中，size是通过模板传入到函数中，可以当做普通变量使用
                    非类型参数都是常量，在函数中不允许修改，只可以使用，定义非类型参数变量时候，需要加const。   

    代码：

    1. #include <iostream>
    2.  
    3. using namespace std;
    4. template<typename T>
    5. T mymax(T a,T b)
    6. {
    7.     if(a>b)
    8.     {
    9.         return a;
    10.     }
    11.     return b;
    12. }
    13. //函数模板嵌套使用
    14. template<typename T>
    15. T max1(T a,T b,int c)
    16. {
    17.     //return  mymax<T>(mymax(a,b),c);
    18. }
    19.  
    20. //函数模板的非类型参数
    21. template<class T,int size>
    22. void showArr(T* arr)
    23. {
    24.     for(int i = 0;i <size;i++)
    25.     {
    26.         cout << arr[i]<<" ";
    27.     }
    28.     cout <<endl;
    29. }
    30.  
    31.  
    32. int main(int argc, char *argv[])
    33. {
    34.     cout <<max1(1,2,3)<<endl;
    35.     int arr[10]= {1,2,3,4,5,6,7,8,9,0};
    36.     const int arrSize = sizeof(arr)/sizeof(arr[0]);
    37.     showArr<int,arrSize>(arr);
    38.  
    39.  
    40.  
    41.     return 0;
    42. }

    模板的缺省类型参数。

    代码：

    1. #include <iostream>
    2.  
    3. using namespace std;
    4. //模板的缺省类型参数。
    5. template<class T1=int,class T2=string>
    6. class person
    7. {
    8.     T1 age;
    9.     T2  name;
    10. public:
    11.     person(T1 age,T2 name):age(age),name(name){}
    12.     void show()
    13.     {
    14.         cout << "name= "<<name<<endl;
    15.         cout << "age = "<<age <<endl;
    16.     }
    17. };
    18.  
    19.  
    20. int main(int argc, char *argv[])
    21. {
    22.     //实例化对象
    23.     person<int ,string> danny(10,"danny");
    24.     danny.show();
    25.     person<> wang(3,"wang");
    26.     wang.show();
    27.     cout << "Hello World!" << endl;
    28.     return 0;
    29. }

    12.类模板
         建立一个通用的类，如果希望成员变量的类型是任意的，用类模板实现。
         类模板不是一个实际的类型，是虚拟的，和ppt模板一样，实例化的时候才会构建类。
         格式：template
                   class test { T age; };
          实例化： 类名<类型> 变量名（参数）；
         类模板和函数模板区别
          函数模板可以使用隐式类型推导，但类模板不可以，必须显示推导
          类模板在定义template时候，可以加上默认参数。template
          在模板中的默认参数类型中，如果所有模板参数都是缺省，但在类进行实例化的时候，尖括号不可以省略template
    class person{}；     person<> wang(3,"wang");

    代码：

    1. #include <iostream>
    2.  
    3. using namespace std;
    4. class person1
    5. {
    6. public:
    7.     void show1()
    8.     {
    9.         cout <<"我是person1"<<endl;
    10.     }
    11. };
    12.  
    13. class person2
    14. {
    15.     void show2()
    16.     {
    17.         cout <<"我是person2"<<endl;
    18.     }
    19. };
    20.  
    21. template <class T>
    22. class usePerson
    23. {
    24. public:
    25.     T per;
    26.     //类模板中的成员函数，不是一开始就创建了，类模板调用时候创建
    27.     void fun1()
    28.     {
    29.         per.show1();
    30.     }
    31.     void fun2()
    32.     {
    33.         per.show2();
    34.     }
    35.  
    36. };
    37.  
    38. void myfun()
    39. {
    40.     usePerson<person1> danny;
    41.     danny.fun1();  //不出错
    42.     //danny.fun2(); //出错
    43. }
    44.  
    45. int main(int argc, char *argv[])
    46. {
    47.     cout << "Hello World!" << endl;
    48.     myfun();
    49.     return 0;
    50. }


     

    作业：做一个函数模板，用选择排序对不同数据类型进行排序（降序的方式）
     可以传入多个参数，并且也支持非类型参数的版本。

    1. #include <iostream>
    2. using namespace std;
    3. template <typename T>
    4. void swap1(T* a,T* b)//万能的交换函数
    5. {
    6.     T temp = *a;
    7.     *a=*b;
    8.     *b=temp;
    9. }
    10.  
    11. template<typename T,int size>
    12. T sort(T num)//模板传递数组的长度
    13. {
    14.     for(int i=0;i<size;i++)
    15.     {
    16.         for(int j=i+1;j<size ;j++)
    17.         {
    18.             if(num[i]<num[j])
    19.             {
    20.                 swap1(&num[i],&num[j]);
    21.             }
    22.         }
    23.     }
    24.     return num;
    25. }
    26.  
    27. template<typename T>
    28. T sort(T num,int size)//函数传递数组的长度
    29. {
    30.     for(int i=0;i<size;i++)
    31.     {
    32.         for(int j=i+1;j<size ;j++)
    33.         {
    34.             if(num[i]<num[j])
    35.             {
    36.                 swap1(&num[i],&num[j]);
    37.             }
    38.         }
    39.     }
    40.     return num;
    41. }
    42.  
    43.  
    44. int main()
    45. {
    46.     /*
    47.     int a=1;//整形的交换
    48.     int b=2;
    49.     swap1(&a,&b);
    50.     cout<<"a = "<<a<<endl<<"b = "<<b<<endl;
    51.  
    52.  
    53.     char a='a';//字符型的交换
    54.     char b='b';
    55.     swap1(&a,&b);
    56.     cout<<"a = "<<a<<endl<<"b = "<<b<<endl;
    57.  
    58.     double a=1.0;//浮点型的交换
    59.     double b=2.0;
    60.     swap1(&a,&b);
    61.     cout<<"a = "<<a<<endl<<"b = "<<b<<endl;
    62.  
    63.     string a("1111");//字符串类型的交换
    64.     string b("2222");
    65.     swap1(&a,&b);
    66.     cout<<"a = "<<a<<endl<<"b = "<<b<<endl;
    67.     */
    68.     int num[]={1,5,3,9,6,45,23,96,14,100};
    69.     const int size =sizeof(num)/sizeof(num[0]);
    70.     int *num1=sort<int* ,size>(num);
    71.     int *num2=sort(num,size);
    72.     cout<<"num1 = ";
    73.     for(int i=0;i<size;i++)
    74.     {
    75.         cout<<num1[i]<<"  ";
    76.     }
    77.     cout<<endl;
    78.     cout<<"num2 = ";
    79.     for(int i=0;i<size;i++)
    80.     {
    81.         cout<<num2[i]<<"  ";
    82.     }
    83.  
    84.  
    85.  
    86.     return 0;
    87. }

  • 相关阅读:
    Java 下载excel文件
    文心一言 vs GPT-4 —— 全面横向比较
    昂首资本通过套期保值，MT4和MT5这样选
    6种方法轻松将PDF转换为Word文档，办公必备！
    Linux基础准备工作（环境的搭建）
    【Unity】安卓加密编译libmono.so失败记录（做个记录呗）
    LeetCode每日一练 —— 160. 相交链表
    【数据结构(三)】单向环形链表和约瑟夫问题（3）
    Springboot基于web的游泳馆信息管理系统 毕业设计-附源码281444
    Greenplum数据库外部协议——GPHDFS实现协议
  • 原文地址：https://blog.csdn.net/she666666/article/details/126715003