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

很抱歉发了这么长的帖子。我很难将其分解为基本方面或找到正确的措辞，因此也很难在谷歌上搜索它——所以如果以前有人问过我，请原谅我。)我只想描述一下我在这里面临的整个情况，并尽可能完整。

上下文

我目前正在追踪一个非常奇怪的错误，在我自己的类之前包含一些库X的头会导致非常奇怪的编译时错误。这里的细节并不那么重要(我稍后将给出一个最小的例子！)，但对于上下文：我正在用一个名为cereal的库序列化我的对象，它突然告诉我的类不再是默认可构造的了。

在将包含的破坏标头的邪恶内容切割成碎片后，我终于发现了发生了什么，并在一个简化的示例中重新创建了错误，但我不知道为什么事情能像现在这样工作(或不工作)，也许有人能向我解释这一点。：)

准备工作

包含的X的报头的某些部分破坏了cereal中的类型特征，该类型特征确定给定类T是否可以默认地由cereal::access构造。

所以，我们首先需要的是类型特征。这是一种类似于谷物特性的实现方式(但它不一样，为了一个最小的例子，它被简化了)：

#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>(因此也可以构造T)，则以yes = std::true_type为返回类型的test(int)方法是适用的，并用于确定static const bool value，否则使用省略号版本，返回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;
}

哪个返回：

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

到目前为止一切都很好。

错误介绍

BUT库X使用类似的方法来测试给定类是否具有名为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;
};
}

当我把这个添加到文件的顶部时，一切都会变得一团糟。或者更确切地说，编译的所有东西仍然很好，但我的程序的输出现在更改为：

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

突然间，这个特性告诉我们，没有什么是不可破坏的。。。百米

可能的"；修复">

为了了解发生了什么，我修改了代码的一些部分，并找到了两个可能的修复方法，这告诉了我们更多关于这个问题的信息。

原始功能可以通过以下方式恢复。。。

a) 。。。明确规定测试方法：

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

或

b) 。。。将CCD_ 14重命名为例如CCD_。

实际问题

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

"；什么鬼东西">

这就是这个问题的标题来源：对我来说，这是不同名称空间之间的泄漏，甚至是模板化的类和方法之间的泄漏。我的意思是，既然Whatever和Whatever::test都是模板化的，有不同的模板参数，那么使用它到底是怎么回事？

如果我添加类似的内容

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

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

最后一个问题

所以，我想知道：这里到底发生了什么，为什么要这样做我可能只是不知道这里有一些很酷的c++功能，在这种特殊情况下，它会让我很困惑。。。

所以。。。请开导我！：)

--无

附言：另外，感谢你和我一起阅读这面文字墙！：)

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是对的，这是一个编译器错误。

我在原来的问题中添加了一个较小的例子，它提供了编译器错误的更多信息。看起来像@DanM。是正确的，这只是一个编译器错误。遗憾的是，我没能在上面找到它https://gcc.gnu.org/bugzilla

因此，答案是：只需使用不同的编译器/编译器版本。

clang 6.0.0和gcc 8.4.0都对我有效。

上下文