Fatal编程技术网
  • cplusplus/
  • C++ 指向嵌套结构中成员变量的指针

C++ 指向嵌套结构中成员变量的指针

c++ boost

C++ 指向嵌套结构中成员变量的指针,c++,boost,boost-multi-index,C++,Boost,Boost Multi Index,对于下面的类，如何表示指向Bar实例之一的成员变量qux的指针 struct Foo { struct Bar { int qux; } bar1, bar2; }; 当我使用boost:：multi_index容器并且需要使用qux作为密钥时，这是需要的，这是密钥提取器中需要的 template<class Class,typename Type,Type Class::*PtrToMember> struct boost::multi_index::member

对于下面的类，如何表示指向
Bar
实例之一的成员变量
qux
的指针

struct Foo {
  struct Bar {
    int qux;
  } bar1, bar2;
};
当我使用
boost:：multi_index
容器并且需要使用
qux
作为密钥时，这是需要的，这是密钥提取器中需要的

template<class Class,typename Type,Type Class::*PtrToMember>
struct boost::multi_index::member

模板
结构boost:：多索引：：成员
在您的例子中，您有
Class=Foo:：Bar
、
Type=int
和
ptrtomber=&Foo:：Bar:：qux
，因此这应该可以工作

boost::multi_index::member<Foo::Bar, int, &Foo::Bar::qux>
而
多索引
容器定义为

typedef multi_index_container<
  employee,
  indexed_by<
    ordered_unique<
      tag<id>,  BOOST_MULTI_INDEX_MEMBER(employee,int,id)>,
    ordered_non_unique<
      tag<name>,BOOST_MULTI_INDEX_MEMBER(employee,std::string,name)>,
    ordered_non_unique<
      tag<age>, BOOST_MULTI_INDEX_MEMBER(employee,int,age)> >
> employee_set;
但您不能修改此声明

ordered_non_unique<
      tag<name>,BOOST_MULTI_INDEX_MEMBER(employee,std::string,name)>
我们需要一种对
employee:：Bar
对象进行排序的方法，因此在其定义中添加一个比较运算符

struct Bar
{
  // ...
  bool operator<(Bar const& other) const { return name < other.name; }
};

