【问题标题】:c++ method leak from another template class and namespacec++ 方法从另一个模板类和命名空间泄漏
【发布时间】:2020-07-30 14:54:35
【问题描述】:

抱歉,帖子太长了。我在将其分解为基本方面或找到正确的措辞时遇到了一些麻烦,因此也在谷歌上搜索它——所以如果之前有人问过这个问题,请原谅我。 ;) 我将只描述我在这里面临的整个情况,并尽可能完整。

上下文

我目前正在追踪一个非常奇怪的错误,在我自己的类之前包含一些库 X 的标头会导致非常奇怪的编译时错误。细节在这里并不重要(我将在一秒钟内给出一个最小的例子!),但对于上下文:我正在使用一个名为 cereal 的库来序列化我的对象,它突然告诉我我的类不是默认的- 可建造了。

在将包含的破坏邪恶的标题切成碎片后,我终于发现了发生了什么,并在一个简化的示例中重新创建了该错误,但我不知道 为什么 事情有效(或不t) 正如他们所做的那样,也许有人可以向我解释这一点。 :)

预赛

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&lt;T&gt;可以被默认构造(因此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

到目前为止一切都很好。

bug介绍

但是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

突然间,这个 trait 告诉我们没有什么是可以默认构造的......嗯!

可能的“修复”

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

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

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,因为我的测试类没有Name 成员变量。只是使用了错误的测试...

“什么鬼?”

这就是这个问题的标题的来源:对我来说,这是不同命名空间甚至模板类和方法之间的一种泄漏。我的意思是,既然Whatever 是模板化的,Whatever::test 也有不同的模板参数,那到底是怎么推导出来的呢?

如果我添加类似的东西

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

我得到一个编译错误:Use of undeclared identifier 'test'。哪个好。对于cereal::is_default_constructible,它不是未声明的,因为它从自己的结构中知道test,但实际上它再次访问something::Whatever&lt;T&gt;::test&lt;TT&gt;...不同的命名空间,不同的模板,...

最后一个问题

所以,我想知道:这到底是怎么回事,为什么要这样做?我可能只是不知道这里有一些很酷的 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&lt;???&gt;::value 的表达式来实例化constexpr const bool bar::barbaz&lt;int&gt;::value。 这让我确信@DanM 是正确的,这是一个编译器错误。

【问题讨论】:

  • 一个最小的、可重复的例子比冗长的描述更有帮助。 (它还可以帮助调试问题。)
  • 它是否用 clang 重现(只是为了减少这是一些编译器错误的机会)?
  • 无法在 clang 或 gcc 上重现:godbolt.org/z/o5c4nW
  • 这实际上是我的最小示例。 ;) @DanM。哇。那是宾果游戏!该错误存在于 gcc 7.5.0 中,但在 clang 6.0.0 和 gcc 8.4.0 中均不存在……抱歉给大家带来了麻烦,我从没想到这是一个编译器错误……
  • @NilsN。您可以自己回答(最好链接到 GCC bugtracker gcc.gnu.org/bugzilla 上的问题)。

标签: c++ templates sfinae typetraits


【解决方案1】:

我在原始问题中添加了一个较小的示例,该示例提供了编译器错误,并提供了有关问题所在的更多信息。好像是@DanM。是正确的,这只是一个编译器错误。遗憾的是,我在https://gcc.gnu.org/bugzilla 上找不到它

所以,答案是:只需使用不同的编译器/编译器版本。

clang 6.0.0 和 gcc 8.4.0 都对我有用。

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 2021-01-06
    • 2019-06-02
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2012-08-06
    • 1970-01-01
    相关资源
    最近更新 更多