Question

我对增强侵入式容器存在问题。

我的一个班级有一些侵入性的一些对象列表，其生命周期由它严格管理。对象本身意味着由类的用户修改，但它们不应该修改列表本身。这就是为什么我只通过“getList”函数提供对列表的访问，该函数返回侵入列表的const版本。

const侵入式列表的问题在于，当您尝试迭代它们时，这些元素也会变成const。但是用户应该能够遍历并修改项目。

我不想保留一个单独的指针列表来提供给用户，因为这会使使用侵入式容器的最大优势之一无效。也就是说，能够在恒定时间内从容器中删除项目，而你唯一拥有的是指向项目的指针。

这将是难过得给我的名单只是因为C的限制++的一个非const版本。所以问题是：是否有一个特殊的const版本的boost侵入式容器，它可以神奇地允许项目修改，同时不允许对列表本身进行任何修改？

Answer 1

您无需返回列表，可通过引用访问单独的项目

Answer 2

好的，我已经为这个问题设计了一个完整的解决方案。如果您不需要以有效的方式迭代项目，Andy的解决方案很好。但我想要的东西在语义上等同于const std :: list。也许这是一种矫枉过正，但表现明智，优化后几乎没有差异：

解决方案是使用一个名为ConstList的类私有地扩展侵入列表，该类暴露出足以让BOOST_FOREACH迭代，但不会对任何人进行任何更改。我已将列表钩子从项目移动到子类，因此项目对象也不能用于更改列表。我们使用钩子存储子类，但是我们的迭代器返回对item类的引用。我已将此解决方案编码为两个模板化类，以便轻松应用于任何项目类。

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

它的工作非常干净，用户代码也保持干净。然后这就引出了一个问题：为什么这不是已经在提升????！？！？

可以出于任何目的使用以下代码：）

P.S：在提出这个解决方案的过程中，我有一段时间的启示：“const”只不过是一个特殊情况的语法糖，你可以用正确的类层次结构来实现。是真的，还是我过于概括？

------------------ ConstList.h -----------------------

#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){}
};

------------------ tests.cpp -----------------------

#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

const列表，非const元素访问

2 个答案: