6

私がこのようなオブジェクトを持っている場合：

struct Bar {
    std::string const& property();
};

次のように、マルチインデックスコンテナを作成できます。

struct tag_prop {};
typedef boost::multi_index_container<
    Bar,
    boost::multi_index::indexed_by<
        boost::multi_index::ordered_non_unique<
            boost::multi_index::tag<tag_prop>,
            boost::multi_index::const_mem_fun<
                Bar, const std::string&, &Bar::property
            >
        >
    >
    , ... other indexes
> BarContainer;

しかし、私がこのようなクラスを持っている場合：

struct Foo {
   Bar const& bar();
};

オブジェクト.bar().property()のコンテナのインデックスを作成するにはどうすればよいですか？Foo

通常、への呼び出しをネストboost::bindしますが、マルチインデックスコンテナのコンテキストでそれを機能させる方法を理解できません。

4

3 に答える 3

6

ユーザー定義のコンパレーターを提供する代わりに、ユーザー定義のキーエクストラクターを作成できます。

struct FooBarPropertyExtractor
{{
  typedef std :: string result_type;
  const result_type＆oeprator（）（const Foo＆f）
  {{
    f.bar（）。property（）;を返します。
  }
};

..。

typedef boost :: multi_index_container <
        バー、
        boost :: multi_index :: indexed_by <
                boost :: multi_index :: ordered_non_unique <
                        boost :: multi_index :: tag <tag_prop>、
                        FooBarPropertyExtractor
                >>
        >>
        、...その他のインデックス
> FooContainer;

Boost.MultiIndexキーエクストラクタの高度な機能を参照してください

于 2009-11-02T12:50:53.770 に答える
5

Fooの2つのインスタンスを取り、そのoperator（）が両方のインスタンスでFoo :: bar（）を呼び出すことができる述語オブジェクトを作成する必要があると思います。

何かのようなもの

struct MyPredicate
{

    bool operator() (const Foo& obj1, const Foo& obj2) const
    {
        // fill in here
    }
};

その後、 

...
boost::multi_index::ordered_unique<boost::multi_index::tag<tag_prop>, 
    boost::multi_index::identity<Foo>, MyPredicate>,
...

MultiIndexOrderedIndexesリファレンスをご覧ください

于 2009-10-27T02:07:55.520 に答える
1

ラムダを使用して単純なことを行うのが好きなのと同じくらい、これはすぐに縮退する可能性があります:)

あなたの場合、それはもう少し複雑なので、私は自由関数か述語コンパレーターのどちらかに頼ります。

述語には、型をより明確に定義できるという利点があるため、通常、実際に述語を取り込む方が簡単です。

また、読みやすくするために、私は通常、インデックスをtypedefします。これにより、次のようになります。

namespace mi = boost::multi_index;

struct FooComparator
{
  bool operator()(Foo const& lhs, Foo const& rhs) const
  {
    return lhs.bar().property() < rhs.bar().property();
  }
};

typedef mi::ordered_unique <
          mi::tag<tag_prop>,
          mi::identity<Foo>,
          FooComparator
        > foo_bar_index_t;

typedef boost::multi_index_container <
          Foo,
          mi::indexed_by < 
            foo_bar_index_t,
            // ... other indexes
          >
        > foo_container_t;

述語アプローチはより多くの定型コードを必要としますが、それ自体がコンテナー定義から分離されているインデックス定義から比較ロジックをうまく分離することができます。

明確に分離されているため、構造が一目でわかりやすくなります。

于 2009-10-27T09:09:37.170 に答える