Влиять на преобразование как из строки, так и из int из одного класса?

Question

Как я могу иметь неявные операторы преобразования как в строку, так и в int?

Упрощенный код:

#include <iostream>
#include <string>

struct Value
{
    operator std::string() const { return "abc"; }
    operator int() const { return 42; }
};

int main() {
    Value v;

    std::string s;
    s = v;  // error here

    // lines below not really needed
    int i;
    i = v;

    std::cout << s << " " << i << "\n";
}

c ++ 11 или более поздняя версия. Это ошибки, сообщаемые в строке назначения строки.

sandbox/casting_main.cpp: In function ‘int main()’:
sandbox/casting_main.cpp:14:7: error: ambiguous overload for ‘operator=’ (operand types are ‘std::__cxx11::string {aka std::__cxx11::basic_string<char>}’ and ‘Value’)
     s = v;  // error here
       ^
In file included from /usr/include/c++/5/string:52:0,
                 from /usr/include/c++/5/bits/locale_classes.h:40,
                 from /usr/include/c++/5/bits/ios_base.h:41,
                 from /usr/include/c++/5/ios:42,
                 from /usr/include/c++/5/ostream:38,
                 from /usr/include/c++/5/iostream:39,
                 from sandbox/casting_main.cpp:1:
/usr/include/c++/5/bits/basic_string.h:550:7: note: candidate: std::__cxx11::basic_string<_CharT, _Traits, _Alloc>& std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::operator=(const std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>]
       operator=(const basic_string& __str)
       ^
In file included from /usr/include/c++/5/string:52:0,
                 from /usr/include/c++/5/bits/locale_classes.h:40,
                 from /usr/include/c++/5/bits/ios_base.h:41,
                 from /usr/include/c++/5/ios:42,
                 from /usr/include/c++/5/ostream:38,
                 from /usr/include/c++/5/iostream:39,
                 from sandbox/casting_main.cpp:1:
/usr/include/c++/5/bits/basic_string.h:569:7: note: candidate: std::__cxx11::basic_string<_CharT, _Traits, _Alloc>& std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::operator=(_CharT) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>]
       operator=(_CharT __c)
       ^
In file included from /usr/include/c++/5/string:52:0,
                 from /usr/include/c++/5/bits/locale_classes.h:40,
                 from /usr/include/c++/5/bits/ios_base.h:41,
                 from /usr/include/c++/5/ios:42,
                 from /usr/include/c++/5/ostream:38,
                 from /usr/include/c++/5/iostream:39,
                 from sandbox/casting_main.cpp:1:
/usr/include/c++/5/bits/basic_string.h:587:7: note: candidate: std::__cxx11::basic_string<_CharT, _Traits, _Alloc>& std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::operator=(std::__cxx11::basic_string<_CharT, _Traits, _Alloc>&&) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>]
       operator=(basic_string&& __str)
       ^

Очевидно, что в стандарте c ++ 11 есть оператор присваивания basic_string:

basic_string& operator=(charT c);

Этот оператор присваивания вызывает неоднозначность, которую компилятор не может разрешить.

Есть ли способ иметь неявные операторы преобразования в строку и int в одном классе?

Answer 1

Это не красиво, но можно сделать с помощью SFINAE. Мы создаем оператор преобразования шаблона, но ограничиваемся только преобразованием в int или std :: string, а затем используем if constexpr для выполнения правильного поведения.

#include <type_traits>
#include <iostream>
#include <string>

struct Value
{
    template <typename type, typename = std::enable_if_t <std::is_same_v <type, std::string> || std::is_same_v <type, int>>>
    operator type () const {
        if constexpr (std::is_same_v <int, type>)
            return 42;
        else
            return "abc";
    }
};

int main() {
    Value v;

    std::string s;
    s = v;  // error here


    // lines below not really needed
    int i;
    i = v;

    std::cout << s << " " << i << "\n";
}

Answer 2

Если вы посмотрите на класс basic_string, он определяет (среди прочего) следующие три перегрузки для назначения operator=:

// 1. Rvalue reference overload for basic_string
basic_string& operator=(basic_string&& __str);

// 2. Lvalue Reference overload for basic_string
basic_string& operator=(const basic_string& __str);

// 3. Overload for type value_type (set as char, see std::string typedef below)
basic_string& operator=(value_type __c);

value_type определяется следующим образом:

template<class _CharT, class _Traits, class _Allocator>
class _LIBCPP_TEMPLATE_VIS basic_string
    : private __basic_string_common<true>
{
public:
    typedef _CharT                                       value_type;

И std::string определяется как:

typedef basic_string<char, char_traits<char>, allocator<char> > string;

Как видите, _CharT установлено в char в приведенном выше определении типа. Теперь строка с ошибкой:

   s = v;  // error here 

Проблема в том, что для вышеприведенного назначения все три перегрузки операторов типа basic_string совпадают.

Перегрузки 1. и 2. совпадают, поскольку вы определили неявное преобразование из типа Value в std::string. Перегрузка 3. соответствует из-за неявного преобразования из int в char, а тип Value имеет неявное преобразование в int.

И именно из-за этой неоднозначности назначение ошибочно. Я предполагаю, что единственный способ обойти это - удалить одно из неявных преобразований из вашего Value класса.