C++ 如何在template类中拆分template friend函数的定义？

下面的示例编译得很好，但我不知道如何将运算符的声明和定义分开是否应该在类之外定义它

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;
}

模板
课堂测试
{  
...
模板
friend STREAM&operator最简单的方法可能是让所有这些模板操作符成为朋友：

#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;
}

#包括
模板
课堂测试
{
公众：
测试（常数T和值）：值u0（值）{}
模板
friend STREAM&operator我能达到的最近目标是

#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;
}

#包括
模板
课堂测试；
模板
STREAM&operator问题在于，在您呈现的代码中，friend是一个仅在第一个参数类型上参数化的模板函数。也就是说，对于类模板的每个实例化类型T（称之为
mytype
），您正在声明一个自由模板函数：

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

模板
STREAM&operator对于类Test的每个实例化类型T，模板函数operator可能的dup：为什么要参数化OSTREAM类型？常见的习惯用法是定义operator@dribeas：因为我希望能够同时使用其他输出流。例如boost:：asio:：ip:：tcp:：iostream和boost:：asio:：local:：stream\u protocol:：iostreamm、 我在你的“答案”中添加了一条评论，这不是真正的答案，而是问题的延伸（考虑编辑问题以添加更多信息，因为在一个地方阅读所有信息更容易）@dribeas:done（感谢提示）通常您会编写：template-template-STREAM&Test:：operator即使它可以工作，示例仍然会遗漏：Test:：operator@~笑话：
operator@LucTouraille:但是这两个声明之间有一个区别。原始声明只能将Test作为第二个参数。第二个声明可以将event std:：cin；但除此之外因此，示例的编译方式与实际不同。为operatorI指定第二个模板参数也找不到重用
t
的方法，即使是在函数定义之前有2
template
声明的典型模板成员函数也是如此。这在可访问性方面并不重要，但看起来很奇怪尽管如此。你是对的，它与原始版本不一样。但是，由于原始版本可以在类定义中定义，因此应该有一种拆分声明和定义的方法。原始版本使用一个模板参数（第一个）定义一个函数。如果你想要一些等效的东西，你必须在每个类定义中定义一个函数键入T。这是可能的，但可能会很痛苦。是的，它会在环绕模板类实例化后立即声明/定义带有一个模板参数的模板成员函数。不要使用自身继承的
boost:：asio:：ip:：tcp:：iostream
和
boost:：asio:：ip:：tcp:：iostream
继承自
std:：basic_iostream
从
std:：basic\u ostream
？我认为它们不会继承。它们应该是模板专门化。boost:：asio:：ip:：tcp:：iostream应该是模板basic\u socket\u iostream的专门化。只需遵循代码。。。（boost/asio/basic_socket_iostream.hpp:
模板类basic_socket_iostream:public boost:：base_from_member，public std:：basic_iostream
）。这很有意义，关键是您不需要重写任何
操作符
#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;
}

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

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

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