这个 has_member 类模板如何工作？

Question

我试图了解以下类模板的工作原理（取自 此处），但我无法正确理解它：

template <typename Type> 
class has_member 
{ 
   class yes { char m;}; 
   class no { yes m[2];}; 
   struct BaseMixin 
   { 
     void operator()(){} 
   }; 
   struct Base : public Type, public BaseMixin {}; 
   template <typename T, T t>  class Helper{}; 
   template <typename U> 
   static no deduce(U*, Helper<void (BaseMixin::*)(), &U::operator()>* = 0); 
   static yes deduce(...); 
public: 
   static const bool result = sizeof(yes) == sizeof(deduce((Base*)(0))); 
};

更具体地说，我不明白 BaseMixin 的目的以及其中的operator()。另外，由于 Base 是从它派生的，所以我也不理解它。

更具体地说，当模板参数Type定义了operator()时，为什么只有才会触发SFINAE，导致第一个deduce( ) 函数被忽略并选择第二个函数？

---

无论如何，这是我的测试代码：

struct A{};                             //SFINAE is triggered for A
struct B{ void operator()(){} };        //SFINAE is not triggered for B
struct C{ void operator()(int,int){} }; //SFINAE is not triggered for C

int main() 
{       
   std::cout << std::boolalpha; //enable true/false instead of 1/0!
   std::cout << has_member<A>::result << std::endl;
   std::cout << has_member<B>::result << std::endl;
   std::cout << has_member<C>::result << std::endl;
}

输出（ideone）：

false
true
true

Answer 1

• BaseMixin 有一个 operator() 定义。
• Base 派生自 Type 和 BaseMixin，因此如果 Type 有一个 operator() 那么 Base::operator() 上的名称查找将是不明确的。
• deduce 是针对 Base* 而不是 Type* 调用的。
• Helper 仅当 &U::operator() 明确解析时才会实例化到BaseMixin::operator()。
• 相反，如果 Helper 没有实例化，这是因为 Type< /code> 有自己的 operator() ，使得 &U::operator() 上的名称查找不明确，因此导致 deduce 的重载返回选择类型yes。

关于第二个项目符号的标准引用 - C++11 §10.2/2-6：

2 以下步骤定义类作用域 C 中成员名称 f 的名称查找结果。

3 C 中 f 的查找集称为 S(f,C)，由以下部分组成两个组件集：声明集，一组名为f的成员；以及子对象集，一组在其中找到这些成员的声明（可能包括using-declaration）的子对象。在声明集中，using-declaration 被它们指定的成员替换，类型声明（包括注入类名）被它们指定的类型替换。 S(f,C)计算如下：

4 如果 C 包含名称 f 的声明，则声明集包含 C< 中声明的 f 的每个声明/code> 满足查找发生的语言结构的要求。 [注意：例如，在详细类型说明符或基本说明符中查找名称会忽略所有非类型声明，在嵌套名称说明符中查找名称时会忽略函数、变量和枚举器声明。作为另一个示例，在 using-declaration 中查找名称包括类或枚举的声明，这些声明通常会被同一范围内该名称的另一个声明隐藏。 —结束说明 ] 如果生成的声明集不为空，则子对象集包含 C 本身，计算完成。

5 否则（即 C 不包含 f 声明或生成的声明集为空），S(f,C) 最初是空的。 如果C有基类，计算每个直接基类子对象f的查找集B_i，并将每个此类查找集 S(f,B_i) 依次合并为 S(f,C)。

6 以下步骤定义将查找集 S(f,B_i) 合并到中间 S(f,C) 的结果>：

• 如果 S(f,B_i) 的每个子对象成员都是 S( f,C)，或者如果 S(f,B_i) 为空，则 S(f,C) 不变合并完成。相反，如果 S(f,C) 的每个子对象成员都是 S(f,B_i 的至少一个子对象成员的基类子对象sub>)，或者如果 S(f,C) 为空，则新的 S(f,C) 是以下内容的副本S(f,B_i)。
• 否则，如果S(f,B_i)和S(f,C)的声明集不同，合并不明确：新的S(f,C)是一个具有无效声明集和子对象集并集的查找集。在后续合并中，无效声明集是被认为与其他任何不同。
• 否则，新的S(f,C)是一个具有共享声明集和子对象集并集的查找集。

Answer 2

Base 可以从 Type 继承 operator()，或者从 BaseMixin 继承，如果 Type有 operator() 它隐藏了 BaseMixin 的运算符。

因此，如果 Type 没有定义 operator ()，则 Base 的 operator() 可以隐式转换为BaseMixin 的 operator()。然后，用 U==Base 推导(U*, Helper* = 0) code> 将匹配。

相反，如果 Type 定义了 operator()，则 Base 的 operator() 无法转换为 BaseMixin 是其中之一，因此 derive(U*, Helper* = 0) 将不匹配。