docs/程序语言/C++/现代C++/源码阅读/雅兰亭库/C++无宏反射研究/细节研究

[giscus[bot]]

docs/程序语言/C++/现代C++/源码阅读/雅兰亭库/C++无宏反射研究/细节研究

一、判断成员个数

https://hengxin666.github.io/HXLoLi/docs/%E7%A8%8B%E5%BA%8F%E8%AF%AD%E8%A8%80/C++/%E7%8E%B0%E4%BB%A3C++/%E6%BA%90%E7%A0%81%E9%98%85%E8%AF%BB/%E9%9B%85%E5%85%B0%E4%BA%AD%E5%BA%93/C++%E6%97%A0%E5%AE%8F%E5%8F%8D%E5%B0%84%E7%A0%94%E7%A9%B6/%E7%BB%86%E8%8A%82%E7%A0%94%E7%A9%B6

[HengXin666]

哥哥, 有空实验一下:

template <typename T, typename U, typename... Args>
constexpr bool IsConstructibleVal = requires {
    T {Args{Args{}}..., U{U{}}};
};

似乎没有那么稀烂... 而且和:

template <typename T, typename U, typename... Args>
constexpr bool IsConstructibleVal = requires {
    T {{Args{}}..., {U{}}};
};

的效果在极个别情况不同!

[HengXin666]

错误的，实际上会生成但是：
编译器发现:

1. Emp 是聚合类 => 尝试使用聚合初始化 => 因为没有成员, 即 > 成员个数. 失败.
2. 不会继续尝试 拷贝、移动构造, 因为他们是不同的路径？？？还是因为匹配成为初始化列表了？？？
3. 那为什么显示定义构造就没事了？？？

• https://godbolt.org/z/74KWbW3aY （疑似全部优化了，应该是走移动构造的才对；至少不应该是Any -> A）

[HengXin666]

• https://godbolt.org/z/8ccfhvjEE, 进一步研究, 查看 Emp e3{Any{}}; // err, 都很微妙?

struct Any {
    /// @brief 万能类型转换运算符, 只用于模版判断
    template <typename T>
    operator T() {
        return T{};
    }
};

struct Emp {
    // Emp() = default; // [A]
    
    // Emp& operator=(Emp&&) = default; // [B] 毫无作用
    
    // Emp(Emp&&) = default; // [C] 实际上期望调用的, 但是这样会屏蔽 [A], 
    //                       // 需要开启 [A], 但可以不开启 [C]
};

struct One { char str[8]; };

struct Test { Emp _emp; };
struct Test2 { One _one; };

int main() {
    Emp e1{ Emp {Emp{}} }; // ok
    // Emp e2{ /* Emp */ {Emp{}} }; // err, 如果注释掉 [A + C]
    // Emp e3{Any{}}; // err, 但是 operator T 不是 explicit 的啊
    Emp e4 = Any{};

    Test t1{}; // ok
    Test t2{{}}; // ok

    Test2 ok{{Any{}}}; // ok (对比)
    // Test t3{{Any{}}}; // err, 如果注释掉 [A]
    Test t4{Any{Any{}}}; // ok
}

[HengXin666]

编译器的处理流程是：

1. 检查目标类型是否是聚合类型

   • 聚合类型定义：没有用户自定义构造函数、没有 private/protected 成员、没有虚函数等。
   • Emp 和 Test 都是聚合类型。

2. 使用 braced-init-list 初始化聚合

   • 对聚合类型 {a,b,c} 的规则是：逐成员初始化。

   • 每个成员使用 直接列表初始化（direct-list-initialization）：

     • T x{y};，其中 T 是成员类型，y 是花括号里的元素。
     • 对成员的初始化 不会尝试隐式转换（比如拷贝构造或移动构造）。

3. 直接列表初始化 vs 拷贝/移动构造

   • 对于非聚合类型，T x{y}; 可能会调用：

     • 构造函数（包括 explicit 和 non-explicit）
     • 拷贝或移动构造

   • 对于聚合类型，列表初始化 忽略构造函数（因为聚合类型没有用户自定义构造函数），直接尝试用 {} 初始化每个成员。

   • 成员初始化阶段不会走隐式转换，所以 Any{} → Emp 的模板 operator 不会被考虑。

[HengXin666]

有说法是说:

#include <type_traits>
#include <utility>

// 原始万能类型
struct Any {
    template <typename T>
    operator T() const {
        return T{};
    }
};

// 聚合初始化辅助函数
template <typename T, typename... Args>
T makeAggregate(Args&&... args) {
    static_assert(std::is_aggregate_v<T>, "T must be an aggregate type");
    return T{std::forward<Args>(args)...};
}

// 测试类型
struct Emp { };

struct One { char str[8]; };

struct Test { Emp _emp; };
struct Test2 { One _one; };

Emp makeEmp() { return {}; }

int main() {
    // 普通类型
    Emp e1 = Any{};           // ok, 拷贝/隐式转换
    Emp e2{makeEmp()};        // ok

    // 聚合类型
    Test t1 = makeAggregate<Test>(Any{});       // ok
    Test t2 = makeAggregate<Test>(makeEmp());   // ok

    Test2 t3 = makeAggregate<Test2>(Any{});    // ok, 对数组成员也适用
    Test2 t4 = makeAggregate<Test2>(One{});    // ok

    // 可以直接嵌套
    Test t5 = makeAggregate<Test>(Any{Any{}}); // ok
}

[HengXin666]

不行的，这个是无解的，用户自己明确定义一个吧