c++ - 按位置查找未标记的模板选项/参数/参数

Question

简而言之:我想从可变参数模板参数中提取各种选项，但不仅通过标签而且通过那些参数的索引，这些参数是未知的 标签。我喜欢 boost 中的方法(例如 heap 或 lockfree 策略)，但想让它与 STL containers 兼容- 分配器参数。

前言

我目前正在为具有此签名的可变大小记录/对象的队列/缓冲区编写模板:

// current:
template <typename R = byte, class Alloc = std::allocator<byte>,
  class... Opts> class rqueue;
// what I want:
template <class... Opts> class rqueue;

我几乎没有其他可能的选择，我是这样描述的:

namespace tag {
    struct allocator {};        ///< specify allocator for data storage
    struct virtual_offset {};   ///< manage offset in virtual memory
    struct fill_empty {};       ///< fill empty space (security or reconstruction)
    struct reconstructible {};  ///< fill empty and leave one slot between wp&rp
} namespace opt {
/// allocator for data storage
    template <class Alloc> struct allocator: tag::allocator {
        typedef Alloc type; };
/// type for offset in virtual memory
    template <class Off> struct virtual_offset: tag::virtual_offset {
        typedef Off type; };
/// type and value to fill empty space
    template <class T, T V> struct fill_empty: tag::fill_empty {
        typedef T type; static constexpr T value = V; };
/// make state pointers reconstructible by leaving one slot between wp&rp
    template <class T, T V> struct reconstructible
      : tag::reconstructible, fill_empty<T, V> {};
}

用法

// basic queue for custom record class
rqueue<record>;
// advanced record storage that can be written to a file and reconstructed back
rqueue<opt::virtual_offset<unsigned>, opt::reconstructible<byte,0xFF>>;
// specialization for strings with custom allocator
rqueue<string, myalloc>;
// alternative to above
rqueue<const char*, opt::allocator<myalloc>>;

选项包助手

namespace opt {
template<class... Opts> struct bind {
    template<class Tag> static constexpr bool has() {
        return false; }
    template<class Tag, class Default = void>
      using get = Default; };
template<class First, class... More> struct bind<First, More...> {
private:
    template<class Tag> static constexpr bool first() {
        return std::is_same<Tag, First>::value
          || std::is_base_of<Tag, First>::value; }
    template<class Tag, class Default, bool> struct get_ {
        typedef typename bind<More...>::template get<Tag, Default> type; };
    template<class Tag, class Default> struct get_<Tag, Default, true> {
        typedef First type; };
public:
    template<class Tag> static constexpr bool has() {
        return first<Tag>() || bind<More...>::template has<Tag>(); }
    template<class Tag, class Default = void>
      using get = typename get_<Tag, Default, first<Tag>()>::type; };
}

它没有The Boost Parameter Library那么先进，但完成了工作……到目前为止，包含未标记的必需参数和标记的可选参数列表。

测试代码

cout << boolalpha;

typedef opt::bind<
  opt::virtual_offset<unsigned>,
  opt::reconstructible<char,0>
  > opts;
cout << opts::has<tag::virtual_offset>() << endl;
cout << opts::has<tag::fill_empty>() << endl;
cout << opts::has<tag::reconstructible>() << endl;
cout << typeid(opts::get<tag::virtual_offset>::type).name() << endl;
cout << typeid(opts::get<tag::fill_empty>::type).name() << endl;
cout << (int)opts::get<tag::fill_empty>::value << endl;

typedef opt::bind<> no;
cout << no::has<tag::virtual_offset>() << endl;
cout << no::has<tag::fill_empty>() << endl;
cout << no::has<tag::reconstructible>() << endl;
cout << typeid(no::get<tag::virtual_offset>).name() << endl;

typedef opt::bind<opt::fill_empty<char,0>> one;
cout << one::has<tag::virtual_offset>() << endl;
cout << one::has<tag::fill_empty>() << endl;
cout << one::has<tag::reconstructible>() << endl;
cout << typeid(one::get<tag::virtual_offset>).name() << endl;

问题

我正在搜索复杂的 boost 参数/元编程库并以 metafunctions 结尾它可以完成与我的小 helper 相同的工作(当然还有更多)，但没有找到按索引提取未标记选项的解决方案。

1. 我错过了吗？它在某处吗？
2. 你能给我一些不同的解决方案吗？

也许我应该忘记它并坚持使用那些标签，或者编写一些复杂的帮助程序来过滤掉所有标记的选项并访问索引留下的选项......但在我投降或去之前很长的路要走，这里是问的好地方:)

注意:如果你引用了一些库，请留下如何使用它的描述。谢谢。

Answer 1

我已经设法让它工作了

(已提供的选项包助手的特化，与原始代码合并)

template<class... Tags> struct tags {
    template<class Option> static constexpr bool match() {
        return false; }};
template<class First, class... More> struct tags<First, More...> {
    template<class Option> static constexpr bool match() {
        return std::is_same<First, Option>::value
          || std::is_base_of<First, Option>::value
          || tags<More...>::template match<Option>(); }};
//-----------------------------------------------------------------------
template<class... Tags, class... Opts>
  struct bind<tags<Tags...>, Opts...> {
    static constexpr size_t size = sizeof...(Opts);
    typedef opt::tags<Tags...> tags;
    template<class Tag> static constexpr bool has() {
        return false; }
    template<class Tag, class Default = void>
      using get = Default;
    template<size_t idx, class Default = void>
      using at = Default;
    static constexpr size_t count = 0; };
template<class... Tags, class First, class... More>
  struct bind<tags<Tags...>, First, More...> {
public:
    typedef opt::tags<Tags...> tags;
    static constexpr size_t size = 1 + sizeof...(More);
private:
    template<size_t idx, class Default, bool> struct at_ {
        typedef typename bind<tags, More...>::template at<idx,Default> type; };
    template<size_t idx, class Default> struct at_<idx, Default, false> {
        typedef typename bind<tags, More...>::template at<idx-1,Default> type; };
    template<class Default> struct at_<0, Default, false> {
        typedef First type; };
public:
    template<class Tag> static constexpr bool has() {
        return bind<First, More...>::template has<Tag>(); }
    template<class Tag, class Default = void>
      using get = typename bind<First, More...>::template get<Tag,Default>;
    template<size_t idx, class Default = void>
      using at = typename at_<idx, Default, tags::template match<First>()>::type;
    static constexpr size_t count = bind<tags, More...>::count
      + (tags::template match<First>() ? 0 : 1); };

用法

template <class... Opts> class rqueue {
//  bind tags and options
    typedef opt::bind<opt::tags<tag::allocator,
      tag::virtual_offset, tag::fill_empty,
      tag::reconstructible, tag::fixed_size>,
      Opts...> opts;
public:
//  get first untagged option or byte if none
    typedef typename opts::template at<0,byte>
      value_type, record_type, *pointer, &reference;
//  get second untagged option, or allocator option or std::allocator<byte>
    typedef typename std::conditional<
      (opts::count > 1),
      typename opts::template at<1>,
      typename opts::template get<tag::allocator,
      std::allocator<byte>>>::type allocator_type;
//...shorter version of the above
    typedef typename opts::template at<1,
      typename opts::template get<tag::allocator,
      std::allocator<byte>>> allocator_type_v2;
//  get type specified as virtual_offset or void
    typedef typename opts::template get<tag::virtual_offset,
      std::enable_if<true>>::type offset_type;