Because of this, code compiled with C++ compiler A cannot talk to code compiled with C++ compiler B. And compiler vendor A could change their mind between versions, changing things again, so you can't even use code compiled with different compilers from the same vendor.
This is an over-generalization. Again, COM interfaces are quite frequently implemented as C++ classes and work quite well across compilers on Windows. You can get a pointer to a COM object implemented as a MSVC C++ class and directly invoke a member function on it from BCB compiled C++ program and vice versa. You can't freely inter-operate between compilers (in fact, interface classes whose arguments are only primitive and pointer types is about the only C++ feature that works reliably), but that's different from saying it can't work at all.
In comparison, C defines a standard binary layout for its structs, arrays, and the like, as well as things like not mangling function names. Because of this, C code compiled with any compiler, can talk to C code compiled by any other compiler.
Actually, it doesn't. In particular, primitives don't have set sizes (only minimum sizes) and structs may have vendor specific padding between members. It's also entirely possible for one compiler for a given platform to have primitive types with sizes unavailable to some other compilers on the same platform (historically common with 64-bit and 128-bit types). There's also the fun realm of incompatible vendor specific calling conventions (ex: Microsoft C, Turbo C and Watcom C all defined a __fastcall convention but each used a different number of registers). For that matter, some vendors just never bothered implementing broad parts of C99, so any features from that aren't guaranteed to be portable. Usually the only ones that cause problems for library interfaces are flexible array members and the _Bool type.
Functions must be defined under C-type calling convention, cannot have any overrides, and cannot be members of structs. Classes cannot be exposed.
Actually, on x86 Windows most cross-compiler code seems to use the Pascal calling convention (arguments passed left to right with callee cleanup) rather than C calling conventions (arguments passed right to left with caller cleanup). In particular, almost every Win32 API function uses the Pascal calling convention. And again, in COM, C++ interface classes are frequently exposed.