C++异常

最新推荐文章于 2023-01-16 16:36:10 发布
最新推荐文章于 2023-01-16 16:36:10 发布
阅读量688 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： c++ 文章标签： 异常处理 异常 vector
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_30366449/article/details/76861683

异常是指存在于运行时的反常行为，这些行为超出了函数正常功能的范围。
所以在程序的某部分检测到一个它无法处理的问题时，需要用到异常处理。
首先我们先贴代码

#include "stdafx.h"
#include <iostream>
using namespace std;

template <class T>
class Vector {
public:
    Vector(int);
    ~Vector();
    Vector(const Vector&);
    Vector& operator=(const Vector& rhs);
    T& operator[](int);
private:
    T* m_elements;
    int m_size;
};

template <class T>
Vector<T>::Vector(int size) :m_size(size) {
    cout << "this is constructor" << endl;
    m_elements = new T[m_size];
}

template <class T>
Vector<T>::~Vector() {
    cout << "this is Destrucor" << endl;
    delete[] m_elements;
    m_elements = NULL;
}

template<class T>
Vector<T>::Vector(const Vector &)
{
    cout << "this is copy construcor" << endl;
}


template <class T>
Vector<T>& Vector<T>::operator=(const Vector& rhs) {
    cout << "this is = " << endl;

}

template <class T>
T& Vector<T>::operator[](int index) {
    if (index>0 && index<m_size) {
        return m_elements[index];
    }
    else {
        cout << "index is invalid" << endl;
    }
}//这样处理会发生异常，没有返回值

int main()
{
    Vector<int> v1(6);
    cout << "hello" << endl;
    int i = 1;
    for (; i < 6; i++) {
        v1[i] = i;
    }
    cout << i << endl;
    return 0;
}

异常时不良的处理有：

  • 1 返回值是不缺的内存的值
    return m_elements[index];
  • 2 错误时，返回一个错误值
T& Vector<T>::operator[](int index) {
    if (index<0 || index>=m_size) {
        T* error_marker = new T("something magic value");
        return *error_marker;
    }
    return m_elements[index];
}

x = v1[2] + v1[4]; //一旦v1[4]越界，则x无法计算
  • 3 退出处理
    if(index<0||index>=m_size){
         exit(666);
    }
    return m_elements[index];
  • 4 自动判断
assert(index>= 0&& intdex <m_size);
return m_elements[index];

所以这时候，我们可以用关键字 throw 抛出一个异常。

template <class T>
T& Vector<T>::operator[](int index) {
    if (index<0 || index>=m_size) {
        //throw is a keyword
        //exception is raised at this point
        throw <<something>>;
    }
    return m_elements[index];
}

可以通过原始类型或者一个类去表达这个error

class VectorIndexError{
public:
    VectorIndexError(int v):m_badValue(v){ }
    ~VectorIndexError(){ }
    void diagnostic(){
        cerr <<"index "<< m_badValue<<"out of range!";}
private:
    int m_badValue;
};

template <class T>
T& Vector<T>::operator[](int index) {
    if (index<0 || index>=m_size) {
        //throw is a keyword
        //exception is raised at this point
        throw VectorIndexError(index);
    }
    return m_elements[index];
}

#include "stdafx.h"

#include <iostream>
using namespace std;

template <class T>
class Vector {
public:
    Vector(int);
    ~Vector();
    Vector(const Vector&);
    Vector& operator=(const Vector& rhs);
    T& operator[](int);
private:
    T* m_elements;
    int m_size;
};

template <class T>
Vector<T>::Vector(int size) :m_size(size) {
    cout << "this is constructor" << endl;
    m_elements = new T[m_size];
}

template <class T>
Vector<T>::~Vector() {
    cout << "this is Destrucor" << endl;
    delete[] m_elements;
    m_elements = NULL;
}

template<class T>
Vector<T>::Vector(const Vector &)
{
    cout << "this is copy construcor" << endl;
}


