自定义大数类big_int无法通过字符串字面量进行拷贝初始化的问题求助

问题拆解与根因分析 #

首先得揪出你遇到的核心矛盾：

• 你给const char*版本的构造函数加了explicit，这直接禁止了隐式转换——而拷贝初始化语法big_int num2 = "99";本质上需要把字符串字面量（会退化为const char*）隐式转换成big_int临时对象，再拷贝到num2，这一步被explicit死死拦住，所以编译报错。
• 但如果去掉explicit，又会因为同时存在std::string构造函数和赋值运算符，导致编译器在转换场景下找不到唯一匹配的重载，产生歧义。

可行的解决方案 #

下面给你两个实用的方案，既能让拷贝初始化正常工作，又不会引入歧义：

方案1：新增const char*版本的赋值运算符

既然explicit的构造函数挡住了隐式转换，那我们绕个弯——保留构造函数的explicit，给类加一个专门处理const char*的赋值运算符：

#include <string>

class big_int {
private:
    std::string value;
public:
    // 继续保留explicit的const char*构造函数
    explicit big_int(const char* s) { value = s; }
    // 你原来的其他构造函数、赋值重载保持不变
    big_int(){}
    big_int (const big_int& other){ *this = other;}
    big_int (const std::string& s){ value = s;}
    big_int& operator=(const std::string& other) {
        this->value = other;
        return *this;
    }
    big_int& operator=(const big_int& other) {
        if (this != &other)
            this->value = other.value;
        return *this;
    }

    // 新增这一行：const char*版本的赋值运算符
    big_int& operator=(const char* s) {
        this->value = s;
        return *this;
    }
};

std::ostream& operator<<(std::ostream& os, const big_int& other) {
    os << other.value;
    return os;
}

这样big_int num2 = "99";会被编译器解析成：先默认构造num2，再调用新增的operator=(const char*)完成赋值，完美绕开了构造函数的explicit限制。不过要注意，这个方案需要你的类有可用的默认构造函数，如果之前禁用了，得先放开。

方案2：用代理类彻底解决歧义（更优雅的方案）

如果你更在意拷贝初始化的“语义纯粹性”（不想先默认构造再赋值），可以用一个轻量的代理类做中间层，彻底避免转换歧义：

#include <string>

// 先定义一个代理类，专门承接const char*的隐式转换
class BigIntProxy {
private:
    const char* raw_str;
public:
    BigIntProxy(const char* s) : raw_str(s) {}
    // 只给big_int开放访问权限
    friend class big_int;
};

class big_int {
private:
    std::string value;
public:
    // 保留所有原来的构造函数，包括explicit的const char*版本
    big_int(){}
    big_int (const big_int& other){ *this = other;}
    explicit big_int (const char* s){ value = s;}
    big_int (const std::string& s){ value = s;}

    // 新增接收代理类的构造函数
    big_int(const BigIntProxy& proxy) {
        value = proxy.raw_str;
    }

    // 顺便给代理类加个赋值运算符，覆盖所有场景
    big_int& operator=(const BigIntProxy& proxy) {
        value = proxy.raw_str;
        return *this;
    }

    // 你的其他运算符重载保持不变...
};

std::ostream& operator<<(std::ostream& os, const big_int& other) {
    os << other.value;
    return os;
}

代理类的作用是：当编译器看到"99"时，会先隐式转换成BigIntProxy（这个转换无歧义，因为代理类只有一个const char*构造函数），然后big_int通过代理类的构造函数完成初始化，完美避开了std::string带来的重载冲突。

验证效果 #

不管用哪个方案，你都能正常运行big_int num2 = "99";，同时原来的直接构造方式big_int str_num("45569");也完全不受影响，而且不会出现编译歧义。

内容来源于stack exchange