C++ 为什么要称之为<<&引用；运算符作为函数导致；不明确的呼叫”；编译器错误？

为什么第一个代码段工作正常，但第二个代码段会导致不明确的调用错误？为什么编译器不能解决第二种情况下的函数重载

片段1：

int main() {
    int x = 1234;
    std::cout << x;
}

intmain（）{
int x=1234；
std:：cout您试图调用一个成员函数（属于
std:：cout
），就好像它是一个自由函数一样：

这种歧义可能来自多个匹配，所有这些匹配都涉及某种类型的转换，其中没有一种是可取的。编译器错误可能会给您一些可怕的不可能读取的可能匹配列表，所有这些似乎都不相关


对于运算符，请将其称为运算符，而不是函数！将运算符定义为成员是有充分理由的，将其定义为自由函数也是有充分理由的。您不必在意在任何特定情况下使用哪种运算符

如果我想创建自己的支持
+
的类型，我可能有很好的技术理由选择一种方法而不是另一种方法，甚至在库的未来版本中改变主意。您是否介意我选择哪种方法


请注意
运算符，因为整数没有全局（或非成员）。它是：

std:：cout.operator运算符是一个非静态成员函数，因此可以使用
发件人：

#包括
int main（）{
int x=1234；
标准：：计算运算符来自：

prog.cc:在函数“int main（）”中：
程序cc:11:10:错误：重载“foo（int）”的调用不明确
傅(1),


但这段代码运行良好，这正是我的观点！你不应该（不应该）知道或关心它何时是成员函数，何时是自由函数。谢谢你的回答。我不明白的是为什么编译器能够确定
谢谢你的回答，但为什么编译器知道我的意思是
std:：cout。operator@KeyBored因为这就是运算符重载与运算符的成员内重载的工作方式。如果

int main() {
    int x = 1234;
    operator<<(std::cout, x);
}

std::cout.operator<<(x);

#include <iostream>

int main() {
    int x = 1234;
    std::cout.operator<<(x);
}

template< class Traits >
basic_ostream<char,Traits>& operator<<( basic_ostream<char,Traits>& os,
                                        char ch );

template< class Traits >
basic_ostream<char,Traits>& operator<<( basic_ostream<char,Traits>& os,
                                        signed char ch );

#include <iostream>
void foo(char a)
{

}
void foo(signed char b)
{

}
int main() {
    foo(1);
}

const char* z = "char*";  // OK 
const signed char* x = "signed char*";  // invalid conversion from ‘const char*’ to ‘const signed char*’ 
const unsigned char y = "unsigned char*"; // invalid conversion from ‘const char*’ to ‘unsigned char’