涉及临时的运算符重载决策的顺序

Question

考虑以下最小示例：

#include <iostream>

using namespace std;

class myostream : public ostream {
    public:
        myostream(ostream const &other) :
            ostream(other.rdbuf())
        { }
};

int main() {
    cout << "hello world" << endl;

    myostream s(cout);
    s << "hello world" << endl;

    myostream(cout) << "hello world" << endl;
}

在 g++ 和 Visual C++ 上的输出都是

hello world
hello world
0x4012a4

写入临时对象 myostream(cout) 的版本似乎更喜欢成员运算符 ostream： :operator<<(void *)，而不是自由运算符 operator<<(ostream &, char *)。对象是否有名称似乎很重要。

为什么会出现这种情况？我该如何防止这种行为？

编辑：现在从各种答案中可以清楚地看出为什么会发生这种情况。至于如何防止这种情况发生，以下内容似乎很有吸引力：

class myostream : public ostream {
    public:
        // ...
        myostream &operator<<(char const *str) {
            std::operator<<(*this, str);
            return *this;
        }
};

然而，这会导致各种含糊不清。

Answer 1

如果一个对象没有名称（即它是一个临时对象），则它不能绑定到非常量引用。具体来说，它不能绑定到以下参数的第一个参数：

operator<<(ostream &, char *)

Answer 2

右值不能绑定到非常量引用。因此，在您的示例中， ostream 类型的临时变量不能是 free 运算符<<(std::ostream&, char const*) 的第一个参数，而使用的是成员运算符<<(void*)。

如果需要，您可以添加一个调用，例如

myostream(cout).flush() << "foo";

将右值转换为引用。

请注意，在 C++0X 中，右值引用的引入将允许提供运算符<< 的重载。以右值引用作为参数，解决问题的根本原因。

Answer 3

我刚刚意识到答案的部分。临时值不是左值，因此不能用作 ostream & 类型的参数。

“我怎样才能完成这项工作”的问题仍然存在......

Answer 4

由于到目前为止，没有一个答案似乎给出了一个干净的解决方案，所以我将接受肮脏的解决方案：

myostream operator<<(myostream stream, char const *str) {
    std::operator<<(stream, str);
    return stream;
}

这只是可能的，因为 myostream 有一个复制构造函数。 （在内部，它由引用计数的 std::stringbuf 支持。）

Answer 5

虽然 C++11 确实解决了这个问题，因为存在右值引用，但我认为这可能是 C++11 之前版本的解决方法。

解决方案是有一个成员函数 <<运算符，我们可以在其中转换为对基类的非常量引用：

class myostream : public ostream {
    public:
        // ...
        template<typename T>
        ostream &operator<<(const T &t) {
            //now the first operand is no longer a temporary,
            //so the non-member operators will overload correctly
            return static_cast<ostream &>(*this) << t;
        }
};

Answer 6

好吧，我不知道导致这种情况的 C++ 规范，但很容易弄清楚为什么会发生这种情况。

临时存在于堆栈中，通常会传递给另一个函数或对其调用单个操作。因此，如果您对其调用自由运算符：

operator<<(myostream(cout))

它会在此操作结束时被销毁，并且第二个“<<”附加 endl 的运算符将引用无效对象。自由“<<”的返回值运算符将是对已破坏的临时对象的引用。 C++ 规范可能定义了有关自由运算符的规则，以防止这种情况使 C++ 程序员感到沮丧和困惑。

现在，在临时对象上使用“<<(void*)”成员运算符的情况下，返回值是对象本身，该对象仍在堆栈上并且没有被销毁，因此编译器知道不要销毁它，但是将其传递给下一个成员运算符，即采用 endl 的成员运算符。临时变量上的运算符链接对于简洁的 C++ 代码来说是一个有用的功能，因此我确信 C++ 规范设计者考虑了它并实现了编译器来有意支持它。

编辑

有人说这与非常量引用有关。此代码编译：

#include <iostream>
using namespace std;
class myostream : public ostream { 
    public: 
        myostream(ostream const &other) : 
            ostream(other.rdbuf()) 
        { } 
            ~myostream() { cout << " destructing "; }
    }; 
int _tmain(int argc, _TCHAR* argv[])
{
    basic_ostream<char>& result = std::operator << (myostream(cout), "This works");
    std::operator << (result, "illegal");
         return 0;
}

并返回

  This works destructing illegal