4

我想在编译时通过一个接一个地添加类型来组装一个类型列表（实际上是：一组）。像这样的东西：

struct HeadOfList;

struct Item1;
[ addToList<Item1, HeadOfList> ]

struct Item2;
[ addToList<Item2, HeadOfList> ]

我不在乎列表是如何存储的。我想到了这样的事情：

template<typename T> struct NextInList { typedef void type; };
template<> struct NextInList<HeadOfList> { typedef Item1 type; };
template<> struct NextInList<Item1> { typedef Item2 type; };
template<> struct NextInList<Item2> { typedef Item3 type; };

但 aboost::mpl::list也一样好。类型的顺序也无关紧要，我只想能够遍历它们并向它们添加新元素。

我对此有一种不好的感觉，因为这样的构造意味着例如LastElementOf<MyList>::type会在源文件的不同点（添加新元素之前和之后）编译为不同的类型，这对我来说似乎是假的。尽管如此，这正是我现在想要的。

你认为有可能吗？允许使用 C++11。

更新：我只想补充一点，在添加新元素时我不知道添加到列表中的最后一个元素，但我知道列表本身（例如列表的头部）

4

1 回答 1

5

在咨询了 comp.lang.c++.moderated 之后，我想出了下面详述的代码。PushBack()宏用于向列表中添加新项目，可以通过使用宏迭代项目，Next()并且可以通过其“下一项”本身来识别最后一项。所以一个非常基本的示例代码：

struct A {}; 

namespace NS1 { 
    struct B {}; 
    struct C {}; 
    struct D {}; 

    // building up the compile-time list 
    struct Head; 

    PushBack(Head, A); 
    PushBack(Head, B); 
} 

PushBack(NS1::Head, NS1::C); 

namespace NS1 { 
    PushBack(Head, D); 
} 



// iterate through the list
namespace NS2 { 

    // end of the list reached (recognized from PrevItem == Item)
    template <class ListId, class Item> 
    void print(Wrapper<Item>, Wrapper<Item>) {} 

    // process Item and advance to the next element
    template <class ListId, class PrevItem, class Item> 
    void print(Wrapper<PrevItem>, Wrapper<Item>) 
    { 
        cout << typeid(Item).name() << endl; 
        print<ListId>(Wrapper<Item>(), Wrapper< Next(ListId, Item) >()); 
    } 
}

可以在此处或此处找到更详细的示例，其中还包含一个迭代器以简化列表的使用。

“图书馆”最重要的部分：

/// Helper class to wrap incomplete types and avoid instantiation of T 
template<class T> struct Wrapper {}; 

namespace CTList { 
    /// The front of compile-time lists 
    struct Nil {}; 
} 

/// Compile-time list helper 
template< typename ListId, typename Item > 
Item NextInListHelper( ::Wrapper<ListId>, ::Wrapper<Item> ); 

/// The last element of the list
#define Back(ListId) \ 
    decltype( NextInListHelper( ::Wrapper<ListId>(), ::Wrapper<\ 
    decltype( NextInListHelper( ::Wrapper<ListId>(), ::Wrapper<\ 
    decltype( NextInListHelper( ::Wrapper<ListId>(), ::Wrapper<\ 
    decltype( NextInListHelper( ::Wrapper<ListId>(), ::Wrapper<\ 
    decltype( NextInListHelper( ::Wrapper<ListId>(), ::Wrapper<\ 
    decltype( NextInListHelper( ::Wrapper<ListId>(), ::Wrapper<\ 
    decltype( NextInListHelper( ::Wrapper<ListId>(), ::Wrapper<\ 
    decltype( NextInListHelper( ::Wrapper<ListId>(), ::Wrapper<\ 
    decltype( NextInListHelper( ::Wrapper<ListId>(), ::Wrapper<\ 
    decltype( NextInListHelper( ::Wrapper<ListId>(), ::Wrapper<\ 
                             CTList::Nil \ 
     >())) \ 
     >())) \ 
     >())) \ 
     >())) \ 
     >())) \ 
     >())) \ 
     >())) \ 
     >())) \ 
     >())) \ 
     >())) 



/// Add a new element (type) to the list 
#define PushBack( ListId, item) \ 
    item NextInListHelper( ::Wrapper< ListId >, ::Wrapper< Back(ListId) > ) 

/// The next element in the ('ListId') list after 'item' 
#define Next(ListId, item) decltype(NextInListHelper(::Wrapper<ListId>(), ::Wrapper<item>() ))

它使用NextInListHelper函数声明和 Argument Dependent (Name)Look-up 来记录列表。可以使用Back宏引用列表的最后一个元素。

列表的第一个元素可以访问为：Next(ListId, CTList::Nil)，列表的最后一个元素可以识别为它与它的下一个元素相同（LastItem == Next(ListId, LastItem)）。

我仅使用 gcc 4.6.3 对其进行了测试，但它旨在完全符合 C++11。

关于解决方案的几句话：

  • 在这种形式中，它可以处理最多 10 个元素的类型列表，但是可以通过向Back()宏添加额外的行来扩展
  • “列表”只能包含一次类型
  • 声明中使用的附加ListId类型NextInListHelper允许类型同时包含在多个列表中
  • Wrapper用于避免列表元素类型的实际实例化并支持不完整的类型作为 ListId
  • PushBack()'calls' 必须在ListId( NS1) 或Wrapper（全局范围）的命名空间中
  • 列表的处理可以放在任何命名空间( NS2)
于 2012-06-17T20:32:49.990 回答