C++模板类、模板成员友元函数匹配规则

Question

我有一个带有模板化友元函数声明的模板化类，当用更直接但看似等效的表达式声明时，它的签名不匹配：

link to example on online compiler

#include <type_traits>

template <typename Sig> class Base;
template <typename R, typename ... Args> class Base<R(Args...)> { };
template <typename Sig, typename T> class Derived;
template <typename Sig> struct remove_membership;

template <typename T, typename R, typename ... Args>
class Derived<R(Args...), T> : public Base<R(Args...)> {
  static void bar() { }

  // XXX: why are these two not equivalent, and only the 1st version successful?
  template <typename T2>
  friend auto foo(T2 const &) -> Base<typename
    remove_membership<decltype(&std::remove_reference_t<T2>::operator())>::type> *;
  template <typename T2>
  friend auto foo(T2 const &) -> Base<R(Args...)> *;
};

template <typename F, typename R, typename ... Args>
struct remove_membership<R (F::*)(Args...) const> {
  using type = R(Args...);
};

template <typename T>
auto foo(T const &) -> Base<typename 
remove_membership<decltype(&std::remove_reference_t<T>::operator())>::type> * 
{
  using base_param_t = typename remove_membership<
    decltype(&std::remove_reference_t<T>::operator())>::type;
  Derived<base_param_t, T>::bar();
  return nullptr;
}

int main(int, char **) { foo([](){}); } // XXX blows up if verbose friend decl. removed.

在Derived<R(Args...), T> 的成员定义内部（例如，在bar() 的主体中），类型匹配，增加了我的困惑：

static_assert(std::is_same<Base<R(Args...)>, Base<typename  
  remove_membership<decltype(&std::remove_reference_t<T>::operator())>::type>>::value,
  "signature mismatch");

是否有围绕模板类模板成员函数（和友元函数）声明和实例化的规则使这些前面的声明在某些或所有情况下不同？

Answer 1

template <typename T2>
void foo(T2 const &)

template <typename T2>
auto foo(T2 const &)
-> std::enable_if_t<some_traits<T2>::value>;

是 2 种不同的重载。即使两者都返回void（有效时）。
第二次重载使用 SFINAE。

（是的，模板函数的不同之处仅在于返回类型与常规函数相反）。

您的版本不相同但相似（&std::remove_reference_t<T>::operator() 应该是有效的）

你可以使用更简单的模板友元函数：

template <typename T, typename R, typename ... Args>
class Derived<R(Args...), T> : public Base<R(Args...)> {
  static void bar() { }

  template <typename T2>
  friend auto foo(T2 const &) -> Base<R(Args...)>*;
};

template <typename T>
auto foo(T const &) -> Base<void()>* // friend with Derived<void(), U>
{
  using base_param_t = typename remove_membership<
    decltype(&std::remove_reference_t<T>::operator())>::type;
  Derived<base_param_t, T>::bar();
  return nullptr;
}

Demo

但是你必须实现不同版本的模板foo。

Answer 2

问题可以简化为：

template<class T>
struct identity {
    using type=T;
};

class X {
    int bar();
public:
    template<class T>
    friend T foo();
};

template<class T>
typename identity<T>::type foo() { return X{}.bar(); }

int main() {
    foo<int>(); // error: bar is a private member of X
}

尽管我们知道identity<T>::type 总是T，但编译器并不知道这一点，因此假设是错误的。稍后在代码中的某处可能会出现identity<T> 的特化，它解析为T 以外的某种类型。

因此，当编译器看到foo 的第二个声明时，它不会假定它与之前声明的foo 是同一个朋友。