template <class T>
Vector<T>& Vector<T>::operator=(const Vector& rhs) {
    cout << "this is = " << endl;

}

class VectorIndexError {
public:
    VectorIndexError(int v) :m_badValue(v) { }
    ~VectorIndexError() { }
    void diagnostic() {
        cerr << "index " << m_badValue << " out of range!" << endl;
    }
private:
    int m_badValue;
};

template <class T>
T& Vector<T>::operator[](int index) {
    if (index<0 || index >= m_size) {
        //throw is a keyword
        //exception is raised at this point
        throw VectorIndexError(index);
    }
    return m_elements[index];
}



int func() {
    Vector<int> v(12);
    v[3] = 5;
    int i = v[20];  //out of range!
                    //control never get here
    return 5 * i;
}

void outer() {
    try {
        func();
        //func2();
    }
    catch (VectorIndexError& o) {
        o.diagnostic();
        //This exception does not propagate
    }
    cout << "Control is here after exception";
}

int main()
{
    Vector<int> v1(6);
    cout << "hello" << endl;
    int i = 1;
    for (; i < 6; i++) {
        v1[i] = i;
    }
    cout << i << endl;
    cout << "do exception test" << endl;
    outer();
    cout << endl;
    return 0;
}

所以异常处理包括：

  • throw 表达式，异常检测部分使用 throw 表达式来表示遇到了无法处理的异常问题，即 throw 引发了异常。
  • try 语句块，异常处理部分使用 try 语句块处理异常。try 语句块以关键字 try 开始，并以一个或多个 catch 子句解释。

下面给出一个

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

template <class T>
class Vector {
public:
    Vector(int);
    ~Vector();
    Vector(const Vector&);
    Vector& operator=(const Vector& rhs);
    T& operator[](int);
private:
    T* m_elements;
    int m_size;
};

template <class T>
Vector<T>::Vector(int size) :m_size(size) {
    cout << "this is constructor" << endl;
    m_elements = new T[m_size];
}

template <class T>
Vector<T>::~Vector() {
    cout << "this is Destrucor" << endl;
    delete[] m_elements;
    m_elements = NULL;
}

template<class T>
Vector<T>::Vector(const Vector &)
{
    cout << "this is copy construcor" << endl;
}


template <class T>
Vector<T>& Vector<T>::operator=(const Vector& rhs) {
    cout << "this is = " << endl;

}

template <class T>
T& Vector<T>::operator[](int index) {
    if (index<0 || index >= m_size) {
        //throw is a keyword
        //exception is raised at this point
        throw VectorIndexError(index);
    }
    return m_elements[index];
}

class VectorIndexError {
public:
    VectorIndexError(int v) :m_badValue(v) { }
    ~VectorIndexError() { }
    void diagnostic() {
        cerr << "index " << m_badValue << " out of range!" << endl;
    }
private:
    int m_badValue;
};

int func() {
    Vector<int> v(12);
    v[3] = 5;
    int i = v[20];  //out of range!
                    //control never get here
    return 5 * i;
}

void outer() {
    try {
        func();
        //func2();
    }
    catch (VectorIndexError& o) {
        o.diagnostic();
        //This exception does not propagate
    }
    cout << "Control is here after exception";
}

void outer2() {
    string err("exception caught");
    try {
        func();
        //func2();
    }
    catch (VectorIndexError) {
        cout << err << endl;
        throw;  //propagate the exception
    }
}

void outer3() {
    try {
        outer2();
    }
    catch(...){
        //... means catchs ALL exception no matter what types(int ,double class exception types)
        cout << "The exception stops here!" << endl;
    }
}

int main()
{
    Vector<int> v1(6);
    cout << "hello" << endl;
    int i = 1;
    for (; i < 6; i++) {
        v1[i] = i;
    }
    cout << i << endl;
    cout << "do exception test" << endl;
    outer();
    cout << endl;
    cout << "do exception test2" << endl;
    //outer2();
    //cout << endl;
    outer3();
    return 0;
}

机制如下图所示：
这里写图片描述

异常处理的步骤是：
先顺序执行 throw 表达式，在每一个 throw 表达式里面按顺序执行：

  • 1 Check for exact match

  • 2.Apply base class conversions
    –Reference and pointer types only

  • 3.Ellipses(…)match all

其中， throw 表达式可以理解成函数调用，表达式类型就是异常抛出的类型。

C++ Standard Exceptions(回顾基础)
爱拼才会赢
10-08 875
/* Exercise 5.23: Write a program that reads two integers from the standard input and prints the result of dividing the first number by the second. */ #include int main(void) { int a, b;
【C++】C++异常处理精要：从传统C语言错误处理到现代C++异常机制
最新发布
Colorful___的博客
05-23 1399
在软件开发中，错误处理是确保程序稳定性和健壮性的关键环节。C语言和C++语言在错误处理方面有着显著的不同。C语言通常采用返回错误码或终止程序的方式，而C++则引入了异常处理机制，提供了一种更为灵活和强大的错误处理方式。本文将深入探讨C语言的传统错误处理方式，C++的异常处理机制，以及如何高效地使用C++的异常处理来提高代码的可读性、可维护性和异常安全性。异常处理机制是一种编程范式，用于在程序运行时检测到错误和异常情况时采取相应的措施。
pta c++ 程序填空题
weixin_62566689的博客
01-16 4939
pta c++ 判断题 类与对象 数据共享与保护 数组 指针 字符串 继承与派生 多态性 群体类和群体数据的组织 泛型程序设计 流类库与输入输出 异常处理 stl 面向对象程序设计 成员函数 构造函数 析构函数 类的组合 作用域 静态 动态 友元 常对象 多文件结构 对象数组 this指针 动态内存分配 引用 虚函数 抽象类 运算符重载 函数模板 类模板 容器
C++ 模板 泛型编程
weixin_41111116的博客
07-03 567
C++ 模板
c++之面向对象编程
qq_31861931的博客
10-20 936
概述 在面向对象程序（OOP）设计思想出现之前，程序采用面向过程的设计方法，程序由数据和函数组成，函数是程序的基本组成单元。面向过程方法灵活性强，逻辑简单，但函数名众多容易造成混乱，且函数和数据分开存放，联系不够紧密，在大型软件开发中采用面向过程方式效率低下、维护困难。 类和对象 类和对象是面向对象编程的核心，类和对象类似建筑图纸和大楼的关系，类是对象的一种抽象，对象是类的一个实例。在面向对...
C++ standard exceptions
#+!
04-15 1199
Standard exceptions The C++ Standard library provides a base class specifically designed to declare objects to be thrown as exceptions. It is called exception and is defined in the  header file und
C# 捕获C/C++异常的例子
04-11
为了在C#中处理C++异常，我们需要使用`extern "C"`和`System::Runtime::InteropServices`命名空间中的特性来定义接口和方法。例如： ```csharp using System; using System.Runtime.InteropServices; ...
C++ 异常处理 catch(…)介绍
01-01
C++标准中定义了一种特殊的catch用法，那就是” catch(…)”。 感性认识 1、catch(…)到底是一个什么样的东东，先来个感性认识吧!看例子先： 代码如下:　int main() { try { cout << “在 try block 中, 准备...
C++ 异常的详细介绍
01-21
c++异常为处理这种情况提供了一种功能强大的而灵活的工具。异常是相对比较新的C++功能，有些老编译器可能没有实现。另外，有些编译器默认关闭这种特性，我们可能需要使用编译器选项来启用它。 一、异常机制的使用 ...
浅谈C++ 异常处理的语义和性能
12-22
3. **C++ 加SEH**（/EHa）：这种模式同时支持C++异常和Windows的SEH异常，因此可以捕获更多类型的错误，包括系统级别的异常。这会进一步增加代码大小，因为需要处理更多的异常情况，但提高了程序的健壮性。 在讨论...
c++中human* p = new man；p->Disp();题目
天天的优快云
05-21 1632
#include "stdafx.h" #include using namespace std; class human { public: ~human() { cout } void Disp() { cout } }; class man  :  public human { public: ~man() {
C++标准库中封装的一些数据结构
洞若观火
05-28 1829
向量(vector) #include <vector> 1.构造函数 vector():创建一个空vector vector(int nSize):创建一个vector,元素个数为nSize vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t vector(const vector&):复制构造函数 v...
C++类模板中使用异常知识点
2359Coding
05-06 1263
这一篇主要记录了类模板中使用异常类的知识点 类模板中使用异常类的时候，异常类同样可以进行模板化 下面通过这个小案例来明白这个知识点 #include #include using namespace std; class Error :public exception{ }; template class Myerror{ public: void showError()
函数模板----template＜typename T＞/ ttemplate＜class T＞
明月清风 精进不止
10-28 303
#include <iostream> using namespace std; template<class T>// 这句话的意思是告诉编译器紧接着的函数中的T不要报错，T代表的是泛型的数据 void swapT(T& a, T& b) { T c = a; a = b; b = c; } int main() { int a = 10; int b = 20; //1.编译器自动推导类型 swa.
C++ 语言学习 day07 函数异常，模板，模板类
she666666的博客
09-05 503
函数异常，模板，模板类，template typename
第六周C++上机报告（项目1--改错）
sdzbwxt的专栏
04-05 1047
此为错误代码： #include #include using namespace std; class C {private: int x; public: C(int x){this->x = x;} int getX(){return x;} }; int main() { const C c(5); cout<<c.getX()<<endl; return
C++：模板
qq_53826699的博客
06-08 353
●模板的概念 ●在C++标准库中，几乎所有的代码都是模板代码。 ●模板是对具有相同特性的函数或类的再抽象，模板是一种参数化的多态性工具。 ●所谓参数化多态性，是指将程序所处理的对象的类型参数化，使一段程序代码可以用于处理多种不同类型的对象。 ●采用模板编程，可以为各种逻辑功能相同而数据类型不同的程序提供一种代码共享的机制。 ●函数模板 ●模板函数 ●类模板与模板类 ●类模板的友元 ●STL标准库的相关内容(迭代器、算法、容器等) ...
C++中的模板类
热门推荐
qq_39645539的博客
07-11 1万+
什么是模板类：C++发展到一定层次后，必然有部分代码存在仅传参的数据类型不同而内容一致的情况。因此，C++为解决此类场景，特推出模板类的使用。模板类是一种泛型技术，即与数据类型无关的通用程序设计技术。可以使我们设计出独立于数据类型的程序。模板类本身不占空间，当编译器执行到模板参数的调用时，当在程序中赋予具体的数据类型后并调用时则占用空间。常见的模板包含函数模板与类模板。模板的声明中class含义同typenamec，class并不是表明后续的类型名是一个类，而表示后续是一个通用的类型说明符。一、函数模板函数
双栈共享存储空间（C++代码实现）
qq_45767476的博客
05-23 1626
理论部分 理论来源：b站up主:跟懒猫老师快乐数据结构 C++代码 #include<iostream> using namespace std; const int STACKSIZE = 6; //两栈共享存储空间编程 //使用类模板编程 template<class DataType> class BothStack { private: DataType *data;//属性,顺序栈,数组 int top1, top2;//属性，top1指向栈1的栈顶,top
C++异常处理深度解析
"一本关于C++异常处理的书籍，作者为Robert Schmidt，译者为无情。本书涵盖了C和C++中的异常处理机制，包括标准C++异常处理的基本语法和语义，异常安全，模板安全等内容，并探讨了如何混合使用C++异常和Visual C++的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值