0
点赞
收藏
分享

微信扫一扫

C++翁恺学习33-异常的抛出和捕捉

蛇发女妖 2022-04-27 阅读 53
c++

example:Vector

template <class T> class Vector{
private:
    T* m_elements;
    int m_size;
public:
    Vector (int size = 0):m_size(size)...
    ~Void(){delete [] m_elements;}
    void length(int);
    int length(){return m_size;}
    T& operator[](int);
};

problem

template <class T>
T& Vector<T>::operator[](int indx){}
  • what should the [] operator do if the index is not valid?  index 越界怎么办?

    1.)return random memory object   不可以

    return m_elements[indx];

    2.)return a special error value   返回一个特殊错误值  不是好办法

    if (indx < 0 || indx >= m_size){
        T* error_marker = new T("some magic value");
        return *error_marker;
    }
    return m_elements[indx];

    *but this throws the baby out with the bath!

    x = v[2] + v[4];      //not safe code

    3.)just die!    

    if (indx < 0 || indx >= m_size){
        exit(22);
    }
    return m_elements[indx];

    4.)die gracefully (with autopsy!)

    assert(indx >= 0 && indx < m_size);  // 不合适
    retrun m_elements[indx];

when to use exceptions  好的解决办法

  • many times ,you don't know what should be done

  • if you do anything you'll be wrong

  • solution:turf the problem

    make your caller(or its caller...) responsible

how to raise an exception

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

what do you throw?

//what do you have? Data!

//define a class to represent the error

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

how to raise an exception

template<class T>
T& Vector<T>::operator[](int indx){
    if(indx < 0 || indx >= m_size){
        //VectorIndexError
        //throw e;
        throw VectorIndeError(indx); // VectorIndeError对象在堆栈里面
    }
    return m_elements[indx];
}

what about your caller?

  • case 1 Doesn't care

    • code never even suspects a problem

      int func(){
          Vector<int> v(12);
          v[3] = 5;
          int i = v[42];//out of range
          //control never gets here!
          return i*5;
      }
  • case2 cares deeply

    void outer(){
        try{
            func(); func2();  // func2 不执行
        }catch(VectorIndexError& e){
            e.diagnostic();
            //this excpetion does not propagete
        }
        cout << "control is here after exception"
    }
  • case3 mildly interested

    void outer2(){
        String err("exception caught");
        try{
            func();
        }catch(VextorIndexError){
            cout << err;
            throw;  //propagate the exception
        }
    }
  • case4 does't care about the particulars

    void outer3(){
        try {
            outer2();
        }catch(...){ // 捕捉所有异常
            //...catches **all** exceptions!
            cout << "the exception stops here"
        }
    }

what happened?

review

  • throw statement raise the exception
    • control propagates back to first handler for that exception
    • propagation follows the call chain
    • objects on stack are properly destroyed
  • "throw exp"
    • throws values for matching
  • "throw"
    • reraises the exception being handled
    • valid only within a handler
举报

相关推荐

0 条评论