Я бы предпочел одну неявную последовательность преобразования другой. У меня есть следующий (очень упрощенный) класс и функции:
class Whatever {...}
template <class T>
class ref
{
public:
operator T* ()
{
return object;
}
operator T& ()
{
return *object;
}
T* object;
...
};
void f (Whatever*)
{
cout << "f (Whatever*)" << endl;
}
void f (Whatever&)
{
cout << "f (Whatever&") << endl;
}
int main (int argc, char* argv[])
{
ref<Whatever> whatever = ...;
f(whatever);
}
Когда у меня есть объект ref, и я делаю неоднозначный вызов f, я бы хотел, чтобы компилятор выбрал тот, который включает T &. Но в других однозначных случаях я бы хотел, чтобы неявное преобразование оставалось таким же.
До сих пор я пытался представить промежуточный класс, в который ref неявно преобразуется и который имеет оператор неявного преобразования в T *, поэтому последовательность преобразования будет более длинной. К сожалению, он не признал в однозначных случаях, что он действительно конвертируется в T *. То же самое произошло, когда промежуточный класс имел (неявный) конструктор. Неудивительно, что эта версия была совершенно не связана с ref.
Я также пытался создать один из шаблонов операторов неявного преобразования, тот же результат.