Question

我正在努力解决this question中描述的问题（将模板函数声明为模板类的朋友），我相信第二个答案是我想要做的（向前声明模板函数，然后将专业命名为朋友）。我有一个问题是，一个稍微不同的解决方案是否实际上是正确的，或者只是恰好在Visual C ++ 2008中工作。

测试代码是：

#include <iostream>

// forward declarations
template <typename T>
class test;

template <typename T>
std::ostream& operator<<(std::ostream &out, const test<T> &t);

template <typename T>
class test {
  friend std::ostream& operator<< <T>(std::ostream &out, const test<T> &t);
  // alternative friend declaration
  // template <typename U>
  // friend std::ostream& operator<<(std::ostream &out, const test<T> &t);

  // rest of class
  };

template <typename T>
std::ostream& operator<<(std::ostream &out, const test<T> &t) {
  // output function defined here
  }

首先，我发现一个奇怪的事情是，如果我更改operator<<的前向声明以使其不匹配（例如，std::ostream& operator<<(std::ostream &out, int fake);，则所有内容仍然可以编译并正常工作（即明确，我不需要定义这样的函数，只声明它。）但是，如在链接问题中，删除前向声明会导致问题，因为编译器似乎认为我正在声明一个数据成员而不是朋友的功能。我很确定这种行为是一个Visual C ++ 2008错误。

有趣的是当我删除前向声明并在上面的代码中使用替代友元声明时。请注意，模板参数U未出现在以下签名中。此方法也可以正确编译和工作（不更改任何其他内容）。我的问题是这是否符合Visual C ++ 2008的标准或特性（我在参考书中找不到合适的答案）。

请注意，虽然朋友声明template <typename U> friend ... const test<U> &t);也有效，但这实际上让运营商friend的每个实例都可以访问test的任何实例，而我想要的是私人成员test<T>的{{1}}只能从operator<< <T>访问。我通过在test<int>中实例化operator<<并访问私有成员来测试这个;当我尝试输出test<double>时，这会导致编译错误。

概要：删除前向声明并切换到上面代码中的替代友元声明似乎产生相同的结果（在Visual C ++ 2008中） - 这段代码实际上是否正确？

更新：对代码的任何上述修改都不能在gcc下工作，所以我猜这些是Visual C ++编译器中的错误或“功能”。我仍然很欣赏那些熟悉标准的人的见解。

Answer 1

...如果我更改运算符的前向声明＆lt;＆lt;所以它不匹配

朋友功能应被视为一种非常特殊的声明。本质上，编译器足以解析声明，但是除非你真正专门化类，否则不会进行语义检查。

完成建议的修改后，如果您再实例化test，则会收到有关声明不匹配的错误：

template class test<int>;

...但是......删除前向声明会导致问题

编译器尝试解析声明以存储它，直到类模板专用。在解析期间，编译器到达声明中的<：

friend std::ostream& operator<<  <

operator<< <可以跟随的唯一方法是，如果它是模板，则进行查找以检查它是否为模板。如果找到函数模板，则<被认为是模板参数的开始。

删除前向声明时，未找到任何模板，operator<<被视为对象。（这也是为什么当你添加using namespace std时代码继续编译的原因，因为必须有operator<<的模板声明。

...当我删除前向声明并在上面的代码中使用替代友元声明时。请注意，模板参数U不会出现在以下签名中......

不要求在函数模板的参数中使用所有模板参数。替代声明用于新的函数模板，只有在命名空间中声明并指定显式模板参数时才能调用。

一个简单的例子是：

class A {};
template <typename T> A & operator<<(A &, int);

void foo () {
  A a;
  operator<< <int> (a, 10);
}

...此代码实际上是否正确？

这有两个部分。第一个是替代友元函数未在范围的后面引用声明：

template <typename T>
class test {
  template <typename U> 
  friend std::ostream& operator<<(std::ostream &out, const test<T> &t);
  };

template <typename T> 
std::ostream& operator<<(std::ostream &out, const test<T> &t);  // NOT FRIEND!

友元函数实际上将在每个特化的命名空间中声明：

template <typename U> 
std::ostream& operator<<(std::ostream &out, const test<int> &t);
template <typename U> 
std::ostream& operator<<(std::ostream &out, const test<char> &t);
template <typename U>
std::ostream& operator<<(std::ostream &out, const test<float> &t);

operator<< <U>的每个专精都可以根据参数test<T>的类型访问特定的专精。因此，实质上访问受限于您的要求。但是正如我之前提到的，这些函数基本上不能用作运算符，因为你必须使用函数调用语法：

int main ()
{
  test<int> t;
  operator<< <int> (std << cout, t);
  operator<< <float> (std << cout, t);
  operator<< <char> (std << cout, t);
}

根据上一个问题的答案，您可以使用litb建议的前向声明，也可以根据Dr_Asik's答案定义友情函数内联（这可能是什么我会的。）

更新：第2条评论

...在课前改变前方声明;类中的那个仍然匹配我稍后实现的功能......

正如我上面所指出的，编译器在声明中看到operator<<时会检查<是否为模板：

friend std::ostream& operator<<  <

它通过查找名称并检查它是否是模板来完成此操作。只要你有一个伪前向声明，那么这会“欺骗”编译器将你的朋友视为模板名称，因此<被认为是模板参数列表的开头。

稍后，当您实例化该类时，您确实拥有一个匹配的有效模板。从本质上讲，您只是欺骗编译器将朋友视为模板专业化。

你可以在这里这样做，因为（正如我之前所说），此时不会进行语义检查。

模板类的模板友好功能

1 个答案: