我看到很多例子，但我无法理解，如何使用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;
}
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块是如何完整的并且在构造函数中。
function try blocks解决了构造函数中提出的异常问题：
class A
{
public:
A()
try
{ cout << "in costr\n"; 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\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);
}
你的意思是这样的：
#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";
}
}
你必须把尝试和一起抓住......
class A
{
public:
A() { cout << "in costr\n"; throw 10; }
};
int main()
{
try
{
A* ptr = new A;
}
catch (int a)
{
cout << "caught " << a << '\n';
}
}
要添加答案，如果要在对象构造过程中检查异常，可以考虑这样的构造：
#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;
}
在这里，看看在进行任何进一步的构造尝试之前如何从基础中捕获，这会导致对象构造失败，同时提供足够的信息。在这种情况下，这是一个简单的例子。在实际情况中，您可能希望将异常传播到调用堆栈而不是吞噬它。