结构栏
{
// ...

bool操作符在您的例子中，您有
Class=Foo:：Bar
，
Type=int
和
ptrtomber=&Foo:：Bar:：qux
，所以这应该可以工作


boost::multi_index::member<Foo::Bar, int, &Foo::Bar::qux>


而
多索引
容器定义为


typedef multi_index_container<
  employee,
  indexed_by<
    ordered_unique<
      tag<id>,  BOOST_MULTI_INDEX_MEMBER(employee,int,id)>,
    ordered_non_unique<
      tag<name>,BOOST_MULTI_INDEX_MEMBER(employee,std::string,name)>,
    ordered_non_unique<
      tag<age>, BOOST_MULTI_INDEX_MEMBER(employee,int,age)> >
> employee_set;


但您不能修改此声明


ordered_non_unique<
      tag<name>,BOOST_MULTI_INDEX_MEMBER(employee,std::string,name)>


我们需要一种对
employee:：Bar
对象进行排序的方法，因此在其定义中添加一个比较运算符


struct Bar
{
  // ...
  bool operator<(Bar const& other) const { return name < other.name; }
};



结构栏
{
// ...

bool操作符我假设其意图是创建一个包含
Foo
s的boost多索引容器，并使用
qux
作为键。尽管
qux
不是
Foo
的成员，但您可以通过在成员
Foo:：bar1
上建立索引并为有序索引提供自定义比较谓词来实现这一点例如，如果您试图创建一个
ordered\u unique
键，您可以这样编写：


ordered_unique<member<Foo, Foo::Bar, &Foo::bar1>, compare_foo_bar>



我假设其意图是创建一个包含
Foo
s的boost多_索引容器，并使用
qux
作为键。尽管
qux
不是
Foo
的成员，但可以通过在成员
Foo:：bar1
上建立索引并为有序索引提供自定义比较谓词来实现这一点。例如，如果如果您试图创建一个
ordered_unique
键，您可以这样编写：


ordered_unique<member<Foo, Foo::Bar, &Foo::bar1>, compare_foo_bar>


你可以求助于：


struct Foobar1qux
{
typedef int result_type；
int运算符（）（const Foo&x）const{return x.bar1.qux；}
};
结构Foobar2qux
{
typedef int result_type；
int运算符（）（const Foo&x）const{return x.bar2.qux；}
};
typedef多索引容器<
福，
索引<
有序非唯一，
有序非唯一
>
>多功能t1；


一种更通用的方法是级联键提取器，如Boost.MultiIndex文档中的所示：


template<class KeyExtractor1,class KeyExtractor2>
struct key_from_key
{
public:
  typedef typename KeyExtractor1::result_type result_type;

  key_from_key(
    const KeyExtractor1& key1_=KeyExtractor1(),
    const KeyExtractor2& key2_=KeyExtractor2()):
    key1(key1_),key2(key2_)
  {}

  template<typename Arg>
  result_type operator()(Arg& arg)const
  {
    return key1(key2(arg));
  }

private:
  KeyExtractor1 key1;
  KeyExtractor2 key2;
};

typedef multi_index_container<
  Foo,
  indexed_by<
    ordered_non_unique<
      key_from_key<
        member<Foo::Bar,int,&Foo::Bar::qux>,
        member<Foo,Foo::Bar,&Foo::bar1>
      >
    >,
    ordered_non_unique<
      key_from_key<
        member<Foo::Bar,int,&Foo::Bar::qux>,
        member<Foo,Foo::Bar,&Foo::bar2>
      >
    >
  >
> multi_t2;



模板
结构键\u来自\u键
{
公众：
typedef typename键提取器1:：result\u type result\u type；
钥匙从钥匙(
常量KeyExtractor1&key1=KeyExtractor1（），
常量KeyExtractor2&key2_=KeyExtractor2（））：
键1（键1），键2（键2）
{}
样板
结果类型运算符（）（参数和参数）常量
{
返回键1（键2（arg））；
}
私人：
钥匙拔出器1钥匙1；
键提取器2键2；
};
typedef多索引容器<
福，
索引<
有序非唯一<
钥匙从钥匙<
成员
成员
>
>,
有序非唯一<
钥匙从钥匙<
成员
成员
>
>
>
>多相t2；

您可以求助于：


struct Foobar1qux
{
typedef int result_type；
int运算符（）（const Foo&x）const{return x.bar1.qux；}
};
结构Foobar2qux
{
typedef int result_type；
int运算符（）（const Foo&x）const{return x.bar2.qux；}
};
typedef多索引容器<
福，
索引<
有序非唯一，
有序非唯一
>
>多功能t1；


一种更通用的方法是级联键提取器，如Boost.MultiIndex文档中的所示：


template<class KeyExtractor1,class KeyExtractor2>
struct key_from_key
{
public:
  typedef typename KeyExtractor1::result_type result_type;

  key_from_key(
    const KeyExtractor1& key1_=KeyExtractor1(),
    const KeyExtractor2& key2_=KeyExtractor2()):
    key1(key1_),key2(key2_)
  {}

  template<typename Arg>
  result_type operator()(Arg& arg)const
  {
    return key1(key2(arg));
  }

private:
  KeyExtractor1 key1;
  KeyExtractor2 key2;
};

typedef multi_index_container<
  Foo,
  indexed_by<
    ordered_non_unique<
      key_from_key<
        member<Foo::Bar,int,&Foo::Bar::qux>,
        member<Foo,Foo::Bar,&Foo::bar1>
      >
    >,
    ordered_non_unique<
      key_from_key<
        member<Foo::Bar,int,&Foo::Bar::qux>,
        member<Foo,Foo::Bar,&Foo::bar2>
      >
    >
  >
> multi_t2;



模板
结构键\u来自\u键
{
公众：
typedef typename键提取器1:：result\u type result\u type；
钥匙从钥匙(
常量KeyExtractor1&key1=KeyExtractor1（），
常量KeyExtractor2&key2_=KeyExtractor2（））：
键1（键1），键2（键2）
{}
样板
结果类型运算符（）（参数和参数）常量
{
返回键1（键2（arg））；
}
私人：
钥匙拔出器1钥匙1；
键提取器2键2；
};
typedef多索引容器<
福，
索引<
有序非唯一<
钥匙从钥匙<
成员
成员
>
>,
有序非唯一<
钥匙从钥匙<
成员
成员
>
>
>
>多相t2；

谢谢你的评论，但我认为它不起作用。如果在Foo中有两个Bar成员，你如何在不引用哪个Bar实例的情况下区分这两个Barcheck@xiaodong我决定第一次使用Boost.MultiIndex，并发布了一个新的示例，我认为它代表了您描述的用例。我还冒昧地将您的评论中的详细信息添加到您的问题中。请确保描述准确无误。感谢您的评论，但我认为它不起作用。假设Foo中有两个酒吧成员，您如何区分这两个酒吧而不引用要使用的酒吧实例check@xiaodong我决定和Boost一起玩多人游戏这是第一次索引，并且发布了一个新的示例，我认为它代表了您描述的用例。我还冒昧地将您的评论中的详细信息添加到您的问题中。请确保描述准确。为什么还要再问这个问题？我在不到一个小时前刚刚看到了完全相同的问题。@Bot为什么假设它是asked当它显然是由社区成员编辑时再次出现？[image]（）（如果你不想看到“活动排名”问题，请停留在“最新问题”选项卡上。）为什么再次问这个问题？我在不到一个小时前才看到完全相同的问题。@Bot为什么假设它显然是由社区成员编辑时再次出现？[image]（）（如果不想看到“活动排名”问题，只需停留在“最新问题”选项卡上。）