如何区分C++构造函数初始化列表中抛出的同一类型异常？

在构造函数体内初始化成员时，我们可以为每个成员的初始化代码单独添加try-catch块，分别捕获并处理不同成员的分配异常，示例如下：

#include <memory>

struct A {
   std::unique_ptr<int[]> data1, data2;
   A();
};

A::A()
{
   try {
       data1 = new int[5];
   }
   catch (std::bad_alloc& ex) {
       /* 处理data1分配失败 */
   }
   try {
       data2 = new int[5];
   }
   catch (std::bad_alloc& ex) {
       /* 处理data2分配失败 */
   }
}

但如果直接使用构造函数初始化列表初始化成员，外层的try-catch无法区分抛出的bad_alloc来自哪个成员的分配操作：

#include <memory>

struct A {
   std::unique_ptr<int[]> data1, data2;
   A();
};

A::A()
try : data1{new int[5]},
      data2{new int[5]}
{
}
catch (std::bad_alloc& ex) {
       /* 无法区分是data1还是data2分配失败 */
}

要解决这个问题，有几种可行的方案：

方案1：封装带标识的分配函数，抛出自定义异常 #

为每个成员的分配逻辑封装辅助函数，在函数内捕获bad_alloc并抛出携带成员标识的自定义异常，这样在构造函数的catch块里就能明确区分异常来源：

#include <memory>
#include <stdexcept>
#include <string>

// 自定义异常类，携带成员名称信息
struct MemberAllocFailure : public std::bad_alloc {
    std::string member;
    MemberAllocFailure(const std::string& name) : member(name) {}
    const char* what() const noexcept override {
        return member.c_str();
    }
};

// 通用分配辅助函数
template<typename T>
std::unique_ptr<T[]> allocate_for_member(const std::string& member_name, size_t count) {
    try {
        return std::unique_ptr<T[]>(new T[count]);
    } catch (const std::bad_alloc&) {
        throw MemberAllocFailure(member_name);
    }
}

struct A {
    std::unique_ptr<int[]> data1, data2;
    A();
};

A::A() try : 
    data1(allocate_for_member<int>("data1", 5)),
    data2(allocate_for_member<int>("data2", 5))
{
} catch (const MemberAllocFailure& ex) {
    if (ex.member == "data1") {
        // 处理data1内存分配失败的逻辑
    } else if (ex.member == "data2") {
        // 处理data2内存分配失败的逻辑
    }
}

方案2：拆分初始化步骤，混合初始化列表与构造函数体内捕获 #

如果成员支持赋值操作（比如std::unique_ptr），可以先在初始化列表初始化部分成员，剩下的在构造函数体内用单独的try-catch块初始化，这样能明确区分异常来源：

#include <memory>

struct A {
    std::unique_ptr<int[]> data1, data2;
    A();
};

A::A() try : data1(new int[5]) {
    // 初始化列表完成data1的初始化，异常会被外层catch捕获
    try {
        data2 = new int[5];
    } catch (const std::bad_alloc&) {
        // 这里的异常肯定来自data2的分配
        // 处理data2分配失败，此时data1已成功初始化
    }
} catch (const std::bad_alloc&) {
    // 这里的异常来自data1的分配
    // 处理data1分配失败，此时data2未被初始化
}

方案3：使用可选类型延迟初始化（C++17+） #

利用std::optional包装成员，先默认初始化optional，再在构造函数体内逐个初始化并捕获异常，这种方式适合对初始化顺序有灵活需求的场景：

#include <memory>
#include <optional>

struct A {
    std::optional<std::unique_ptr<int[]>> data1, data2;
    A();
};

A::A() {
    try {
        data1 = std::unique_ptr<int[]>(new int[5]);
    } catch (const std::bad_alloc&) {
        // 处理data1分配失败
    }

    try {
        data2 = std::unique_ptr<int[]>(new int[5]);
    } catch (const std::bad_alloc&) {
        // 处理data2分配失败
    }

    // 后续可以检查optional是否有值，确保成员状态合法
}

内容的提问来源于stack exchange，提问作者francesco