“轻量级类型分类习语”的最简单实现？

Question

我的目标是实现一个谓词来检测嵌套的using 别名（或typedef）的存在，该别名充当轻量级标签以指示类具有某些属性（出于通用编程的目的）。例如，has_my_tag<T> 谓词的行为如下：

struct A {
  using my_tag = void;
};

struct B {};

int main()
{
    static_assert(has_my_tag<A>::value, "");  // evaluate to true if my_tag=void is present
    static_assert(!has_my_tag<B>::value, ""); // false otherwise
}

用户@JoelFalcou 将此称为“轻量级类型分类习语”，并在this answer 中提供了解决方案。我一直找不到该名称的成语的任何参考资料（你知道吗？）这是乔尔对has_my_tag<> 的实现：

template<class T, class R = void>  
struct enable_if_type { typedef R type; };

template<class T, class Enable = void>
struct has_my_tag : std::false_type {};

template<class T>
struct has_my_tag<T, typename enable_if_type<typename T::my_tag>::type> : 
std::true_type
{};

这是编译器资源管理器上的工作版本：https://godbolt.org/z/EEOBb-

我想出了以下简化版：

template<class T, class Enable = void>
struct has_my_tag : std::false_type {};

template<class T>
struct has_my_tag<T, typename T::my_tag> : std::true_type
{};

https://godbolt.org/z/yhkHp7

我的问题：简化版本是否是一种可接受的方式来实现这个成语？有没有会失败的情况？有在 C++11 中工作的更简单的版本吗？我应该更喜欢哪个版本？

据我了解，Joel 的版本将允许 my_tag 为任何类型起别名，而我的版本要求 my_tag 为 void 起别名。但是考虑到为轻量级谓词测试标记类型的目标，我不清楚哪个版本是首选。

辅助问题：另外，这个成语还有其他名称吗？它是否用于我可以调查的任何库中？到目前为止，我还没有找到可以显示任何搜索结果的名称。

Answer 1

对于您的设置，原始版本与您的设置没有区别。两者都使用 SFINAE 来选择正确的 has_my_tag。但是，您的版本确实将您的 typedef/using 限制为 my_tag=void。如果 my_tag 与任何其他类型一样被 typedef，则您的专业化将不匹配，您最终将实例化主模板，如 here 所示。

原因是你在main中实例化模板的地方，static_assert(has_my_tag<A>::value, "");你没有指定第二个参数，所以使用默认（void），即has_my_tag<A,void>::value

您的专业必须与此匹配才能被考虑。

enable_if_type 的用法，（基本上是在 c++17 中完成 void_t 的工作）是在 T 的 ::type 成员上启用 SFINAE，但总是导致无效，这样你的专业化就会当::type 存在时匹配，不管my_tag typedef 的类型。

这让你只关心它是否存在，而不是它的类型；

我个人会使用不依赖于 my_type 被 typedef 为 void 的方法，无论是 enable_if_type 版本，还是类似的东西......

#include <iostream>
#include <type_traits>

struct A {
  using my_tag = void;
};

struct B {};

struct C {
  using my_tag = int; // with void_t also works with my_tag = int
};

struct D {
  struct my_tag{}; //or some struct as the tag
};

// same as your enable_if_type
template <typename...>
using void_t = void;


template<class T, class Enable = void>
struct has_my_tag : std::false_type {};

template<class T>
struct has_my_tag<T, void_t<typename T::my_tag>> : std::true_type
{};


int main() {
    std::cout << has_my_tag<A>::value << std::endl;
    std::cout << has_my_tag<B>::value << std::endl;
    std::cout << has_my_tag<C>::value << std::endl;
    std::cout << has_my_tag<D>::value << std::endl;
    return 0;
}

Demo

Answer 2

首先，你的工作，但确实取决于它是void。如果该轻量级标签在某些情况下带有非 void 类型，则它可能会很有用，如果它是非 void 类型，您会默默地检测失败，这似乎很糟糕。

其次，您的类型标记要求您修改类型，这意味着您无法获得内置或您不拥有的类型（如std 中的类型）。我们可以解决这个问题。

namespace type_tag {

  namespace adl {
    template<template<class...>class tag>
    struct tag_token_t {};

    template<class T, template<class...> class tag>
    constexpr
    decltype( (void)(std::declval<tag<T>>()), std::true_type{} )
    tag_test( T*, tag_token_t<tag> ) { return {}; }

    template<class T, template<class...> class tag, class...LowPriority>
    constexpr
    std::enable_if_t<!std::is_same<T,int>{}, std::false_type> tag_test(T*, tag_token_t<tag>, LowPriority&&...) {
      return {};
    }
  }
  template<template<class...>class Z>using tag_token_t = adl::tag_token_t<Z>;

  template<template<class...>class tag>
  constexpr tag_token_t<tag> tag_token{};

  namespace details {
    template<class T, template<class...>class tag>
    constexpr auto test_impl( T*, tag_token_t<tag> ) {
      return tag_test( (T*)nullptr, tag_token<tag> );
    }
  }
  template<class T, template<class>class tag>
  constexpr auto tag_test() {
    return details::test_impl((T*)nullptr, tag_token<tag>);
  }
}

所以现在的标签是这样的：

template<class T>
using my_tag = typename T::my_tag;

我们可以如下测试：

constexpr auto double_has_tag = type_tag::tag_test< double, my_tag >();

如果 double 有标签，则返回编译时 true 或 false。

我们可以通过以下方式确定int 有标签：

namespace type_tag::adl {
  constexpr std::true_type tag_test( int*, type_tag::tag_token_t<my_tag> ) {
    return {};
  }
}

或者，对于我们控制的类型：

struct my_tagged_type {
  using my_tag = void;
};

对于我们可以将名称注入其命名空间的类型（即，不是std 或内置类型），我们可以这样做：

namespace not_my_ns {
  constexpr std::true_type tag_test( not_my_type*, ::tag_test::tag_token_t<::my_tag> ) {
    return {};
  }
}

突然type_tag::tag_test<not_my_ns::not_my_type, ::my_tag>() 是真的。

一旦我们有了tag_test< type, tag_name >()，我们就可以使用通常的std::enable_if，而不是一些自定义系统。

本系统的优点包括：

1. 它可以在不改变任何你要标记的类型的情况下进行扩展。

2. 可以使用您的系统使用的using tag=void; 或using tag=int; 对其进行扩展。

3. 在 SFINAE 使用点，它只是另一个编译时 bool。所以你现有的 SFINAE 模式可以使用它。

4. 如果您在结构中为其他人出于不相关原因使用的标签类型选择了一个糟糕的名称，tag_test 可以根据每个类型覆盖它。

缺点是需要一点魔法才能做到这一点。但在常见的用例中，最终用户所需的工作与轻量级系统所需的工作相同。在更复杂的用例中，这可以让您完成轻量级无法做到的事情。

Live example.