简而言之： 我想从可变参数模板参数中提取各种选项，但不仅仅是通过标记，而是通过索引获取那些没有已知的参数标签。我喜欢boost中的方法（例如heap或lockfree策略），但希望使其与STL containers - allocator参数兼容。
我目前正在为具有此签名的可变大小记录/对象的队列/缓冲区编写模板：
// 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结束，它可以完成与我的小助手（当然还有更多）相同的工作，但是没有找到<的解决方案strong> 按索引提取未标记的选项。
也许我应该忘记它并坚持使用这些标签，或者写一些复杂的帮助来过滤掉所有标记的选项并访问索引留下的那些 ......但在我投降或去之前很长的路，这里是个好地方：）
注意： 如果您参考某个图书馆，请留下说明如何使用它。谢谢。
答案 0 :(得分：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;