C++结构体隐式转换赋值歧义报错问题求解

问题场景 #

定义了一个封装std::variant的value结构体，通过模板转换运算符和赋值运算符实现隐式转换。构造std::string变量时可正常隐式转换，但对已创建的std::string变量赋值该结构体实例时，编译器报operator=歧义错误。

结构体代码 #

#include <string>
#include <variant>

using namespace std;
using val = variant<int, string, double, bool, long, long long, long double>;

struct value
{
    val innerVal;
    value():innerVal(""){}
    value(const val &c) : innerVal(c) {}

    template <typename T>
    operator T()
    {
          return get<T>(innerVal);
    }

    template <typename V>
    value &operator=(const V &t)
    {
        innerVal = t;
        return *this;
    }
};

测试代码 #

int main(int argc, char* argv[])
{
    value h;
    h = "String";
    string m = h;// 此处正常
     string b = "different";
     b = h;// 此处报错
}

编译错误 #

use of overloaded operator '=' is 
ambiguous (with operand types 
'std::__ndk1::string' (aka 
'basic_string<char, char_traits<char>, 
allocator<char> >') and 'value')

        b = h;

原因分析 #

问题根源在于模板转换运算符operator T()没有约束，编译器会尝试为所有可能的T生成转换运算符，即使T不是val的备选类型。在处理b = h时：

• 编译器可以将h转换为std::string，匹配string& operator=(const string&)
• 同时会尝试其他转换路径（比如转换为const char*、bool等），这些转换在运行时会失败，但编译阶段会被视为可行候选，导致重载决议出现歧义。

而构造string m = h时，重载决议仅匹配std::string的构造函数，候选范围更窄，因此无歧义。

解决方案 #

给模板转换运算符添加SFINAE约束，仅允许转换为val的备选类型，同时将转换运算符改为const（支持const对象转换，且符合转换操作不修改对象的语义）。

C++20 版本（简洁写法） #

#include <string>
#include <variant>
#include <type_traits>

using namespace std;
using val = variant<int, string, double, bool, long, long long, long double>;

struct value
{
    val innerVal;
    value():innerVal(""){}
    value(const val &c) : innerVal(c) {}

    // 仅当T是val的备选类型时启用转换运算符
    template <typename T>
    operator T() const
    requires std::is_one_of_v<T, int, string, double, bool, long, long long, long double>
    {
          return get<T>(innerVal);
    }

    template <typename V>
    value &operator=(const V &t)
    {
        innerVal = t;
        return *this;
    }
};

C++17 版本（兼容旧标准） #

#include <string>
#include <variant>
#include <type_traits>

using namespace std;
using val = variant<int, string, double, bool, long, long long, long double>;

struct value
{
    val innerVal;
    value():innerVal(""){}
    value(const val &c) : innerVal(c) {}

    // 用enable_if+disjunction约束转换类型
    template <typename T, typename = enable_if_t<
        disjunction_v<
            is_same<T, int>,
            is_same<T, string>,
            is_same<T, double>,
            is_same<T, bool>,
            is_same<T, long>,
            is_same<T, long long>,
            is_same<T, long double>
        >
    >>
    operator T() const
    {
          return get<T>(innerVal);
    }

    template <typename V>
    value &operator=(const V &t)
    {
        innerVal = t;
        return *this;
    }
};

修改后，b = h将只会匹配string& operator=(const string&)，消除歧义，编译正常通过。

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