微信用什么小程序可以提取文字_室内设计怎么网上接单_八戒_一份完整的电商运营方案

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);
};

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];
  

• 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

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

//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;
};

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];
}

• 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"}
  }
  

• 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