"неоднозначная перегрузка для оператора []", если оператор преобразования int int существует

Я пытаюсь реализовать оператор типа vector и карту типа TG40 для класса. Но я получаю сообщения об ошибках от моих компиляторов (g++ и клан g++). Выяснилось, что они возникают только в том случае, если в классе есть также операторы преобразования в целочисленные типы.

Теперь у меня две проблемы. Во-первых, я не знаю, почему компилятор не может различить [](const std::string&) и [](size_t), когда в классе есть операторы преобразования в целые. Второе... Мне нужно преобразование и оператор индекса. Как это исправить?

работы:

#include <stdint.h>
#include <string>

struct Foo
{
    Foo& operator[](const std::string &foo) {}
    Foo& operator[](size_t index) {}
};

int main()
{
    Foo f;
    f["foo"];
    f[2];
}

не работает:

#include <stdint.h>
#include <string>

struct Foo
{
    operator uint32_t() {}
    Foo& operator[](const std::string &foo) {}
    Foo& operator[](size_t index) {}
};

int main()
{
    Foo f;
    f["foo"];
    f[2];
}

ошибка компилятора:

main.cpp: In function 'int main()':
main.cpp:14:9: error: ambiguous overload for 'operator[]' in 'f["foo"]'
main.cpp:14:9: note: candidates are:
main.cpp:14:9: note: operator[](long int, const char*) <built-in>
main.cpp:7:7: note: Foo& Foo::operator[](const string&)
main.cpp:8:7: note: Foo& Foo::operator[](size_t) <near match>
main.cpp:8:7: note:   no known conversion for argument 1 from 'const char [4]' to 'size_t {aka long unsigned int}'

Ответ 1

Проблема в том, что ваш класс имеет оператор преобразования до uint32_t, поэтому компилятор не знает, следует ли:

Построить a std::string из строкового литерала и вызвать вашу перегрузку, принимая std::string;
Преобразуйте объект Foo в uint32_t и используйте его как индекс в строковый литерал.

В то время как вариант 2 может казаться запутанным, считайте, что следующее выражение является законным в С++:

1["foo"];

Это связано с тем, как определяется встроенный оператор нижнего индекса. В пункте 8.3.4/6 стандарта С++ 11:

За исключением того, что он был объявлен для класса (13.5.5), индексный оператор [] интерпретируется в таком способ, который E1[E2] идентичен *((E1)+(E2)). Из-за правил преобразования, которые применяются к +, если E1 является array и E2 целое число, то E1[E2] относится к E2 -му члену E1. Поэтому, несмотря на свою асимметричную внешний вид, подписка является коммутативной операцией.

Следовательно, приведенное выше выражение 1["foo"] эквивалентно "foo"[1], которое оценивается как o. Чтобы устранить двусмысленность, вы можете сделать оператор преобразования explicit (в С++ 11):

struct Foo
{
    explicit operator uint32_t() { /* ... */ }
//  ^^^^^^^^
};

Или вы можете оставить этот оператор преобразования как есть, и явно построить объект std::string:

    f[std::string("foo")];
//    ^^^^^^^^^^^^     ^

В качестве альтернативы вы можете добавить дополнительную перегрузку оператора индекса, который принимает const char*, что было бы лучше, чем любое из вышеперечисленных (поскольку оно не требует никакого пользовательского преобразования):

struct Foo
{
    operator uint32_t() { /* ... */ }
    Foo& operator[](const std::string &foo) { /* ... */ }
    Foo& operator[](size_t index) { /* ... */ }
    Foo& operator[](const char* foo) { /* ... */ }
    //              ^^^^^^^^^^^
};

Также обратите внимание, что ваши функции имеют не-void возвращаемый тип, но в настоящее время пропустите инструкцию return. Это вставляет Undefined Поведение в вашу программу.

Ответ 2

Проблема заключается в том, что f["foo"] можно решить как:

Преобразуйте "foo" в std::string (будь то s) и выполните f[s] вызов Foo::operator[](const std::string&).
Преобразовать f в целочисленный вызов Foo::operator int() (be it i) и сделать i["foo"] с помощью известного факта, что встроенный оператор [] является коммутативным.

Оба имеют одно настраиваемое преобразование типа, следовательно, двусмысленность.

Простое решение - добавить еще одну перегрузку:

Foo& operator[](const char *foo) {}

Теперь вызов f["foo"] вызовет новую перегрузку, не требуя какого-либо преобразования настраиваемого типа, поэтому неясность будет нарушена.

ПРИМЕЧАНИЕ. Преобразование из типа char[4] (тип типа "foo") в char* считается тривиальным и не учитывается.

Ответ 3

Как указано в других ответах, ваша проблема заключается в том, что [] коммутирует по умолчанию - a[b] совпадает с b[a] для char const*, а ваш класс может быть конвертирован в uint32_t, это так же хорошо совпадение, когда char* преобразуется в std::string.

То, что я предоставляю здесь, - это способ сделать "чрезвычайно привлекательную перегрузку", когда у вас есть именно такая проблема, когда перегрузка не вызывается, несмотря на то, что вы полагаете, что она должна.

Итак, вот Foo с "чрезвычайно привлекательной перегрузкой" для std::string:

struct Foo
{
  operator uint32_t() {return 1;}
  Foo& lookup_by_string(const std::string &foo) { return *this; }
  Foo& operator[](size_t index) {return *this;}
  template<
    typename String,
    typename=typename std::enable_if<
      std::is_convertible< String, std::string >::value
    >::type
  > Foo& operator[]( String&& str ) {
    return lookup_by_string( std::forward<String>(str) );
  }
};

где мы создаем функцию "поиск по строкам", а затем создаем шаблон, который захватывает любой тип, который может быть преобразован в std::string.

Поскольку он "скрывает" пользовательское преобразование в теле шаблона operator[], при проверке соответствия не происходит никакого преобразования, определенного пользователем, поэтому это предпочтительнее других операций, для которых требуются определенные пользователем преобразования (например, uint32_t[char*]). По сути, это "более привлекательная" перегрузка, чем любая перегрузка, которая точно не соответствует аргументам.

Это может привести к проблемам, если у вас есть другая перегрузка, которая принимает const Bar&, а Bar имеет преобразование в std::string, вышеупомянутая перегрузка может удивить вас и захватить пройденный в Bar - оба rvalues и неконстантные переменные соответствуют вышеуказанной [] сигнатуре лучше, чем [const Bar&]!