C++学习七：异常处理、转换函数、智能指针

最新推荐文章于 2024-07-10 22:49:54 发布
最新推荐文章于 2024-07-10 22:49:54 发布
阅读量969 收藏 21
点赞数 25
文章标签： c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/only_write_bug/article/details/135197691
版权

一.异常处理

1.核心思想

    让函数的设计者去检查错误，检查到错误时抛出异常，而函数的使用者捕获异常并处理异常

2.C++的异常处理机制有3部分组成：

    try(检查错误) -> throw(抛出异常) -> catch(捕获异常)

3.异常语法形式

    try{

        //检查错误

        if(错误)

            throw 异常

    }catch(异常1)

    {

        处理异常

    }catch(异常2)

    {

        处理异常

    }

    eg:       

 int divior(int x, int y)
        {
            if(y != 0)
                return x/y;                        //正确：返回结果
            else                                            //y == 0
                throw invalid_argument("invalid argument");//抛出异常
        }
        int main()
        {

            int m = 1;
            int n = 0;
            try{                                //检错
                cout << divior(m,n) << endl;
            }
            catch(const invalid_argument &iserr)//捕获异常
            {  
                cout << iserr.what() << endl;//打印异常原因 处理异常
            }  
            return 0;
        }

4.自定义异常

    eg1:由标准异常类派生       

class myexception : public exception{
        public:
            myexception(const char *str) noexcept : ptr(str)  //指定异常不再抛异常
            {
           
            }
            ~myexception() noexcept //自动为序虚
            {
            }
            const char* what() const noexcept //重写基类的虚函数
            {
                return ptr;
            }
        private:
            const char *ptr；
        };
        int divior(int x, int y)
        {
            if(y != 0)
                return x/y;//正确：返回结果
            else if(0 == x)
                throw myexception("x == 0");//抛出自定义异常
            else//y == 0
                throw invalid_argument("invalid argument");//抛出标准异常
        }
        int main()
        {
            int m = 0;
            int n = 1;
            try
            {                //检错
                cout << divior(m,n) << endl;
            }
            catch(const invalid_argument &iserr)//捕获异常
            {  
                cout << iserr.what() << endl;//打印异常原因 处理异常
            }
            catch(const myexception &iserr)//捕获异常
            {  
                cout << iserr.what() << endl;//打印异常原因 处理异常
            }      
            return 0;

        }

       

    eg2:不由标准异常类派生，自定义异常类     

  class myexception{
        public:
            myexception(const char *str) noexcept: ptr(str)  //指定异常不再抛异常
            {
            }
            virtual ~myexception() noexcept //自动为序虚
            {
            }
            virtual const char* what() const noexcept //重写基类的虚函数
            {
                return this->ptr;
            }
        private:
            const char *ptr;
        };
        int divior(int x, int y)
        throw(invalid_argument)//指定函数可以抛出invalid_argument类型的异常
        {
            if(y != 0)
                return x/y;//正确：返回结果
            else if(0 == x)
            {
            #if 0
                throw myexception("x == 0");//抛出自定义异常
            #else
                myexception tmp("x == 0");
                throw tmp;
            #endif
            }
            else//y == 0
                throw invalid_argument("invalid argument");//抛出标准异常
        }
        int main()
        {
            int m = 0;
            int n = 1;
            try
            {//检错
                cout << divior(m,n) << endl;
            }
            catch(const invalid_argument &iserr)//捕获异常
            {  
                cout << iserr.what() << endl;//打印异常原因 处理异常
            }
            catch(const myexception &iserr)//捕获异常
            {  
                cout << iserr.what() << endl;//打印异常原因 处理异常
            }      
            return 0;
        }

二.转换函数

1.目的

    实现基本类型和自定义类型之间的转换；

2.语法形式

    operator 新类型() const

    {

        //转换语句

    }

    eg:

        operator int() const //自定义类型转int

        {

        }

    注意：

        转换函数只能是成员函数，无返回值，空参数。

        不能定义到void的转换，也不允许转换成数组或者函数类型。

        转换常定义为const形式，原因是它并不改变数据成员的值。

3.explicit关键字

    阻止隐式类型转换；

    eg:       

class Demo{
        public:
            explicit Demo(int val) //explict:阻止隐式类型转换
            {
                this->val = val;
                cout << __func__ << ":" << __LINE__ << endl;
            }
            virtual ~Demo()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
        public:
            void setval(int val)
            {
                this->val = val;
            }
            int getval() const
            {
               return this->val;
            }
        private:
            int val;
    };
    int main()
    {
        Demo obj(666);
        obj = 123;//Demo tmp(123); obj = tmp;   隐式类型转换: int -> Demo
        cout << obj.getval() << endl;
        return 0;
    }

