常量列表，非常量元素访问

Question

我对boost侵入性容器有一个问题。

我的一个类有一些对象的侵入式列表，这些对象的生存期由它严格管理。对象本身是要由类的用户修改的，但它们不应该修改列表本身。这就是为什么我只通过"getList“函数提供对列表的访问，该函数返回入侵列表的const版本。

const侵入性列表的问题是，当您试图遍历元素时，元素也会变成const。但是用户应该能够遍历和修改这些项。

我不想为用户保留一个单独的指针列表，因为这会使使用介入式容器的最大优点失效。也就是说，能够在固定的时间内从容器中删除项，而您所拥有的唯一东西是指向该项的指针。

如果仅仅因为C++的限制而不得不给出一个非常数版本的列表，那将是令人遗憾的。所以问题是: boost侵入性容器是否有一个特殊的常量版本，它神奇地允许修改项，而不允许对列表本身进行任何修改？

Answer 1

好了，我已经设计了一个完整的解决方案。如果您不需要以高效的方式迭代项目，那么Andy的解决方案很不错。但是我想要一些在语义上等同于const std::list的东西。也许这有点过头了，但在性能方面，优化后几乎没有什么区别：

解决方案是使用一个名为ConstList的类私下扩展入侵列表，这个类公开的内容仅足以让BOOST_FOREACH迭代，但不会由任何人进行任何更改。我将list钩子从item移到了一个子类中，这样item对象也不能用来更改list。我们存储带有钩子的子类，但是我们的迭代器返回对item类的引用。我将这个解决方案编码到两个模板化的类中，以便于应用到任何item类。

我已经创建了一个包含ConstList类和HookedItem类的头文件，后面跟着tests.cpp，用于测试和基准测试。您将看到我们的ConstList类在迭代时具有相同的性能。

它的工作非常干净，用户代码也保持干净。这就引出了一个问题:为什么boost中还没有这个？！？

出于任何目的，您可以随意使用以下代码:)

附言:当我想出这个解决方案的时候，我有了一些启示："const“只是一种特殊情况的语法糖，你可以用正确的类层次结构来实现什么。这是真的吗，还是我过于泛化了？

#include <boost/intrusive/list_hook.hpp>

template < typename T>
struct type_wrapper{  typedef T type;};

template<class listType, class owner, class item>
class ConstList: private listType {
    friend class type_wrapper<owner>::type;
public:
    class iterator {
        typename listType::iterator it;
    public:
        typedef std::forward_iterator_tag iterator_category;
        typedef item value_type;
        typedef int difference_type;
        typedef item* pointer;
        typedef item& reference;
        template<class T>
        iterator(const T it): it(it){}
        bool operator==(iterator & otherIt) {return it==otherIt.it;}
        iterator & operator++() {
            it++;
            return *this;
        }
        item & operator*() {
            return *it;
        }
    };
    iterator begin() {
        return iterator(listType::begin());
    }

    iterator end() {
        return iterator(listType::end());
    }
};

template<class item, class owner, class hooktype>
class HookedItem: public item {
    friend class type_wrapper<owner>::type;
public:
    hooktype hook_;
    typedef boost::intrusive::member_hook<HookedItem, hooktype, &HookedItem::hook_> MemberHookOption;
private:
    template<class Arg1, class Arg2>
    HookedItem(Arg1 &arg1, Arg2 &arg2): item(arg1, arg2){}
};

#include<cstdio>
#include<boost/checked_delete.hpp>
#include<ConstList.h>
#include<boost/intrusive/list.hpp>
#include<boost/foreach.hpp>

using namespace boost::intrusive;

class myOwner;
class myItem {
public:
    int a,b; //arbitrary members
    myItem(int a, int b): a(a), b(b){};
};

typedef HookedItem<myItem,myOwner,list_member_hook<> > myHookedItem;
typedef list<myHookedItem, typename myHookedItem::MemberHookOption> myItemList;
typedef ConstList<myItemList,myOwner,myItem> constItemList;

class myOwner {
public:
    constItemList constList;
    myItemList & nonConstList;
    myOwner(): nonConstList(constList) {}
    constItemList & getItems() { return constList;}
    myItem * generateItem(int a, int b) {
        myHookedItem * newItem = new myHookedItem(a,b);
        nonConstList.push_back(*newItem);
        return newItem;
    }
    ~myOwner() {nonConstList.clear_and_dispose(boost::checked_delete<myHookedItem>);}
};


int main(int argc, char **argv) {
    myOwner owner;
    int avoidOptimization=0;
    for(int i=0; i<1000000; i++) {
        owner.generateItem(i,i);
    }


    clock_t start = clock();
    for(int i=0; i<1000; i++)
        BOOST_FOREACH(myItem & item, owner.constList)
            avoidOptimization+=item.a;
    printf ( "%f\n", ( (double)clock() - start ) / CLOCKS_PER_SEC );


    start = clock();
    for(int i=0; i<1000; i++)
        BOOST_FOREACH(myHookedItem & item, owner.nonConstList)
            avoidOptimization+=item.a;
    printf ( "%f\n", ( (double)clock() - start ) / CLOCKS_PER_SEC );


    printf ("%d",avoidOptimization);
    return 0;
}

-控制台输出

4.690000
4.700000
1764472320

Answer 2

你不需要返回列表，可以通过引用来访问不同的项目