Question

Lets take some code samples:

! 4 > 0;

From C++ standard we know, that negation will be done first, than comparison. But if we expand this example a little:

#include <iostream>

class Test
{
public:
    bool operator!() const
    {
            std::cout << "operator!" << std::endl;
            return false;
    }

    bool operator>(const int &) const
    {
            std::cout << "operator>" << std::endl;
            return false;
    }
};


int main(int argc, char * argv[])
{
    Test t;
    std::cout << "t > 0;" << std::endl;
    t > 0;
    std::cout << "! t > 0;" << std::endl;
    ! t > 0;
    std::cout << "!t.operator>(0)" << std::endl;
    ! t.operator>(0);

    return 0;
}

Output of this program will be:

t > 0;
operator>
! t > 0;
operator!
!t.operator>(0)
operator>

1. First call (control call) is quite clear. We check if operator we want is called.
2. Second call is proof of what I stated first. negation operator is called first, than on result (bool) operator> is called.
3. Third call is what bothers me.

And here pops my question. Why SomeObjInstance > 0 call is different from SomeObjInstance.operator>(0). I know that it’s not common to call operators in second manner (as members), but why this calls differs? I always tought that SomeObjInstance > 0 is translated under the hood to member call SomeObjInstance.operator>(0) or function call bool operator>(const Test &, int) if member operator is not present.

Where this behaviour is described in C++ standard, or maybe is this some kind of undefined behaviour?

Answer 1

The member access operator .* has a higher precedence than the negation operator !.

Where this behaviour is described in C++ standard, or maybe is this some kind of undefined behaviour?

This is most likely the relevant paragraph:

13.5 Overloaded operators [over.oper]

5) Operator functions are usually not called directly; instead they are invoked to evaluate the operators they implement (13.5.1 – 13.5.7). They can be explicitly called, however, using the operator-function-id as the name of the function in the function call syntax (5.2.2).

In your first example t > 0; it will use the according operator with the precedence for the relational comparison operators. However, in your second version t.operator>(0) you use it as a function call. Thereby the Test::operator> is used as a member function, which will result in your described behavior, as it looses its operator characteristics (“they can be explicitly called, however, using the operator-function-id as the name of the function in the function call syntax”).

See also:

• C++ Operator Precedence