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

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

到目前为止一切都很好。

漏洞介绍

但是该库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) ... 将重命名somethingelse::Whatever::test为例如somethingelse::Whatever::test1。

实际问题

可悲的是，这两个部分都来自不同的外部库。由于选项 b)，显然somethingelse::Whatever::test选择了获取的值cereal::is_default_constructible::value。这当然会导致 a 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++ 功能在这种特殊情况下只会让我感到困惑......

所以...请赐教！:)

——尼尔斯

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 bar::barbaz<int>::value通过使用表达式 for来实例化constexpr const bool foo:foobaz<???>::value。这让我确信@DanM 是正确的，这是一个编译器错误。

标签： c++templatessfinaetypetraits