1，来看下面这段代码：

#include <iostream>
using namespace std;

class BaseClass
{
public:
    BaseClass()
    {

    }
};
class MyClass : public BaseClass
{
private:
    char *ptr;
public:
    MyClass();
};

MyClass::MyClass():BaseClass(), ptr(new char[10])
{

}

int main()
{
    MyClass c1;
    return 0;
}

     假设在MyClass的构造函数中需要处理内存分配错误，也就是new char[10]出错，它会抛出std::bad_alloc异常，那么应该怎么捕获它呢？想必也只能将其移到构造函数体内：

MyClass::MyClass() : BaseClass()
{
    try
    {
        ptr = new char[10];
    }
    catch (const bad_alloc& ex)
    {
    }
}

     如果BaseClass的构造函数也抛出异常的话，这样还是有问题的。这就是引入function-try-block的原因，通过它我们可以将try/catch的处理代码放在构造函数中初始化列表的周围，也就能够捕获由基类或成员变量构造函数抛出的任何异常了。

#include <iostream>
using namespace std;

class BaseClass
{
public:
    BaseClass()
    {

    }
};
class MyClass : public BaseClass
{
private:
    char *ptr;
public:
    MyClass();
};

MyClass::MyClass()
try : BaseClass(), ptr(new char[10])
{
    cout << "构造函数中" << endl;
    throw "error";
}
catch(const string& ex)
{
    cout << "异常处理中" << endl;
}

int main()
{
    MyClass c1;
    return 0;
}

     C++标准规定在构造函数和析构函数中，如果执行到达处理程序的末尾，在function-try-block的处理程序中捕获的异常必须重新抛出。也就意味着上述代码在运行时，会由于有未处理的异常而终止。

      为什么说标准这样规定是必要的呢？因为在捕获一个异常时，对象可能处于无效状态，因此不能允许构造函数成功地完成，否则构造出的对象是不能确保其有效性的。

2，数的累加求和这段代码我们一直都这样写：

int sum = 0;
int x;
while (cin >> x)
{
    sum += x;
}

而可曾想过下面这样的写法更为优雅呢？

int sum = 0;
for (int x; cin >> x;)
{
    sum += x;
}