本文介绍: c++异常处理使得异常的引发和异常的处理不必在一个函数中,这样底层的函数可 以着重解决具体问题,而不必过多的考虑异常的处理。),要认识到的一个思想: 在异常处理过程中,由问题检测代码可以抛出一个对象给问题处理代码,通过这个 对象的类型和内容,实际上完成了两个部分的通信,通信的内容是“还有一个缺点就是函数的返回值只有一个,你通过函数的返回值表示错误代码, 那么函数就不能返回其他的值。转换是非常有用的,但是它也会带来一些问题,比如在转换指针时,我们很可能将其转换成一个比它更大的类型,但这可能会破坏其他的数据。
C++类型转换
静态转换(static_cast)
class Animal{};
class Dog : public Animal{};
class Other{};
//基础数据类型转换
void test01(){
char a = 'a';
double b = static_cast<double>(a);
}
//继承关系指针互相转换
void test02(){
//继承关系指针转换
Animal* animal01 = NULL;
Dog* dog01 = NULL;
//子类指针转成父类指针,安全
Animal* animal02 = static_cast<Animal*>(dog01);
//父类指针转成子类指针,不安全
Dog* dog02 = static_cast<Dog*>(animal01);
}
//继承关系引用相互转换
void test03(){
Animal ani_ref;
Dog dog_ref;
//继承关系指针转换
Animal& animal01 = ani_ref;
Dog& dog01 = dog_ref;
//子类指针转成父类指针,安全
Animal& animal02 = static_cast<Animal&>(dog01);
//父类指针转成子类指针,不安全
Dog& dog02 = static_cast<Dog&>(animal01);
}
//无继承关系指针转换
void test04(){
Animal* animal01 = NULL;
Other* other01 = NULL;
//转换失败
//Animal* animal02 = static_cast<Animal*>(other01);
}
动态转换(dynamic_cast)
class Animal {
public:
virtual void ShowName() = 0;
};
class Dog : public Animal{
virtual void ShowName(){
cout << "I am a dog!" << endl;
}
};
class Other {
public:
void PrintSomething(){
cout << "我是其他类!" << endl;
}
};
//普通类型转换
void test01(){
//不支持基础数据类型
int a = 10;
//double a = dynamic_cast<double>(a);
}
//继承关系指针
void test02(){
Animal* animal01 = NULL;
Dog* dog01 = new Dog;
//子类指针转换成父类指针 可以
Animal* animal02 = dynamic_cast<Animal*>(dog01);
animal02->ShowName();
//父类指针转换成子类指针 不可以
//Dog* dog02 = dynamic_cast<Dog*>(animal01);
}
//继承关系引用
void test03(){
Dog dog_ref;
Dog& dog01 = dog_ref;
//子类引用转换成父类引用 可以
Animal& animal02 = dynamic_cast<Animal&>(dog01);
animal02.ShowName();
}
//无继承关系指针转换
void test04(){
Animal* animal01 = NULL;
Other* other = NULL;
//不可以
//Animal* animal02 = dynamic_cast<Animal*>(other);
}
常量转换(const_cast)
//常量指针转换成非常量指针
void test01(){
const int* p = NULL;
int* np = const_cast<int*>(p);
int* pp = NULL;
const int* npp = const_cast<const int*>(pp);
const int a = 10; //不能对非指针或非引用进行转换
//int b = const_cast<int>(a); }
//常量引用转换成非常量引用
void test02(){
int num = 10;
int & refNum = num;
const int& refNum2 = const_cast<const int&>(refNum);
}
重新解释转换(reinterpret_cast)
这是最不安全的一种转换机制,最有可能出问题。
C++异常
异常基本概念
Bjarne Stroustrup 说:提供异常的基本目的就是为了处理上面的问题。基本思想是: 让一个函数在发现了自己无法处理的错误时抛出(throw
)一个异常,然后它的 (直接或者间接)调用者能够处理这个问题。也就是《C++ primer
》中说的:将问 题检测和问题处理相分离。
)一个异常,然后它的 (直接或者间接)调用者能够处理这个问题。也就是《C++ primer
》中说的:将问 题检测和问题处理相分离。
一种思想:在所有支持异常处理的编程语言中(例如 java
),要认识到的一个思想: 在异常处理过程中,由问题检测代码可以抛出一个对象给问题处理代码,通过这个 对象的类型和内容,实际上完成了两个部分的通信,通信的内容是“
出现了什么错 误”
。当然,各种语言对异常的具体实现有着或多或少的区别,但是这个通信的思 想是不变的。
),要认识到的一个思想: 在异常处理过程中,由问题检测代码可以抛出一个对象给问题处理代码,通过这个 对象的类型和内容,实际上完成了两个部分的通信,通信的内容是“
出现了什么错 误”
。当然,各种语言对异常的具体实现有着或多或少的区别,但是这个通信的思 想是不变的。
在 C
语言的世界中,对错误的处理总是围绕着两种方法:一是使用整型的返回值 标识错误;二是使用 errno
宏(可以简单的理解为一个全局整型变量)去记录错误。 当然 C++
中仍然是可以用这两种方法的。 这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回 1
表示成功, 返回 0
表示出错;而有些函数返回
0
表示成功,返回非
0
表示出错。
语言的世界中,对错误的处理总是围绕着两种方法:一是使用整型的返回值 标识错误;二是使用 errno
宏(可以简单的理解为一个全局整型变量)去记录错误。 当然 C++
中仍然是可以用这两种方法的。 这两种方法最大的缺陷就是会出现不一致问题。例如有些函数返回 1
表示成功, 返回 0
表示出错;而有些函数返回
0
表示成功,返回非
0
表示出错。
函数的返回值可以忽略,但异常不可忽略。如果程序出现异常,但是没有被捕获, 程序就会终止,这多少会促使程序员开发出来的程序更健壮一点。而如果使用 C 语言的 error
宏或者函数返回值,调用者都有可能忘记检查,从而没有对错误进行 处理,结果造成程序莫名其面的终止或出现错误的结果。
宏或者函数返回值,调用者都有可能忘记检查,从而没有对错误进行 处理,结果造成程序莫名其面的终止或出现错误的结果。
异常处理可以在调用跳级。这是一个代码编写时的问题:假设在有多个函数的调 用栈中出现了某个错误,使用整型返回码要求你在每一级函数中都要进行处理。而 使用异常处理的栈展开机制,只需要在一处进行处理就可以了,不需要每级函数都 处理。
//如果判断返回值,那么返回值是错误码还是结果?
//如果不判断返回值,那么 b==0 时候,程序结果已经不正确
//A 写的代码
int A_MyDivide(int a,int b){
if (b == 0){
return -1;
}
return a / b;
}
//B 写的代码
int B_MyDivide(int a,int b){
int ba = a + 100;
int bb = b;
int ret = A_MyDivide(ba, bb); //由于 B 没有处理异常,导致 B 结果运算错误
return ret;
}
//C 写的代码
int C_MyDivide(){
int a = 10;
int b = 0;
int ret = B_MyDivide(a, b); //更严重的是,由于 B 没有继续抛出异常,导
致 C 的代码没有办法捕获异常
if (ret == -1){
return -1;
}
else{
return ret;
}
}
//所以,我们希望:
//1.异常应该捕获,如果你捕获,可以,那么异常必须继续抛给上层函数,你不处理,不
代表你的上层不处理
//2.这个例子,异常没有捕获的结果就是运行结果错的一塌糊涂,结果未知,未知的结果
程序没有必要执行下去
异常语法
int A_MyDivide(int a, int b){
if (b == 0){
throw 0;
}
return a / b;
}
//B 写的代码 B 写代码比较粗心,忘记处理异常
int B_MyDivide(int a, int b){
int ba = a;
int bb = b;
int ret = A_MyDivide(ba, bb) + 100; //由于 B 没有处理异常,导致 B 结果运算错误
return ret;
}
//C 写的代码
int C_MyDivide(){
int a = 10;
int b = 0;
int ret = 0;
//没有处理异常,程序直接中断执行
#if 1
ret = B_MyDivide(a, b);
//处理异常
#else
try{
ret = B_MyDivide(a, b); //更严重的是,由于 B 没有继续抛出异常,导致 C 的代码没有办法捕获异常
}
catch (int e){
cout << "C_MyDivide Call B_MyDivide 除数为:" << e << endl;
}
#endif
return ret;
}
int main(){
C_MyDivide();
system("pause");
return EXIT_SUCCESS;
}
异常严格类型匹配
void TestFunction(){
cout << "开始抛出异常..." << endl;
//throw 10; //抛出 int 类型异常
//throw 'a'; //抛出 char 类型异常
//throw "abcd"; //抛出 char*类型异常
string ex = "string exception!";
throw ex;
}
int main(){
try{
TestFunction();
}
catch (int){
cout << "抛出 Int 类型异常!" << endl;
}
catch (char){
cout << "抛出 Char 类型异常!" << endl;
}
catch (char*){
cout << "抛出 Char*类型异常!" << endl;
}
catch (string){
cout << "抛出 string 类型异常!" << endl;
}
//捕获所有异常
catch (...){
cout << "抛出其他类型异常!" << endl;
}
system("pause");
return EXIT_SUCCESS;
}
栈解旋(unwinding)
异常被抛出后,从进入 try 块起,到异常被抛掷前,这期间在栈上构造的所有对象,
都会被自动析构。析构的顺序与构造的顺序相反,这一过程称为栈的解旋
(unwinding).
public:
Person(string name){
mName = name;
cout << mName << "对象被创建!" << endl;
}
~Person(){
cout << mName << "对象被析构!" << endl;
}
public:
string mName;
};
void TestFunction(){
Person p1("aaa");
Person p2("bbb");
Person p3("ccc");
//抛出异常
throw 10;
}
int main(){
try{
TestFunction();
}
catch (...){
cout << "异常被捕获!" << endl;
}
system("pause");
return EXIT_SUCCESS;
}
异常接口声明
如
:void func()
:void func()
一个不抛任何类型异常的函数可声明为:void func() throw()
//可抛出所有类型异常
void TestFunction01(){
throw 10;
}
//只能抛出 int char char*类型异常
void TestFunction02() throw(int,char,char*){
string exception = "error!";
throw exception;
}
//不能抛出任何类型异常
void TestFunction03() throw(){
throw 10;
}
int main(){
try{
//TestFunction01();
//TestFunction02();
//TestFunction03();
}
catch (...){
cout << "捕获异常!" << endl;
}
system("pause");
return EXIT_SUCCESS;
}
异常变量生命周期
class MyException
{
public:
MyException(){
cout << "异常变量构造" << endl;
}
MyException(const MyException & e)
{
cout << "拷贝构造" << endl;
}
~MyException()
{
cout << "异常变量析构" << endl;
}
};
void DoWork()
{
throw new MyException(); //test1 2 都用 throw MyExecption();
}
void test01()
{
try
{
DoWork();
}
catch (MyException e)
{
cout << "捕获 异常" << endl;
}
}
void test02()
{
try
{
DoWork();
}
catch (MyException &e)
{
cout << "捕获 异常" << endl;
}
}
void test03()
{
try
{
DoWork();
}
catch (MyException *e)
{
cout << "捕获 异常" << endl;
delete e;
}
}
异常的多态使用
//异常基类
class BaseException{
public:
virtual void printError(){};
};
//空指针异常
class NullPointerException : public BaseException{
public:
virtual void printError(){
cout << "空指针异常!" << endl;
}
};
//越界异常
class OutOfRangeException : public BaseException{
public:
virtual void printError(){
cout << "越界异常!" << endl;
}
};
void doWork(){
throw NullPointerException();
}
void test()
{
try{
doWork();
}
catch (BaseException& ex){
ex.printError();
}
}
C++标准异常库
标准库介绍
标准异常类的成员:
标准异常类的具体描述:
#include<stdexcept>
class Person{
public:
Person(int age){
if (age < 0 || age > 150){
throw out_of_range("年龄应该在 0-150 岁之间!");
}
}
public:
int mAge;
};
int main(){
try{
Person p(151);
}
catch (out_of_range& ex){
cout << ex.what() << endl;
}
system("pause");
return EXIT_SUCCESS;
}
编写自己的异常类
① 标准库中的异常是有限的;
如何编写自己的异常类?
//自定义异常类
class MyOutOfRange:public exception
{
public:
MyOutOfRange(const string errorInfo)
{
this->m_Error = errorInfo;
}
MyOutOfRange(const char * errorInfo)
{
this->m_Error = string( errorInfo);
}
virtual ~MyOutOfRange()
{
}
virtual const char * what() const
{
return this->m_Error.c_str() ;
}
string m_Error;
};
class Person
{
public:
Person(int age)
{
if (age <= 0 || age > 150)
{
//抛出异常 越界
//cout << "越界" << endl;
//throw out_of_range("年龄必须在 0~150 之间");
//throw length_error("长度异常");
throw MyOutOfRange(("我的异常 年龄必须在 0~150 之间"));
}
else
{
this->m_Age = age;
}
}
int m_Age;
};
void test01()
{
try
{
Person p(151);
}
catch ( out_of_range & e )
{
cout << e.what() << endl;
}
catch (length_error & e)
{
cout << e.what() << endl;
}
catch (MyOutOfRange e)
{
cout << e.what() << endl;
}
}
原文地址:https://blog.csdn.net/weixin_50963877/article/details/134694695
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。
如若转载,请注明出处:http://www.7code.cn/show_7637.html
如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱:suwngjj01@126.com进行投诉反馈,一经查实,立即删除!
声明:本站所有文章,如无特殊说明或标注,均为本站原创发布。任何个人或组织,在未征得本站同意时,禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益,可联系我们进行处理。