why can I not use the dummy parameter in postfix operator++ like someClassObject++5?

Question

I know I can use a dummy int in the postfix operator++ as someClassObject.operator++(5), but why can't use it like someClassObject++5? I am asking this because operator+ can be used like someClassObject1 + someClassObject2.

{
public:

    test(int x, string y) : x(x), y(y){}
    test() :x(0), y("") {};

    //skiping some code for copy constructor and assignment operator overload

    test operator++(int x)
    {
        test a(*this);
        a.x += x;
        ++(*this);
        return a;
    }

    friend ostream& operator<<(ostream& ost, const test& test)
    {
        ost << test.x << " , " << test.y;
        return ost;
    }


    int x;
    string y;
};

int main()
{
    test t1(5, "testing");
    int x = 10;
    cout << t1.operator++(x) << endl;
    //the above line of code works but the line below gives error.
    t1++x;
    return 0;
}

I was expecting both t1.operator++(5) and t1++5 would work in the same way.

Answer 1

Due to the maximal munch rule, the expression

t1++x

is parsed as

t1 ++ x

and grouped as

(t1 ++) x

This makes no sense; rather like t1 x makes no sense.