Question

以下示例编译正常，但我无法弄清楚如何分隔运算符＆lt;＆lt;（）的声明和定义是这种特殊情况。

每次我尝试拆分定义朋友都会造成麻烦，gcc会抱怨运算符＆lt;＆lt;（）定义必须只接受一个参数。

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

运算符＆lt;＆lt;（）应该有一个免费的第一个参数来处理不同类型的输出流（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

不应该在课外定义吗？

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 3

我能达到的最近的是

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

声明所有运算符＆lt;＆lt;作为朋友，而不仅仅是由T参数化的那个。问题是不可能部分地专门化功能。人们本来希望使用

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

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

Answer 4

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

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

重要的一点是Test<mytype>是Test的特殊实例化，其类型参数为mytype。

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

另一方面，我建议您不要在流类型上对operator<<进行参数化，同时在类括号内定义它，因为它有一些优点（名称查找规则略有不同）不同）。

Answer 5

对于类Test的每个实例化类型T，暴露模板函数运算符＆lt;＆lt;（），其可以在不同种类的流上操作。运算符＆lt;＆lt;（）函数具有空闲的第一个参数，但具有固定的第二个参数。

示例：

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

这就是Test类的工作方式。

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

5 个答案: