c++ 方法从另一个模板 class 和命名空间泄漏

Question

很抱歉 post。我在将其分解为基本方面或找到正确的措辞时遇到了一些麻烦，因此也无法对其进行谷歌搜索——所以如果之前有人问过这个问题，请原谅我。 ;) 我将只描述我在这里面临的整个情况，并尽量做到完整。

上下文

我目前正在追踪一个非常奇怪的错误，其中在我自己的 classes 之前包含某些库 X 的 headers 会导致非常奇怪的编译时错误。细节在这里并不那么重要（我将在一秒钟内给出一个最小的例子！），但对于上下文：我正在用一个名为 cereal 的库序列化我的 objects，它突然告诉我我的 classes 不再是 default-constructible。

将包含的 evil-stuff-breaking header 切割成碎片后，我终于发现了发生了什么，并在简化示例中重新创建了错误，但我不知道 为什么 事情正常（或不正常），也许有人可以向我解释一下。 :)

预赛

X 中包含的 header 的某些部分破坏了 cereal 中的类型特征，它决定了给定的 class T 是否可以 default-constructed 来自 cereal::access.

所以，我们首先需要的是类型特征。这是一种类似于谷物中 trait 的工作方式的实现（但它不一样，为了一个最小的例子而极度简化）：

#include <type_traits>

namespace cereal {

    using yes = std::true_type;
    using no = std::false_type;

    struct access {
        template <class T>
        struct construct {
            T foo;
        };
    };

    //! Determines whether the class T can be default constructed by cereal::access
    template <class T>
    struct is_default_constructible
    {
        template <class TT>
            static auto test(int) -> decltype(cereal::access::construct<TT>(), yes());

        template <class>
            static no test(...);

        static const bool value = std::is_same<decltype(test<T>(0)), yes>::value;
    };
}

基本思想是：如果 cereal::access:construct<T> 可以是 default-constructed（因此 T 也是），test(int) 方法 yes = std::true_type 作为 return 类型适用并用于确定 static const bool value，否则使用省略号版本，即 returns a no = std::false_type.

我首先通过将以下代码附加到同一个文件来测试它：

class HasDefault {
public:
    HasDefault() = default;
};


class HasNoDefault {
public:
    HasNoDefault() = delete;
};

class HasPrivateDefault {
private:
    HasPrivateDefault() = default;
};

class HasPrivateDefaultAndFriendAccess {
private:
    friend class cereal::access;
    HasPrivateDefaultAndFriendAccess() = default;
};


#include <iostream>

int main(int, char**)                                                           
{                                                                               
    std::cout << "is it default constructible?" << std::endl;                   
    std::cout << std::boolalpha;                                                
                                                                                
    std::cout                                                                   
        << "HasDefault:                         "                               
        << cereal::is_default_constructible<HasDefault>::value                  
        << std::endl;                                                           
    std::cout                                                                   
        << "HasNoDefault:                       "                               
        << cereal::is_default_constructible<HasNoDefault>::value                
        << std::endl;                                                           
    std::cout                                                                   
        << "HasPrivateDefault:                  "                               
        << cereal::is_default_constructible<HasPrivateDefault>::value           
        << std::endl;                                                           
    std::cout                                                                   
        << "HasPrivateDefaultAndFriendAccess:   "                               
        << cereal::is_default_constructible<HasPrivateDefaultAndFriendAccess>::value
        << std::endl;

    return 0;
}

其中 return 个：

is it default constructible?
HasDefault:                         true
HasNoDefault:                       false
HasPrivateDefault:                  false
HasPrivateDefaultAndFriendAccess:   true

到目前为止一切都很好。

漏洞介绍

BUT 库 X 使用类似的方法来测试给定的 class 是否有一个名为 Name 的成员变量：

namespace somethingelse {

template <class T>
struct Whatever {
    template <class TT> static std::true_type test(decltype(T::Name) *);
    template <class TT> static std::false_type test(...);

    static constexpr bool value =
        std::is_same<decltype(test<T>(nullptr)), std::true_type>::value;
};
}

当我将其添加到文件顶部时，一切都变得一团糟。或者更确切地说，所有 compiles 仍然很好，但我的程序的输出现在更改为：

is it default constructible?
HasDefault:                         false
HasNoDefault:                       false
HasPrivateDefault:                  false
HasPrivateDefaultAndFriendAccess:   false

突然间，特征告诉我们没有什么是default-constructible...嗯！

可能的“修复”

为了找出发生了什么，我更改了部分代码并找到了两个可能的修复程序，它们告诉我们更多关于问题的信息。

可以通过以下任一方式恢复原始功能...

a) ...明确指定测试方法：

static const bool value = std::is_same<decltype(is_default_constructible::test<T>(0)), yes>::value;

或

b) ... 将 somethingelse::Whatever::test 重命名为例如somethingelse::Whatever::test1.

实际问题

遗憾的是，这两个部分都来自不同的外部库。由于选项 b)，显然选择 somethingelse::Whatever::test 来获取 cereal::is_default_constructible::value 的值。这当然会导致 std::false_type，因为我的测试 classes 没有 Name 成员变量。只是使用了错误的测试...

“到底是什么？”

这就是问题标题的来源：对我来说，这是不同命名空间甚至模板化 classes 和方法之间的一种泄漏。我的意思是，由于 Whatever 和 Whatever::test 是模板化的，具有不同的模板参数，到底是如何推断使用它的？

如果我添加类似

    typeid(decltype(test<int>(0)));

我的主程序出现编译错误：Use of undeclared identifier 'test'。哪个好。对于 cereal::is_default_constructible 它不是未声明的，因为它从它自己的结构中知道 test，但是它实际上再次访问了 something::Whatever<T>::test<TT>...不同的命名空间，不同的模板，...

最后一题

所以，我想知道：这里到底发生了什么，为什么要这样做？我可能只是不知道这里有一些很酷的 C++ 功能在这种特殊情况下只是在搞乱我...

所以...请赐教！ :)

--尼尔斯

PS：另外，感谢您的包容和阅读这面文字墙！ :)

PPS: 我差点忘了一些规格！

Ubuntu 18.04
gcc 7.5.0
使用 std=gnu++14

编辑：更小的例子

我试图进一步减少问题，结果是：

#include <type_traits>

namespace foo {

    template <class T>
    struct foobaz {
        template <class U> static std::true_type test(U*);

        static constexpr bool value = std::is_same<std::true_type, decltype(test<T>(nullptr))>::value;
    };

}

namespace bar {

    template <class T>
    struct barbaz {
        template <class U> static std::true_type test(int);

        static constexpr bool value = std::is_same<std::true_type, decltype(test<T>(0))>::value;
    };

}

int main()
{
    bar::barbaz<int>::value;
}

这会导致编译器错误：

src/test.cpp: In instantiation of ‘constexpr const bool bar::barbaz<int>::value’:
src/test.cpp:27:23:   required from here
src/test.cpp:9:84: error: no matching function for call to ‘bar::barbaz<int>::test<int>(std::nullptr_t)’
         static constexpr bool value = std::is_same<std::true_type, decltype(test<T>(nullptr))>::value;
                                                                             ~~~~~~~^~~~~~~~~
src/test.cpp:18:50: note: candidate: template<class U> static std::true_type bar::barbaz<T>::test(int) [with U = U; T = int]
         template <class U> static std::true_type test(int);
                                                  ^~~~
src/test.cpp:18:50: note:   template argument deduction/substitution failed:
src/test.cpp:9:84: note:   cannot convert ‘nullptr’ (type ‘std::nullptr_t’) to type ‘int’
         static constexpr bool value = std::is_same<std::true_type, decltype(test<T>(nullptr))>::value;
                                                                             ~~~~~~~^~~~~~~~~

因此，它试图通过使用 constexpr const bool foo:foobaz<???>::value 的表达式来实例化 constexpr const bool bar::barbaz<int>::value。这让我相信@DanM 是正确的，这是一个编译器错误。

Answer 1

我在我的原始问题中添加了一个较小的示例，该示例给出了编译器错误以及有关问题所在的更多信息。好像是@DanM。是正确的，这只是一个编译器错误。遗憾的是，我无法在 https://gcc.gnu.org/bugzilla

上找到它

所以，答案是：只需使用不同的编译器/编译器版本即可。

clang 6.0.0 和 gcc 8.4.0 都适合我。

c++ 方法从另一个模板 class 和命名空间泄漏

c++ method leak from another template class and namespace

c++

templates

sfinae

typetraits

上下文

预赛