4.C++标准转换函数

    编译时转换：reinterpret_cast、const_cast、static_cast

    运行时候转换：dynamic_cast

   

    1)reinterpret_cast

        语法:reinterpret_cast<new type>（expression）

        功能:将一个类型的指针转换为另一个类型的指针，它也允许从一个指针转换为整数类型

        eg:

            char *p;

            int *q;

            q = reinterpret_cast<int *> (p);//char * -> int *

    2)const_cast

        语法:const_cast<  new type>( expression)

        功能：const指针与普通指针间的相互转换，注意：不能将非常量指针变量转换为普通变量

        eg:

            const int *p;

            int *q;

            q = const_cast<int *>(p);//const int * -> int *

           

    3)static_cast(普通类类型转换)

        语法:static_cast<new type>(expression)

        功能:主要用于基本类型间的相互转换，和具有继承关系间的类型转换

        eg:           

class Base{
            public:
                Base()
                {
                    cout << __func__ << ":" << __LINE__  << endl;
                }
                ~Base()
                {
                    cout << __func__ << ":" << __LINE__  << endl;
                }
        };

        class Inherit : public Base{
            public:
                Inherit()
                {
                    cout << __func__ << ":" << __LINE__  << endl;
                }
                ~Inherit()
                {
                    cout << __func__ << ":" << __LINE__  << endl;
                }
        };
        int main()
        {
            Base *p;
            Inherit *q;
            //p = q;//Inherit * -> Base *
            q = static_cast<Inherit *> (p); //Base * -> Inherit *
            return 0;
        }

    4)dynamic_cast（有虚函数的类型转换）

        语法:dynamic_cast<newtype>(expression)

        功能:只有类中含有虚函数才能用dynamic_cast；仅能在继承类对象间转换

        注意:dynamic_cast具有类型检查的功能，比static_cast更安全

        eg:           

class Base{
            public:
                Base()
                {
                    cout << __func__ << ":" << __LINE__  << endl;
                }
                ~Base()
                {
                    cout << __func__ << ":" << __LINE__  << endl;
                }
        };
            class Inherit : public Base{
                public:
                    Inherit()
                    {
                        cout << __func__ << ":" << __LINE__  << endl;
                    }
                    ~Inherit()
                    {
                       cout << __func__ << ":" << __LINE__  << endl;
                    }
            };
            int main()
            {
                Base *p;
                Inherit *q;
                //p = q;//Inherit * -> Base *
                q = dynamic_cast<Inherit *> (p); //Base * -> Inherit *
                return 0;
            }

5.自定义转换函数

    eg:     

  class Demo{
        public:
            explicit Demo(int val) : val(val)
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
            ~Demo()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
        public:
            operator int() const //转换函数:Demo -> int
            {
                cout << __func__ << ":" << __LINE__ << endl;
                return this->val;
            }
        private:
            int val;
    };
    int main()
    {
        Demo obj(666);
        int i;
        i = obj; //Demo -> int
        cout << "i=" << i << endl;
        return 0;

    }

三.智能指针

本质：类模板，模板中重载了->和*运算符。

1.shared_ptr指针

 

template <class T>
    class myshared_ptr{
    public:
        myshared_ptr(T *p) : ptr(p)
        {
            count ++;
        }
        myshared_ptr(const myshared_ptr<T> &obj)
        {
            cout++;
        }
        ~myshared_ptr()
        {
            count--;
            if(0 == count)
                delete ptr;
        }
    public:
        operator ->()//重载->运算符
        {
        }
        operator *() //重载*运算符
        {  }
    private:
        T *ptr;
    };

   

2.unique_ptr指针(独享指针)

    eg:       

 class Demo{
        public:
            explicit Demo(int val=0) :val(val)
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }
            virtual ~Demo()
            {
                cout << __func__ << ":" << __LINE__ << endl;
            }

        public:
            void setval(int val)
            {
                this->val = val;
            }

            int getval() const
            {
                return this->val;
            }
        private:
            int val;
    };
    int main()
    {
        unique_ptr<Demo> p(new Demo);//构造对象p
        //unique_ptr<Demo> pp = p;//禁止拷贝构造
        p->setval(666);//等价：(*p).setval(666);
        cout << p->getval() << endl;
        return 0;

    }

3.weak_ptr(弱指针)

    通常配合共享指针进行操作；

