c++ - 模板替换和 SFINAE 中的私有(private)成员访问

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 开始，在模板替换期间访问私有(private)成员应该触发 SFINAE，这意味着 clang 是正确的，而 gcc 不是。是否有一些我不知道的额外规则？

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

If a substitution results in an invalid type or expression, type deduction fails. An invalid type or expression is one that would be ill-formed, with a diagnostic required, if written using the substituted arguments. [ Note: If no diagnostic is required, the program is still ill-formed. Access checking is done as part of the substitution process. — end note ]

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

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 对您的代码进行了几次更改。

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

编译器读取带有模板定义的源文件。

名称查找(可能会触发 ADL):它是一个名称、
在程序中遇到时，与声明相关联
介绍了它。
( http://en.cppreference.com/w/cpp/language/lookup )

模板参数规范/推导:为了
实例化一个函数模板，每个模板参数必须是
已知，但并非每个模板参数都必须指定。什么时候
可能，编译器会推导出缺少的模板参数
从函数参数。
( http://en.cppreference.com/w/cpp/language/template_argument_deduction )

模板替换(可能触发 SFINAE):每次使用
函数参数列表中的模板参数替换为
相应的模板参数。替换失败(即
未能用推导或提供的模板参数替换
函数模板的模板参数)删除函数
来自重载集的模板。 ( http://en.cppreference.com/w/cpp/language/function_template#Template_argument_substitution )

形成重载集:在重载解析开始之前，
通过名称查找和模板参数推导选择的函数
组合形成候选函数集。
( http://en.cppreference.com/w/cpp/language/overload_resolution#Details )

重载解析:一般来说，其候选函数
参数与参数最匹配的是那个
叫。
( http://en.cppreference.com/w/cpp/language/overload_resolution )

模板实例化:必须确定模板参数
以便编译器可以生成实际的函数(或类，从
类模板)。 ( http://en.cppreference.com/w/cpp/language/function_template#Function_template_instantiation )

编译器生成代码。

我将保留这些要点作为以后的指南和引用。此外，我将引用步骤 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 中都可以很好地编译，因为当编译器完成所有模板的评估过程时，它只会选择实例化第一个模板，因为它与用于在 main( 中创建对象的模板参数的最佳匹配) )。此外，当编译器无法推导出 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; }

铛的输出:

Using None

g++ 的输出:

error: ‘int A::a’ is private

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

现在，奇怪的部分是在下一个示例中，它使用私有(private)成员函数:

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

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

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

两个编译器的输出:

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

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

#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++ 中失败。