如何为C++模板类声明友元函数？含非成员运算符重载需求

我用g++ -std=c++14 -g test.cpp -o debug.exe -Wall编译代码时，尝试了两种模板类友元函数的声明写法，均无法通过编译，现将问题、错误写法及正确方案整理如下：

错误写法1：声明非模板友元函数 #

#include <iostream>

template <typename T>
class Test{
    private: T x;

    public: Test(const int &x): x(x) {}

    public: friend void test(const Test<T> &obj);
    // 警告：friend声明的是非模板函数
};

template <typename T>
void test(const Test<T> &obj) {
    std::cout << obj.x << std::endl;
    // 错误：‘int Test<int>::x’是私有成员，无法访问
}

int main() {
    Test<int> obj(15);
    test<int>(obj);
}

问题解析：类内声明的friend void test(const Test<T> &obj)是一个普通非模板函数，但后续定义的是模板版本的test，两者属于不同的函数实体。编译器会认为你要声明一个普通友元，但实际定义的模板函数并未获得友元权限，因此无法访问私有成员。

错误写法2：模板参数名遮蔽 #

#include <iostream>

template <typename T>
class Test{
    private: T x;

    public: Test(const int &x): x(x) {}

    public: template <typename T> friend void test(const Test<T> &obj);
    // 错误：模板参数‘T’遮蔽了类模板的同名参数
};

template <typename T>
void test(const Test<T> &obj) {
    std::cout << obj.x << std::endl;
}

int main() {
    Test<int> obj(15);
    test<int>(obj);
}

问题解析：类模板本身的参数是T，友元模板又使用了同名的T，导致参数名冲突遮蔽，编译器不允许这种重复命名。

正确写法1：绑定特定模板实例为友元 #

这种写法让test<T>的模板实例仅成为Test<T>类的友元，权限更精确，需要前置声明：

#include <iostream>

// 前置声明：告知编译器Test是模板类，test是模板函数
template <typename T> class Test;
template <typename T> void test(const Test<T> &obj);

template <typename T>
class Test{
    private: T x;

    public: Test(const int &x): x(x) {}

    // 声明test<T>这个特定实例为当前Test<T>的友元
    public: friend void test<T>(const Test &);
};

template <typename T>
void test(const Test<T> &obj) {
    std::cout << obj.x << std::endl;
}

int main() {
    Test<int> obj(15);
    test<int>(obj);
}

为什么需要前置声明？
当在类内写friend void test<T>(const Test &);时，编译器需要提前知道test是模板函数，否则会将test<T>判定为语法错误；同时Test作为模板类，简写的const Test &也需要编译器提前知晓其模板身份，因此必须先完成两者的前置声明。

正确写法2：声明整个模板为友元 #

如果允许所有test<U>的实例访问所有Test<T>的私有成员，可以使用这种写法，无需前置声明，但要注意模板参数名不与类模板重复：

#include <iostream>

template <typename T>
class Test{
    private: T x;

    public: Test(const int &x): x(x) {}

    // 用不同的参数名U，避免遮蔽类模板的T
    template <typename U>
    friend void test(const Test<U> &obj);
};

template <typename U>
void test(const Test<U> &obj) {
    std::cout << obj.x << std::endl;
}

int main() {
    Test<int> obj(15);
    test<int>(obj);
}

模板类的非成员运算符重载实现 #

完全可行，逻辑和友元函数声明一致。以重载输出运算符<<为例，两种写法都适用：

写法1：绑定特定运算符实例为友元 #

#include <iostream>

template <typename T> class Test;
template <typename T>
std::ostream& operator<<(std::ostream& os, const Test<T>& obj);

template <typename T>
class Test{
    private: T x;

    public: Test(const T &x): x(x) {}

    // 绑定对应的运算符模板实例为友元
    friend std::ostream& operator<< <T>(std::ostream& os, const Test& obj);
};

template <typename T>
std::ostream& operator<<(std::ostream& os, const Test<T>& obj) {
    os << "Test value: " << obj.x;
    return os;
}

int main() {
    Test<int> obj(15);
    std::cout << obj << std::endl; // 输出：Test value: 15
}

写法2：声明整个运算符模板为友元 #

#include <iostream>

template <typename T>
class Test{
    private: T x;

    public: Test(const T &x): x(x) {}

    template <typename U>
    friend std::ostream& operator<<(std::ostream& os, const Test<U>& obj);
};

template <typename U>
std::ostream& operator<<(std::ostream& os, const Test<U>& obj) {
    os << "Test value: " << obj.x;
    return os;
}

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

根据需求选择即可：若仅需同类型的运算符实例访问对应类实例，选写法1；若允许所有运算符实例访问所有类实例，选写法2。

内容的提问来源于stack exchange，提问作者Alison