相关疑难解决方法(0)

我已经多次听过和读过,最好将异常作为引用而不是引用来引用.为什么是

try {
    // stuff
} catch (const std::exception& e) {
    // stuff
}

比...更好

try {
    // stuff
} catch (std::exception& e) {
    // stuff
}

我发现有三种方法可以捕获异常,有什么区别？

1)按价值捕获;

2)引用参考;

3)用指针抓住;

我只知道按值捕获将调用该对象的两个副本,通过引用捕获将调用一个.那么指针捕获怎么样？什么时候用指针捕捉？除了抛出一个对象,我可以抛出一个像这样的对象的指针吗？

class A {}

void f() {

  A *p = new A();
        throw p;


}

如果我传递派生类的对象,则应调用派生类catch块.但输出表明异常是由基类捕获的.为什么？

#include<iostream>
using namespace std;

class Base {};
class Derived: public Base {};
int main()
{
   Derived d;
   // some other stuff
   try {
       // Some monitored code
       throw d;
   }
   catch(Base b) { 
        cout<<"Caught Base Exception";
   }
   catch(Derived d) {  //This catch block is NEVER executed
        cout<<"Caught Derived Exception";
   }
   getchar();
   return 0;
}

这是一个理论问题,可以更好地理解异常的工作原理.

我需要检查什么才能确保我的课程安全？当我从堆栈的角度抛出异常时会发生什么？

例如,如果我在堆栈中创建一个对象,那么当我离开作用域时它应该被销毁,但是当我抛出该对象时会发生什么？这样做是安全的还是我必须在堆上创建对象？

非常感谢!

Sutter和Alexandrescu的编码标准告诉我们通过引用捕获异常.

当然,像这样的一揽子建议通常会偶尔有例外(没有双关语意).是否有任何使用案例,首选按值列出异常？

我有一个带有自定义异常的模板类:

MyClass<T>::MyException;

在使用我的类时,我只关心是否抛出了异常,因此我可以以编程方式处理它.因此,当我发现异常时,我不愿意为此命名.

try {
   MyClass<T>::MyMethod ();
} catch (typename MyClass<T>::MyException) {
   //Act appropriately
}

我想知道添加引用运算符时是否有任何区别,例如

} catch (typename MyClass::MyException &) {

在任何一种情况下,除了识别类型之外,我最终不会使用捕获的异常.一个与另一个有任何权衡或性能影响吗？

我的示例代码:

#include<iostream>
using namespace std;

class Test{ public: int set;};
Test T;

int main()
{
    T.set = 100;
    try{
        throw T;
    }
    catch(Test &T)
    {
        T.set = 0;
    }
    cout<<T.set<<endl;
    return 1;
}

这里我通过引用捕获抛出的T对象并在catch块中修改它的值.为什么在块之后T对象仍然打印？在这种情况下,参考语法对值的传递有什么用？100catch

编译器:gcc 5.1.0