Question

I would like to prefer a certain implicit conversion sequence over another. I have the following (greatly simplified) class and functions:

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);
}

When I have a ref object and I am making an ambiguous call to f, I would like the compiler to choose the one involving T&. But in other unambiguous cases I wish the implicit conversion to remain the same.

So far I have tried introducing an intermediate class which ref is implicitly convertible to, and which has an implicit conversion operator to T*, so the conversion sequence would be longer. Unfortunately it did not recognize in unambiguous cases that it is indeed convertible to T*. Same thing happened when the intermediate class had a(n implicit) constructor. It’s no wonder, this version was completely unrelated to ref.

I also tried making one of the implicit conversion operators template, same result.

Answer 1

Simple: define void f(const ref<Whatever>&), it will trump the others which require a conversion.