如何定义my_int类使int可隐式转为std::complex<my_int>（拷贝初始化）

首先，我们来拆解为什么std::complex<my_int> ci = 4;无法编译，而std::complex<my_int> ci(4);却能正常运行：

C++的隐式转换规则有个关键限制：一次隐式转换序列里最多只能包含一次用户定义的转换（比如类的构造函数或转换运算符）。在拷贝初始化场景下：

• 要把int转成std::complex<my_int>，需要先通过my_int(int)构造函数把int转为my_int（第一次用户定义转换），再通过std::complex<T>的构造函数把my_int转为std::complex<my_int>（第二次用户定义转换）。两次转换违反了规则，所以编译失败。
• 而直接初始化ci(4)时，是直接调用std::complex<my_int>的构造函数，仅需要把int隐式转为my_int这一次用户定义转换，完全符合规则，因此可以正常编译。

最优解决方案：特化std::complex<my_int>添加直接接受int的构造函数 #

我们可以通过特化标准库的std::complex模板，为my_int类型添加直接接受int参数的构造函数，这样就不需要两次用户定义转换，拷贝初始化就能正常工作了。

修改后的完整代码如下：

#include <iostream>
#include <complex>

struct my_int {
    my_int() : _i(0) {}
    my_int(const my_int& mi) : _i(mi._i) {}
    my_int(int i) : _i(i) {}
    operator int(){return _i;}
    int _i;
};

// 特化std::complex<my_int>，添加直接处理int的构造逻辑
namespace std {
template<>
class complex<my_int> {
private:
    my_int re_, im_;
public:
    // 保留原有的基础构造函数
    constexpr complex() : re_(0), im_(0) {}
    constexpr complex(const my_int& re) : re_(re), im_(0) {}
    constexpr complex(const my_int& re, const my_int& im) : re_(re), im_(im) {}
    // 添加直接接受int的构造函数，跳过中间转换
    constexpr complex(int re) : re_(re), im_(0) {}
    constexpr complex(int re, int im) : re_(re), im_(im) {}
    // 默认拷贝构造与赋值
    constexpr complex(const complex& other) = default;
    complex& operator=(const complex& other) = default;

    // 提供real()和imag()方法，用于输出逻辑
    my_int real() const { return re_; }
    my_int imag() const { return im_; }
};
}

// 更新输出运算符，适配特化后的complex<my_int>
std::ostream& operator<<(std::ostream& os, const std::complex<my_int>& ci) {
    os << "(" << ci.real()._i << "," << ci.imag()._i << ")";
    return os;
}

std::ostream& operator<<(std::ostream& os, const my_int& mi) {
    os << mi._i;
    return os;
}

int main() {
    std::complex<my_int> ci = 4; // 现在可以正常编译运行
    std::cout << ci << std::endl;
    
    std::complex<my_int> ci2 = {4, 5}; // 也支持列表初始化
    std::cout << ci2 << std::endl;
}

简化替代方案：使用辅助函数（避免特化标准库） #

如果你不想特化标准库模板，可以写一个轻量的辅助函数来生成目标对象，同样能达到简洁初始化的效果：

inline std::complex<my_int> make_complex(int re, int im = 0) {
    return std::complex<my_int>(my_int(re), my_int(im));
}

// 使用方式
int main() {
    auto ci = make_complex(4); // 语法接近拷贝初始化
    std::cout << ci << std::endl;
}

第一种特化方案更贴合你想要的“直接用=4完成拷贝初始化”的需求，而辅助函数则是更轻量化的替代选项。

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