西装没钱买
关注
  • 25
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++软件调试与异常排查从入门到精通系列文章汇总
dvlinker的技术专栏
06-29 15万+
根据近几年排查软件异常的实践与经验，系统地讲解了C++软件异常常见原因与常用排查方法，以图文并茂的方式给出具体的分析实例，带领大家逐步掌握C++软件异常排查的相关技术与要领。
【C++】std::function与函数指针
芒果黑的博客
10-24 8250
之前项目中遇到过一个使用std::function解决函数指针不好解决的一个场景，这里记录一下。 场景描述 首先看结构，有两个引导页，他们都有共同的基类guidebase 基类的代码： 头文件： #include <QList> #include <functional> class GuideBase { public: GuideBase(); protected: void mousePressEvent(); protected: .
C++笔记-使用std::funcional代替函数指针
IT1995的博客
09-14 6049
目录 基本概念 代码与实例 基本概念 在C++中有个functional的头文件中有一个functional，可以代替函数指针！具体代码如下！ 代码与实例 程序运行截图如下： 源码如下： #include <iostream> #include <functional> using namespace std; void func(voi...
C++ 智能指针 - 全部用法详解
cpp_learner的博客
08-02 6万+
血的教训？不学智能指针，本人丢了一份工作。
C++ STL 四种智能指针
热门推荐
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
C++之std::bind()函数的使用
qq_44237695的博客
03-11 5221
C++ std::bind()函数的使用
c++智能指针和普通指针之间相互转换
qq_40340448的博客
02-07 1万+
#include <iostream> #include <memory>//智能指针的头文件 class test { public: test(int d) :data(d){} int data; }; int main() { test *p = new test(10);//初始化一个test对象 std::shared_ptr&...
C++函数指针和std::function对象
给永远比拿愉快
10-08 7517
C++函数指针和std::function对象 这篇博文中通过实现对String字符串大小写转换为列来说明C++中函数指针和std::function对象的使用。 我们在博文《C++实现一个简单的String类》中的自定义的String类为基础，再添加两个成员函数用于将字符串全部转为大写（toUpperCase）和全部转为小写（toLowerCase）。 分析一下这两个函数，我们可以发现，两个函数...
C++ malloc、智能指针、类型转换等（三）
qq_43142509的博客
03-12 2485
malloc、强制转换、智能指针
C++：函数：匿名函数Lambda
C++ JAVA的专栏
11-16 4496
C++：函数：匿名函数Lambda
C++ 中boost::share_ptr智能指针的使用方法
08-29
C++ 中boost::share_ptr智能指针的使用方法 Boost 库的智能指针是 C++ 编程中的一种重要工具，它能够自动管理内存的释放，减少了程序员的负担。其中，boost::shared_ptr 是一种常用的智能指针，它能够使 C++ 的开发...
C++ 一般（普通）函数指针、类成员函数指针，用法区别，以及强制转换
07-03
要调用这个成员函数，你需要一个`Person`对象实例和成员函数指针： ```cpp Person p; (p.*say_hello_ptr)("Alice"); ``` 这里要注意的是，静态成员函数不与特定的对象实例关联，因此它们的指针可以用作一般函数...
C++中的函数指针与函数对象的总结
09-05
例如，声明一个返回整型、接受整型参数的函数指针： ```cpp int (*func_ptr)(int); ``` 使用`typedef`可以让声明更简洁： ```cpp typedef int (*PF) (int); PF pf; ``` 调用函数指针时，可以使用`(*func_ptr)...
C++获取类的成员函数的函数指针详解及实例代码
08-31
在C++编程语言中，获取类的成员函数的函数指针是一项重要的技术，它允许我们动态地调用对象的成员函数。下面将详细介绍这一概念，并通过实例代码进行解析。 首先，我们需要理解成员函数指针的概念。成员函数是类的...
C++如何用智能指针管理内存资源
09-07
- 总是使用`std::make_unique`或`std::make_shared`来创建智能指针，而不是直接使用`new`，这样可以确保正确处理异常安全性和初始化列表。 5. **智能指针的注意事项**： - 虽然智能指针在大多数情况下可以防止...
C++ 多态
最新发布
wxk2227814847的博客
07-10 501
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【明文导入密钥(C/C++)】
m0_70748845的博客
07-07 399
以明文导入ECC密钥为例。具体的场景介绍及支持的算法规格。
C++初探究（2）
Frenemy__的博客
07-09 1276
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 938
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
计算机等级考试二级C++考点：类的转换.docx
08-01
转换可以是隐式的，也可以是显式的，通常涉及到转换构造函数和成员转换函数。 一、转换构造函数 转换构造函数是一种特殊的构造函数，它的作用是将其他类型的数据转换成类的对象。这种构造函数有一个参数，且该参数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值