如何在含自定义构造函数的C++结构体中使用指定初始化语法？

问题背景 #

你有一个大型结构体，已自定义拷贝构造函数、移动构造函数、拷贝赋值运算符和移动赋值运算符，但需要在部分场景下使用指定初始化语法仅初始化少数字段，其余字段保留默认值。但一旦为结构体添加自定义构造函数（包括默认构造），就无法再使用指定初始化——因为指定初始化是聚合类型的专属特性，而包含用户自定义构造函数的结构体不再属于聚合类型。

例如，无自定义构造时可正常使用指定初始化：

struct SA_t {
    int a;
    int b;
    int c;
};

int main() {
    SA_t sa1 { .a = 2, .b = 3 }; // 正常运行，c未初始化（若需默认值可加成员初始化器）
    return 0;
}

添加自定义默认构造后，指定初始化失效：

struct SA_t {
    SA_t() {
        a = 0;
        b = 1;
        c = 2;
    };

    int a;
    int b;
    int c;

    // 自定义拷贝、移动构造与赋值...
};

int main() {
    SA_t sa1 { .a = 2, .b = 3 }; // 编译错误：无匹配的构造函数
    return 0;
}

解决方案 #

针对需求，有三种可行方案：

方案一：用默认成员初始化替代自定义默认构造（优先推荐，若允许） #

如果你的自定义拷贝、移动构造/赋值逻辑可通过编译器默认生成实现，可去掉自定义默认构造函数，改用默认成员初始化器设置字段默认值。此时结构体仍为聚合类型，可正常使用指定初始化：

struct SA_t {
    // 默认成员初始化器，设置各字段默认值
    int a = 0;
    int b = 1;
    int c = 2;

    // 默认生成拷贝、移动构造与赋值（若需自定义逻辑则此方案不适用）
    SA_t(const SA_t&) = default;
    SA_t(SA_t&&) noexcept = default;
    SA_t& operator=(const SA_t&) = default;
    SA_t& operator=(SA_t&&) noexcept = default;
};

int main() {
    SA_t sa1 { .a = 2, .b = 3 }; // c自动保留默认值2
    return 0;
}

方案二：引入中间聚合结构体适配指定初始化 #

若必须保留自定义的拷贝、移动构造/赋值逻辑，可定义一个仅包含字段和默认值的中间聚合结构体，通过转换构造函数将其转换为目标结构体：

// 中间聚合结构体，仅用于指定初始化
struct SA_Init {
    int a = 0;
    int b = 1;
    int c = 2;
};

struct SA_t {
    // 从中间结构体转换构造
    SA_t(const SA_Init& init) : data(init) {}
    SA_t(SA_Init&& init) noexcept : data(std::move(init)) {}

    // 自定义拷贝构造
    SA_t(const SA_t& other) {
        // 你的自定义拷贝逻辑，例如：
        data = other.data;
        // 额外操作...
    }

    // 自定义移动构造
    SA_t(SA_t&& other) noexcept {
        data = std::move(other.data);
        // 额外操作...
    }

    // 自定义拷贝赋值
    SA_t& operator=(const SA_t& other) {
        if (this != &other) {
            data = other.data;
            // 额外操作...
        }
        return *this;
    }

    // 自定义移动赋值
    SA_t& operator=(SA_t&& other) noexcept {
        if (this != &other) {
            data = std::move(other.data);
            // 额外操作...
        }
        return *this;
    }

    // 提供字段访问接口（或直接将data设为public，按需选择）
    int& a() { return data.a; }
    const int& a() const { return data.a; }
    int& b() { return data.b; }
    const int& b() const { return data.b; }
    int& c() { return data.c; }
    const int& c() const { return data.c; }

private:
    SA_Init data;
};

int main() {
    // 通过中间结构体实现指定初始化效果
    SA_t sa1(SA_Init{ .a = 2, .b = 3 });
    return 0;
}

方案三：用std::optional模拟指定初始化效果 #

若不想引入中间结构体，可编写接受std::optional参数的构造函数，模拟指定初始化的“按需赋值”效果：

#include <optional>

struct SA_t {
    // 模拟指定初始化的构造函数
    SA_t(std::optional<int> a = std::nullopt, std::optional<int> b = std::nullopt, std::optional<int> c = std::nullopt) {
        this->a = a.value_or(0); // 未指定则用默认值0
        this->b = b.value_or(1);
        this->c = c.value_or(2);
    }

    // 自定义拷贝、移动构造与赋值
    SA_t(const SA_t&) { /* 自定义逻辑 */ }
    SA_t(SA_t&&) noexcept { /* 自定义逻辑 */ }
    SA_t& operator=(const SA_t&) { /* 自定义逻辑 */ return *this; }
    SA_t& operator=(SA_t&&) noexcept { /* 自定义逻辑 */ return *this; }

    int a;
    int b;
    int c;
};

int main() {
    // 用指定初始化语法传递参数（本质是聚合初始化匹配构造函数参数）
    SA_t sa1{.a=2, .b=3};
    return 0;
}

注意：此方案依赖C17及以上的std::optional，若使用C11/14可自行实现简易的可选类型。

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