有没有办法在gcc / g ++中强制函数解析优先级？

Question

It's easy to understand why we cannot say:

template<class A> class foo 
{
     //stuff
     A& operator[](size_type n);
     operator A*();
     //more stuff
 };

somefooinstance[bar];

... We get back "ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for second."

What this means, of course, is that gcc doesn't know if we mean:

somefooinstance.operator[](bar);

or we mean:

(static_cast<A*>(somefooinstance))[bar];

Now, ISO C++ says all conversions must be considered, yes? But is there no way to force a selection priority? attribute doesn't seem to offer anything helpful.

(Please, no "what are you really trying to do?" answers. Yes, this is a canned example. Uncle Sam doesn't want me cutting and pasting code.)

EDIT:

Someone wanted to see exact code:

template<class T, unsigned S> class foo
    {
    private:
        T m_bar[S];

    public:
        inline T& operator[](unsigned s)
        {
            return m_bar[s];
        }

        inline operator T*()
        {
            return m_bar; 
        }

    };

    int main(int argc, char** argv)
    {
      foo<int, 100> test;
      test[31] = 6;
    }

yields:

23 : warning: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:

8 : note: candidate 1: T& foo::operator[](unsigned int) [with T = int, unsigned int S = 100u]

23 : note: candidate 2: operator[](int*, int)

... with no -pedantic required.

Sorry about the canned example. What I meant by no cutting and pasting was not only can I actually not copy and paste, I can't explain what I am trying to do because rules and regulations.

Answer 1

In C++11 you can make the conversion operator explicit:

explicit operator A*();

Then it will only be used in cases like static_cast<A*>(somefooinstance) .