Si j'ai un objet comme celui-ci:
struct Foo {
Bar const& bar();
};
3 Réponses :
Je pense que vous devez créer un objet de prédicat qui prend deux instances de FOO et son opérateur () peut appeler FOO :: bar () sur les deux instances.
Quelque chose comme p> Utilisez P> ...
boost::multi_index::ordered_unique<boost::multi_index::tag<tag_prop>,
boost::multi_index::identity<Foo>, MyPredicate>,
...
Autant que j'aime utiliser Lambdas pour faire des choses simples, cela peut rapidement dégénérer :)
Dans votre cas, car il est un peu plus compliqué, je vous fierais soit sur une fonction libre ou un comparateur de prédicat. p>
Le prédicat présente l'avantage de définir des types plus clairement, il est généralement plus facile de l'apporter en réalité. p>
aussi, pour l'amour de la lisibilité, j'ai généralement typé de mon index, qui donne: P >
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;
D'accord. J'utilise généralement des alias Typefs et des espaces de noms également, mais cela semblait trop compliqué pour cet exemple trivial, alors je les ai effondrée à une seule déclaration.
Plutôt que de fournir un comparateur défini par l'utilisateur, vous pouvez écrire un extracteur de clé défini par l'utilisateur : xxx voir