const list、const要素以外のアクセス

Question

私はブースト介入コンテナに問題があります。

私のクラスの中には、いくつかのオブジェクトの侵入リストがあり、その寿命は厳密に管理されています。オブジェクト自体は、クラスのユーザーによって変更されることを意図していますが、リスト自体を変更することは想定されていません。そのため、私は、リストのアクセスを、getList関数を介して提供するだけです。これは、侵入リストのconstバージョンを返します。

const侵入型リストの問題は、反復しようとしているときに要素がconstになることです。しかし、ユーザーはアイテムを繰り返し処理して変更できる必要があります。

私は、侵入型コンテナを使用する最大の利点の1つを無効にするため、ユーザーに与えるポインタのリストを別に保管したくありません。つまり、一定時間内にアイテムをコンテナから削除することができますが、唯一のアイテムはアイテムへのポインタです。

C++の制限のために私のリストの非constバージョンを与えるのは悲しいことです。ですから問題は：追加の侵入型コンテナの特殊なconstバージョンがありますが、これは魔法のようにアイテムの変更を許可していますが、リスト自体は変更できません。

Answer 1

して、別の項目へのアクセス権を与え、リストを返す必要はありません。 Andyのソリューションは、効率的な方法でアイテムを繰り返し処理する必要がない場合に便利です。しかし、私はconst std :: listと意味的に同等なものを求めていました。おそらくそれは過剰ですが、パフォーマンスは最適化後にほとんど違いはありません：

ConstListという名前のクラスでプライベートに拡張するのは、BOOST_FOREACHを反復させても何も変更しないようにするだけです誰でも。私はアイテムから子クラスにリストフックを移動したので、アイテムオブジェクトを使ってリストを変更することはできません。フックを子クラスに格納していますが、イテレータはアイテムクラスへの参照を返しています。私はこのソリューションを2つのテンプレート付きクラスにコーディングして、どのアイテムクラスにも簡単に適用できます。

私は、ConstListクラスとHookedItemクラスの後にtests.cppというヘッダーファイルを作成し、テストとベンチマークに使用しました。 ConstListクラスは反復処理中に同等のパフォーマンスを持つことがわかります。

非常にきれいに動作し、ユーザーコードもきれいに保たれます。それで、これは質問をする：どうしてこれはすでにブーストになっていないのですか？！？！？

は、いかなる目的のために、次のコードを使用してお気軽に:)

をPS：この解決策を考え出すながら、私は啓示の瞬間を持っていた：「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){} 
}; 

------------------テスト。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 

Answer 2

あなたはOK、私は問題の完全なソリューションを設計しました参照