linux结构化异常,异常 try catch

# 基本结构

```

try

{

// 保护代码

}catch( ExceptionName e1 )

{

// catch 块

}catch( ExceptionName e2 )

{

// catch 块

}catch( ExceptionName eN )

{

// catch 块

} catch(...) {

}

```

# 抛出异常

```

double division(int a, int b)

{

if( b == 0 )

{

throw "Division by zero condition!";

}

return (a/b);

}

```

# 捕获异常

```

try

{

// 保护代码

}catch( ExceptionName e )

{

// 处理 ExceptionName 异常的代码

}

```

# 下表是对上面层次结构中出现的每个异常的说明：


| 异常 | 描述 |

| --- | --- |

| **std::exception** | 该异常是所有标准 C++ 异常的父类。 |

| std::bad\_alloc | 该异常可以通过**new**抛出。 |

| std::bad\_cast | 该异常可以通过**dynamic\_cast**抛出。 |

| std::bad\_exception | 这在处理 C++ 程序中无法预期的异常时非常有用。 |

| std::bad\_typeid | 该异常可以通过**typeid**抛出。 |

| **std::logic\_error** | 理论上可以通过读取代码来检测到的异常。 |

| std::domain\_error | 当使用了一个无效的数学域时，会抛出该异常。 |

| std::invalid\_argument | 当使用了无效的参数时，会抛出该异常。 |

| std::length\_error | 当创建了太长的 std::string 时，会抛出该异常。 |

| std::out\_of\_range | 该异常可以通过方法抛出，例如 std::vector 和 std::bitset<>::operator\[\]()。 |

| **std::runtime\_error** | 理论上不可以通过读取代码来检测到的异常。 |

| std::overflow\_error | 当发生数学上溢时，会抛出该异常。 |

| std::range\_error | 当尝试存储超出范围的值时，会抛出该异常。 |

| std::underflow\_error | 当发生数学下溢时，会抛出该异常。 |

# 定义新的异常

```

#include

#include

using namespace std;

struct MyException : public exception

{

const char * what () const throw ()

{

return "C++ Exception";

}

};

int main()

{

try

{

throw MyException();

}

catch(MyException& e)

{

std::cout << "MyException caught" << std::endl;

std::cout << e.what() << std::endl;

}

catch(std::exception& e)

{

//其他的错误

}

}

```

# 自定义异常

```

void myTerminate()

{

cout<

exit(1);

}

int main()

{

set_terminate(myTerminate);

if(true) {

throw0;

}

return0;

}

```

# noexcept

```

void fun() noexcept 声明不会抛出异常

```