如何使用try catch与构造函数？

Posted 2021-05-04

我看到很多例子，但我无法理解，如何使用try catch与一个简单的构造函数，我写了一个示例程序：

class A
 {
   public:
    try {
       A()
        { cout << "in costr
"; throw 10;}
    }//try closed
   catch (int a)
{ cout << "caught 1 
"; }

 };

main()
 {
   A *ptr = new A;
   }

1. 该程序给出了编译错误
2. 如果发现异常，对象会发生什么？

答案

try/catch代码应该在一起，你不能没有另一个。这样的事情就是你所追求的：

A *ptr;
try {
    ptr = new A();
} catch (int a) {
    cout << "caught 1
";
}

有关完整的工作示例，请参阅以下程序：

#include <iostream>

class A {
    private:
        int a;
    public:
        A() { a = 7; throw 42; }
        int getA() { return a; }
};

int main (void) {
    A *ptr;
    try {
        ptr = new A();
    } catch (int b) {
        std::cout << "Exception: " << b << '
';
        return -1;
    }
    std::cout << "Value: " << ptr->getA() << '
';
    return 0;
}

在那里有throw 42，你会看到：

Exception: 42

这意味着main已经捕获了来自构造函数的异常。没有throw，你会看到：

Value: 7

因为一切都有效。

---

您的代码的主要问题似乎是：

• 你有一个不应该的try声明。 Try/catch块通常应该在函数或方法中，你可以在public关键字之后立即使用它。
• 如果您从构造函数中抛出异常，则不会在构造函数中捕获它。相反，你在调用构造函数的代码中捕获它（在本例中为main）。
• 如前所述，try和catch在一起，他们不是独立的实体。

---

如果你在构造函数中尝试throw和catch，你仍然需要将它放在构造函数本身中，例如：

#include <iostream>

class A {
    private:
        int a;
    public:
        A() {
            try {
                a = 7;
                throw 42;
            } catch (int b) {
                std::cout << "Exception A: " << b << '
';
                throw;
            }
        }
        int getA() {return a;}
};

int main(void) {
    A *ptr;
    try {
        ptr = new A();
    } catch (int b) {
        std::cout << "Exception B: " << b << '
';
        return -1;
    }
    std::cout << "Value: " << ptr->getA() << '
';
    return 0;
}

这给你：

Exception A: 42
Exception B: 42

特别注意try/catch块是如何完整的并且在构造函数中。

另一答案

function try blocks解决了构造函数中提出的异常问题：

class A
 {
   public:
       A()
       try 
         { cout << "in costr
"; throw 10;}
      catch(...)
        { cout << "exception caught"; throw;}
 };

但他们正在解决的问题与你的例子不同。当类构造函数分配需要回收的资源时，需要函数try块。由于如果构造函数抛出（没有什么可以破坏，类没有构造开始），类的析构函数不运行，解决问题的一种方法是在构造函数上使用函数try块。注意构造函数try块必须重新抛出异常或原始异常，它们无法使异常捕获。

有关您要问的问题的更详细讨论（在构造函数中存在异常的对象的范围/生命周期），请参阅GOTW#66。

另一答案

如果你想要做的是处理构造函数中抛出的异常而不重新抛出它，那么你必须将try-catch块放在构造函数中，或者围绕构造函数初始化列表：

class A
 {
  public:
   A() {
     try {
       // some code that could throw int
       cout << "in costr
"; throw 10;}
     }//try closed
     catch (int a) {
       cout << "caught 1 
";
     }
   }
   explicit A(int i) try : functionThatCanThow(i) catch (int)
   { }

 };

main()
{
   A *ptr = new A;
   A* ptr2 = new A(5);
}

另一答案

你的意思是这样的：

#include <iostream>

class A
{
    public:
        A() 
        {   
            std::cout << "in costr
";

            // An exception
            // of type `int`
            throw int(10); 
        }   
};

int main()
{
    // A try block were something may go wrong.
    try 
    {   
        A *ptr = new A;
    }   
    // A try is followed by one or more catch blocks
    // that can be activated if an exception is thrown
    catch (int a)
    {   
        std::cout << "caught 1 
";
    }   
}

另一答案

你必须把尝试和一起抓住......

class A
{
  public:
    A() { cout << "in costr
"; throw 10; }
};

int main()
{
    try
    {
        A* ptr = new A;
    }
    catch (int a)
    {
        cout << "caught " << a << '
';
    }
}

另一答案

要添加答案，如果要在对象构造过程中检查异常，可以考虑这样的构造：

#include <iostream>

using std::cout;

struct Base {
    Base() { 
        cout << "Inside Base()
";
        throw 1;
    }

private: 
    int i_;
};

struct Member {
    Member(int i) : i_(i) { 
        cout << "Inside Member()
";
        throw 2;
    }

private: 
    int i_;
};

struct Derived : Base {
    Derived(int) try : member_(55) { cout << "Inside try{}
"; } catch(int) { cout << "Inside catch()
"; }

private: 
  Member member_;
};

int main() {
    Derived d(0);
    return 0;
}

在这里，看看在进行任何进一步的构造尝试之前如何从基础中捕获，这会导致对象构造失败，同时提供足够的信息。在这种情况下，这是一个简单的例子。在实际情况中，您可能希望将异常传播到调用堆栈而不是吞噬它。