c++ - 为模板结构中定义的成员结构重载运算符<<

Question

你好亲爱的 StackOverflowers!

我在使用包含另一个(但非模板)结构的模板结构时遇到问题。

事情是这样的:

1. 结构 B 是非模板的，在模板结构 A 中定义。

2. 结构 B 是“ protected ”，因为它仅出于结构 A 的目的而存在，任何人都不得在结构 A 之外使用它。

3. 结构 B 有一个运算符 << 的重载，这样类型 B 的对象可以被发送到标准输出“cout << B_type_object;” (而且它是 A 的 friend ，所以它可以访问 protected B)。

4. 前面提到的 B 对象的打印仅通过 A 中定义的方法完成(因为“2.”)。

5. 只要这两个结构都是非模板的，一切都很好。

6. 当 A 是模板时，我收到一条错误消息(在代码部分提供)。

这是工作代码(其中 A 不是模板):

#include <iostream>
#include <string>

struct A
{

protected:
    struct B
    {
        std::string something;

        B& operator= (const std::string&& rhs)
        {
            this->something = std::move(rhs);
            return *this;
        }
    };

    B B_object;

    friend std::ostream& operator<< (std::ostream& output, const typename A::B& ob);

public:
    void method ()
    {
        B_object = "This is text.";
        //No error here
        std::cout << B_object;
    }
};



std::ostream& operator<< (std::ostream& output, const typename A::B& ob)
{
    output << ob.something;
    return output;
}



int main(int argc, const char * argv[])
{
    A obj;
    obj.method();

    return 0;
}

这是行不通的代码

#include <iostream>
#include <string>

template <typename T>
struct A
{
    T variable;

protected:
    struct B
    {
        std::string something;

        B& operator= (const std::string&& rhs)
        {
            this->something = std::move(rhs);
            return *this;
        }
    };

    B B_object;

    template <typename X> friend std::ostream& operator<< (std::ostream& output, typename A/*<X>*/::B& ob);

public:
    void method ()
    {
        B_object = "This is text.";

        //ERROR: Invalid operands to binary expression ('ostream' (aka 'basic_ostream<char>') and 'A<int>::B')
        std::cout << B_object;
    }
};



template <typename X>
std::ostream& operator<< (std::ostream& output, typename A<X>::B& ob)
{
    output << ob.something;
    return output;
}



int main(int argc, const char * argv[])
{
    A<int> obj;
    obj.method();

    return 0;
}

Answer 1

只需在 B 中声明内联运算符即可，然后它起作用了:

...
struct B
{
    std::string something;

    B& operator= (const std::string&& rhs)
    {
        this->something = std::move(rhs);
        return *this;
    }

    friend std::ostream& operator<< (std::ostream& output, const typename A<T>::B& ob)
    {
        output << ob.something;
        return output;
    }
};
...

这还有一个好处，即您不是 friend任何operator<<任何 A<X> .在您的示例中，运算符(operator)采用 A<string>::B也会是A<int>::B的 friend .有关更深入的解释，请参阅此答案: https://stackoverflow.com/a/4661372/36565