Question

以下是示例代码：

#include <iostream>
using namespace std;

class test
{
    int a;
    int b;

    public:
    test(): a(1), b(2) {}
    ostream& operator<<(ostream&);  //FUNC 1
    friend ostream& operator<<(ostream&,test);  //FUNC 2
};

//FUNC 1
ostream& test::operator<<(ostream& obj)
{
    cout<<a<<" "<<b<<endl;
    return obj;
}

//FUNC 2
ostream& operator<<(ostream& obj, test o)
{
    cout<<o.a<<" "<<o.b<<endl;
    return obj;
}

int main()
{
    test o;
    o<<cout;      //STATEMENT 1 Calls FUNC 1
    cout<<o;      //STATEMENT 2 Calls FUNC 2 
    return 0;
}

有没有办法在类中使用STATEMENT 2，即不使用友元函数并将测试对象作为参数传递。使用像FUNC 1这样的定义吗？

Answer 1

您对函数2 ostream& test::operator<<(ostream& obj, test o)的定义是test类的成员函数。您希望这是该类外部的友元函数：ostream& operator<<(ostream& obj, test o)。

Answer 2

当您输出＆＃34;输出＆＃34; （实际上向左移）运算符是类的成员，它使类的对象成为＆＃34;输出＆＃34;的目标。

简单示例

struct Foo
{
    Foo& operator<<(int value)
    {
        std::cout << "Output to Foo target is " << value << '\n';
        return *this;
    }
};

int main()
{
    Foo foo;
    foo << 123;
}

要使用输出运算符输出到另一个目标（例如输出流），您需要将运算符声明为非成员函数：

struct Bar
{
    int value;
};

std::ostream& operator<<(std::ostream& os, const Bar& bar)
{
    os << bar.value;
}

int main()
{
    Bar bar = { 321 };
    std::cout << bar;
}

在第一个示例中，对象（foo）是输出运算符的目标。在第二个示例中，对象（bar）用作另一个目标（std::cout）的输出。您也可以这样看，如果您将运算符作为成员函数重载，那么类的对象（＆＃34; target＆＃34;我称之为）就在 left 侧运算符和参数位于运算符的右侧。

另外，如果你使用friend在类中声明一个函数，那么它实际上不是一个成员函数：

struct Fum
{
    void ho() { ... }  // ho is a member function

    friend ha() { ... }  // ha is a non-member function
};

请记住，操作符函数只是普通函数，只是使用特殊名称。

我可以重载一个重载的运算符吗？运算符重载如何工作

2 个答案: