C++ 在初始值设定项列表中查找哪个成员引发了异常

假设我有一个类，包含一些类型的成员。我知道带有初始值设定项列表的

try-catch

块的语法如下

template<int N>
struct Member
{
    Member()
    {
        std::cout << "Default constructor of Member " << N << std::endl;
    }
};

class A 
{
    Member<1> m1;
    Member<2> m2;
    // n members 
public:
A() try
    : m1()
    , m2()
    {
        // constructor implementation
    }
    catch (std::exception const & e)
    {
               // ... cleanup 
        throw; // and rethrow
    }
};

模板
结构成员
{
成员（）
{
std:：cout您可以跟踪初始化过程

class A 
{
    Member<1> m1;
    bool m1threw = true;
    Member<2> m2;
    bool m2threw = true;
    // n members 
public:
A() try
    : m1()
    , m1threw(false)
    , m2()
    , m2threw(false)
    {
        // constructor implementation
    }
    catch (std::exception const & e)
    {
               // ... cleanup 
        if (m1threw) {
            // 
        }
        else if (m2threw) {

        }
        throw; // and rethrow
    }
};

A类
{
成员m1；
bool=true；
成员m2；
bool=true；
//n成员
公众：
试试看
：m1（）
，m1（假）
，m2（）
，m2（假）
{
//构造函数实现
}
捕获（标准：：异常常量和e）
{
//…清理
如果（m1）{
// 
}
否则，如果（m2）{
}
抛出；//并重新抛出
}
};

注意类内初始化仅在c++11中有效。使您的示例更复杂的是，成员变量是默认构造的。如果它们的构造函数接受参数，这将与

我为成员提供了一个非默认构造函数来展示构造跟踪器习惯用法的示例

template<int N>
struct Member
{
    Member(int some_arg) 
    {
        std::cout << "Non default constructor of Meber " << N << std::endl;
    }
};

class A 
{
    Member<1> m1;
    Member<2> m2;
   enum TrackerType { NONE, ONE, TWO };
public:
   A(TrackerType tracker = NONE)
   try    // A constructor try block.
     : m1((tracker = ONE, 1)) // Can throw std::exception
     , m2((tracker = TWO, 1)) // Can throw std::exception
     {
         //TODO:
     }
   catch (std::exception const & e)
     {
        if (tracker == ONE) {
           std::cout << "m1 threw: " << e.what() << std::endl;
        }
        else if (tracker == TWO) {
           std::cout << "m2 threw: " << e.what() << std::endl;
        }
        throw;
     }
};

模板
结构成员
{
成员（int some_arg）
{
std:：cout
模板
结构成员
{
成员（）
{
STD:：这个标准C++ C++成员构造函数是如何使用一个参数的，并且有两个提供的（我可以看到它在链接和C++习语页中编译，但是它看起来很奇怪）@ PeterP只有一个参数通过。表达式“<代码>，<代码> >计算到最后的子表达式（数字1）因此，我们用括号将其括起来（如果我必须选择一个“奇怪”的部分，它将是
TrackerType tracker
的声明/初始化）。
template<int N>
struct Member
{
    Member()
    {
        std::cout << "Default constructor of Member " << N << std::endl;
        // ...
        if (bad_thing)
        {
            throw N;
        }
    }
};

class A 
{
    Member<1> m1;
    Member<2> m2;
    // n members 
public:
A() try
    : m1()
    , m2()
    {
        // ...
    }
    catch (int N)
    {
        std::cout << "construction of member " << N << " failed" << std::endl;
        // ...
    }
};