Question

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

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

 };

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

此程序提供编译错误
如果发现异常，对象会发生什么？

Answer 1

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

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

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

#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 << '\n';
        return -1;
    }
    std::cout << "Value: " << ptr->getA() << '\n';
    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 << '\n';
                throw;
            }
        }
        int getA() {return a;}
};

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

给你：

Exception A: 42
Exception B: 42

注意具体 try/catch块如何完整以及在构造函数中。

Answer 2

构造函数期间引发的异常问题由function try blocks解决：

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

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

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

Answer 3

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

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

 };

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

Answer 4

你的意思是这样的：

#include <iostream>

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

            // 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 \n";
    }   
}

Answer 5

你必须把try和catch放在一起......

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

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

Answer 6

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

#include <iostream>

using std::cout;

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

private: 
    int i_;
};

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

private: 
    int i_;
};

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

private: 
  Member member_;
};

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

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

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

6 个答案: