c++ operator overloading += works but << doesn't work

Question

I expected that += and << will work the same, but << somehow not working.

here is my code:

#include <iostream>

using namespace std;

struct Pos{
    int x;
    int y;

    void operator+=(Pos vel){
        x += vel.x;
        y += vel.y;
    }
};

struct Obj{
    string name;
    Pos pos;

    void info(){
        cout << name << endl;
        cout << pos.x << ", " << pos.y << endl;
        cout << endl;
    }
    void operator<<(Pos vel){
        pos += vel;
    }
    void operator+=(Pos vel){
        pos += vel;
    }
};


int main(){
    Pos p{10, 20};
    Obj car{"Car", p};
    Obj truck{"Big truck", {40, 20}};

    car.info();
    truck.info();

    //doesn't work
    car << {0, 10};
    //works
    car += {5, 10};
    //works
    car << Pos{0, 10};
    //works
    car += Pos{5, 10};

    car.info();
} 

most of them works but car << {0, 10};

It shows:

[Error] expected primary-expression before '{' token

I'm wondering what is the difference between += and << and why using constructor will work.

What am I missing here?

Answer 1

This: {10, 20} is a braced-init-list. It is not an expression. As such, it can appear only in specific pieces of C++ grammar.

For example, braced-init-lists can appear after a typename, which means they initialize a prvalue of that type. They can appear as an argument to a function. And (among several others) they can appear on the right-hand side of an assignment operator.

Note that += is an assignment operator.

<< is not one of these specific places. Therefore, a naked braced-init-list cannot appear on either side of a << expression. This is regardless of the fact that the << expression will be converted into a call to operator<< and thus the braced-init-list could be considered a function argument. C++ grammar simply doesn't allow a braced-init-list to appear there, so the compiler never gets far enough to even attempt overload resolution to figure out which function to call.