如何在模板类中拆分模板友元函数的定义？

Question

下面的示例编译良好，但我无法弄清楚如何在这种特殊情况下分离运算符<<() 的声明和定义。

每次我尝试拆分定义时，朋友都会造成麻烦，并且 gcc 抱怨运算符 <<() 定义必须恰好采用一个参数。

#include <iostream>
template <typename T>
class Test {
    public:
        Test(const T& value) : value_(value) {}

        template <typename STREAM>
        friend STREAM& operator<<(STREAM& os, const Test<T>& rhs) {
            os << rhs.value_;
            return os;
        }
    private:
        T value_;
};

int main() {
    std::cout << Test<int>(5) << std::endl;
}

Operator<<() 应该有一个自由的第一个参数来处理不同类型的输出流（std::cout、std::wcout 或 boost::asio::ip::tcp::iostream）。第二个参数应该绑定到周围类的专门版本。

Test<int> x;
some_other_class y;

std::cout << x; // works
boost::asio::ip::tcp::iostream << x; // works

std::cout << y; // doesn't work
boost::asio::ip::tcp::iostream << y; // works

除此之外，使用非成员函数并不等同于拆分定义和声明，因为非成员函数无法访问类的私有属性。

Answer 1

最简单的可能是让所有这些模板操作符成为朋友：

#include <iostream>
template <typename T>
class Test
{
    public:
        Test(const T& value) : value_(value) {}

        template <typename STREAM, typename U>
        friend STREAM& operator<<(STREAM& os, const Test<U>& rhs);

    private:
        T value_;
};

template <typename STREAM, typename T>
STREAM& operator<<( STREAM& os, const Test<T>& rhs )
{
    os << rhs.value_;
    return os;
}

Answer 2

我能实现的最接近的是

#include <iostream>

template <typename T>
class Test;

template <typename STREAM, typename T>
STREAM& operator<<(STREAM& os, const Test<T>& rhs);

template <typename T>
class Test {
public:
    Test(const T& value) : value_(value) {}

    template <typename STREAM, typename U>
    friend STREAM& operator<< (STREAM& os, const Test<U>& rhs);

private:
    T value_;
};

template <typename STREAM, typename T>
STREAM& operator<<(STREAM& os, const Test<T>& rhs) {
    os << rhs.value_;
    return os;
}

int main() {
    std::cout << Test<int>(5) << std::endl;
}

声明所有运算符<<作为朋友，而不仅仅是由 T 参数化的朋友。问题是不可能部分专门化函数。有人会喜欢使用，

template <typename STREAM>
friend STREAM& operator<< <STREAM, T> (STREAM& os, const Test<T>& rhs);

但这不是有效的语法。 （好吧，部分专业化不能声明为朋友）

Answer 3

它不应该在类之外定义吗？

template <typename T>
class Test 
{  
    ...
    template <typename STREAM>
    friend STREAM& operator<<(STREAM& os, const Test<T>& rhs);
};

template <typename STREAM, typename T> 
STREAM& operator<<(STREAM& os, const Test<T>& rhs) 
{
    os << rhs.value_;
    return os;
}

Answer 4

问题在于，在您提供的代码中，友元是仅在第一个参数类型上参数化的模板化函数。也就是说，对于类模板的每个实例化类型 T（称为 mytype），您都在声明一个自由模板函数：

template <typename STREAM>
STREAM& operator<<( STREAM& os, Test<mytype> const & x );

重要的一点是 Test是带有类型参数 mytype 的 Test 的特定实例。

如果您确实想声明一个在流类型和 Test 模板的实例化类型中模板化的友元函数，则必须声明带有两个参数的友元。

另一方面，我建议您不要在流类型上参数化 operator<< ，同时在类大括号内定义它，因为它具有轻微的优势（名称查找规则略有不同）。

Answer 5

对于 Test 类的每个实例化类型 T，都会公开一个模板函数运算符<<()，它可以在不同类型的流上进行操作。 operator<<()函数具有自由的第一参数但固定的第二参数。

示例：

Test<int> x;
some_other_class y;

std::cout << x; // works
boost::asio::ip::tcp::iostream << x; // works

std::cout << y; // doesn't work
boost::asio::ip::tcp::iostream << y; // works

这就是测试类应该工作的方式。