模板替换和 SFINAE 中的私有成员访问

Question

class A { int a; };

template<typename, typename = void>
class test {};

template<typename T>
class test<T,decltype(T::a)> {};

int main() { test<A> a; }

上面的代码在clang version 3.8.0-2ubuntu4 (tags/RELEASE_380/final)上编译没有错误，但在g++-5 (Ubuntu 5.4.1-2ubuntu1~16.04) 5.4.1 20160904和g++-6 (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901上编译失败，出现如下错误：

main.cpp: In function ‘int main()’:
main.cpp:9:22: error: ‘int A::a’ is private within this context
 int main() { test<A> a; }
                      ^
main.cpp:1:15: note: declared private here
 class A { int a; };

在这两种情况下我都是用-std=c++11编译的，但是-std=c++14和-std=c++1z的效果是一样的。

这里哪个编译器是正确的？我假设，至少从 C++11 开始，在模板替换期间访问私有成员应该触发 SFINAE，这意味着 clang 是正确的而 gcc 不是。是否还有一些我不知道的其他规则？

作为参考，我正在考虑当前标准草案 N4606 §14.8.2/8 中的注释：

如果替换导致无效的类型或表达式，请键入 扣除失败。无效的类型或表达式是 格式错误，需要诊断，如果使用 替代论据。 [ 注意：如果不需要诊断，则 程序仍然格式不正确。访问检查是作为 替代过程。 ——尾注]

两个编译器都接受使用成员函数和成员函数指针：

class A { void a() {}; };

template<typename, typename = void>
class test {};

template<typename T>
class test<T,decltype(&T::a)> {};

int main() { test<A> a; }

Answer 1

这很有趣！ 我认为这是一个 g++ 编译器错误，我认为就是这样。我已经尝试使用 g++ 4.9.3 和 clang 3.7.0 对您的代码进行多次更改。

虽然函数与类模板实例化的规则有些不同，但我相信这些是模板实例化的一般步骤：

1. 编译器读取带有模板定义的源文件。
2. 名称查找（可能触发 ADL）：这是一个名称的过程， 在程序中遇到时，与声明相关联 介绍了它。 (http://en.cppreference.com/w/cpp/language/lookup)
3. 模板参数规范/推导：为了 实例化一个函数模板，每个模板参数必须是 已知，但并非必须指定每个模板参数。什么时候 可能，编译器会推断出缺少的模板参数 从函数参数。 (http://en.cppreference.com/w/cpp/language/template_argument_deduction)
4. 模板替换（可能触发 SFINAE）：每次使用 函数参数列表中的模板参数替换为 对应的模板参数。替换失败（即， 未能用推导或提供的模板参数替换模板参数 函数模板的模板参数）删除函数 来自重载集的模板。 (http://en.cppreference.com/w/cpp/language/function_template#Template_argument_substitution)
5. 形成重载集：在重载决议开始之前， 通过名称查找和模板参数推导选择的函数 组合起来形成候选函数集。 (http://en.cppreference.com/w/cpp/language/overload_resolution#Details)
6. 重载解析：一般来说，候选函数的 参数与参数最接近的是 叫。 (http://en.cppreference.com/w/cpp/language/overload_resolution)
7. 模板实例化：必须确定模板参数 这样编译器就可以生成一个实际的函数（或类，从 类模板）。 (http://en.cppreference.com/w/cpp/language/function_template#Function_template_instantiation)
8. 编译器生成代码。

我会将这些要点保留为以后的指南和参考。此外，我将参考步骤 1-6 中的 模板评估。如果您在上面的列表中发现任何错误，请随时更改或发表评论，以便我进行更改。

在以下示例中：

class A {};

template<typename, typename = void>
struct test
{ test(){std::cout<< "Using None" <<std::endl;} };

template<typename T>
struct test<T, decltype(T::a)>
{ test(){std::cout<< "Using T::a" <<std::endl;} };

int main()
{ test<A> a; }

两个编译器的输出：

Using None

这个例子在 g++ 和 clang 中都编译得很好，因为当编译器完成所有模板的评估过程时，它只会选择实例化第一个模板，以便与用于创建对象的模板参数最佳匹配在主（）。此外，当编译器无法推断出 T::a (SFINAE) 时，模板替换过程也会失败。此外，由于参数不匹配，特化不会包含在重载集中，也不会被实例化。

我们是否应该像这样添加第二个模板参数：

test<A , decltype(A::a)> a;

代码不会编译，两个编译器都会抱怨：

error: no member named 'a' in 'A'

然而，在下面的例子中，事情开始变得奇怪：

class A { int a; };

template<typename, typename = void>
struct test
{ test(){std::cout<< "Using None" <<std::endl;} };

template<typename T>
struct test<T, decltype(T::a)>
{ test(){std::cout<< "Using T::a" <<std::endl;} };

int main()
{ test<A> a; }

clang 的输出：

Using None

g++ 的输出：

error: ‘int A::a’ is private

首先，我认为这是一个很好的警告。但为什么会出错？模板甚至不会被实例化。考虑到前面的示例，以及指向成员的指针是编译时已知的常量值这一事实，似乎当 clang 完成模板评估阶段时，SFINAE 发生在模板替换时，它准确地实例化了第一个模板并忽略专业化。但是当 g++ 执行替换过程，并查找变量 T::a 时，它发现它是一个私有成员，而不是说 SFINAE，它提示上面的错误。考虑到这个错误报告，我认为这就是错误所在：https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61806

现在，好奇的部分在下一个示例中，它使用了私有成员函数：

class A{ void a() {}; };

template<typename, typename = void>
struct test
{ test(){std::cout<< "Using None" <<std::endl;} };

template<typename T>
struct test<T,decltype(&T::a)>
{ test(){std::cout<< "Using A::a" <<std::endl;} };

int main()
{ test<A> a; }

两个编译器的输出：

Using None

如果前面的解释是真的，那为什么g++在使用私有成员函数的时候不提示错误呢？同样，这只是基于输出的假设，但我认为这个位实际上可以正常工作。长话短说，SFINAE 启动，特化从重载集中被丢弃，只有第一个模板被实例化。也许它比表面看起来更多，但如果我们显式指定第二个模板参数，两个编译器都会提示相同的错误。

int main()
{ test<A , decltype(&A::a)> b; }

两个编译器的输出：

error: ‘void A::a()’ is private

无论如何，这是我一直在使用的最终代码。为了演示输出，我将课程公开。作为一个有趣的事件，我添加了一个 nullptr 来直接指向成员函数。 decltype(((T*)nullptr)->f()) 的类型是 void，从下面的示例中，a 和c 都由特化而不是第一个模板调用。原因是第二个模板比第一个模板更专业，因此是两者的最佳匹配（一石二鸟）（模板正式排序规则：https://stackoverflow.com/a/9993549/2754510）。 decltype(&T::f) 的类型是 M4GolfFvvE（可能翻译：Men 4 Golf Fear very vicious Elk），这要归功于 boost::typeindex::type_id_with_cvr，它被分解成 void (Golf::*)().

#include <iostream>
#include <boost/type_index.hpp>

class Golf
{
    public:
        int v;

        void f()
        {};
};


template<typename T>
using var_t = decltype(T::v);

template<typename T>
using func_t = decltype(&T::f);
//using func_t = decltype(((T*)nullptr)->f()); //void


template<typename, typename = void>
struct test
{
    test(){std::cout<< "Using None" <<std::endl;}
};

template<typename T>
struct test<T,var_t<T> >
{
    test(){std::cout<< "Using Golf::v" <<std::endl;}
};

template<typename T>
struct test<T,func_t<T> >
{
    test(){std::cout<< "Using Golf::f" <<std::endl;}
};


int main()
{
    test<Golf> a;
    test<Golf,var_t<Golf> > b;
    test<Golf,func_t<Golf> > c;

    using boost::typeindex::type_id_with_cvr;
    std::cout<< typeid(func_t<Golf>).name() << " -> " << type_id_with_cvr<func_t<Golf>>().pretty_name() <<std::endl;
}

两个编译器的输出 (func_t = decltype(&T::f))：

Using None
Using Golf::v
Using Golf::f
M4GolfFvvE -> void (Golf::*)()

两个编译器的输出 (func_t = decltype(((T*)nullptr)->f()))：

Using Golf::f
Using Golf::v
Using Golf::f
v -> void

---

编辑：

根据@Dr.Gut（下面的评论），这个错误继续存在于 gcc 9.2 中。然而，我发现了一个使用 std::declval 的“hack”，这使它看起来更奇怪。

#include <utility>

class A
{
    int a;
};

template<typename, typename = void>
class test
{};

template<typename T>
class test<T,decltype(std::declval<A>().a)>
{};

int main()
{
    test<A> a;
}

在线示例：https://rextester.com/BUFU29474

代码在 g++ 和 vc++ 中编译和运行良好，但在 clang++ 中失败。