중첩 된 구조체의 멤버 변수에 대한 포인터

Question

아래 클래스의 경우 의 인스턴스 중 하나 인 Bar에 대한 포인터를 어떻게 나타내야합니까?

struct Foo { 
    struct Bar { 
    int qux; 
    } bar1, bar2; 
}; 

나는 boost::multi_index 컨테이너를 사용하고 키 추출이 Class = Foo::Bar, Type = int 및 PtrToMember = &Foo::Bar::qux이 귀하의 경우에는

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

Answer 1

Foo의 부스트 multi_index 컨테이너를 생성하고 qux을 키로 사용한다고 가정합니다. qux은 Foo의 구성원이 아니지만 Foo::bar1 구성원에 대해 인덱싱하고 정렬 된 인덱스에 대한 사용자 지정 비교 술어를 제공하여이 작업을 수행 할 수 있습니다.당신이 ordered_unique 키를 생성하려는 경우 예를 들어, 당신은이처럼 작성합니다

struct compare_foo_bar 
{ 
bool operator()(const Foo::Bar& lhs, const Foo::Bar& rhs) 
{ 
    return lhs.qux < rhs.qux; 
} 
}; 

Answer 2

에 필요한 핵심으로 qux를 사용해야하는 경우가 필요, 그래야 작동합니다.

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

아래의 사용자 의견을 바탕으로 Boost.MultiIndex 튜토리얼의 basic example을 사용 사례와 일치하도록 수정했습니다. 원래의 예는이 struct

/* an employee record holds its ID, name and age */ 
struct employee 
{ 
    int   id; 
    std::string name; 
    int   age; 

    employee(int id_,std::string name_,int age_):id(id_),name(name_),age(age_){} 
    // ... 
}; 

그리고 multi_index 컨테이너 지금

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; 

으로 정의된다, 우리가 employee::name 실제로 중첩 struct Bar의 일원이되도록 employee을 수정할 수 및 employee 포함 말할 다음이 포함되어 Bar의 두 인스턴스

struct employee 
{ 
    int   id; 
    struct Bar 
    { 
    Bar(std::string name) : name(name) {} 

    std::string name; 
    } bar1, bar2; 
    int   age; 

    // ... 
}; 

하지만 당신은 직접 중첩 struct의 데이터 멤버를 표시하기 위해이 선언

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

을 수정할 수 없습니다. 대신, 우리는 employee::Bar 오브젝트를 주문하는 방법이 필요합니다

ordered_non_unique< 
    tag<name>,BOOST_MULTI_INDEX_MEMBER(employee,employee::Bar,bar1)> 

에 선언을 수정, 그래서에 색인 경우, 이러한 변화와 함께 그 정의

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

에 비교 연산자를 추가해야 컨테이너 name 태그를 사용하는 경우 bar1.name 데이터 멤버를 기반으로 주문할 것입니다.

여기에 complete working example이 있습니다.

또한 bar1.name에 포함 된 문자의 역순으로 포함되도록 bar2.name을 초기화하고 name2 태그를 사용하여 색인을 생성하는 옵션을 추가했습니다.

Answer 3

당신이 의지 할 수 compare_foo_bar는 Foo::Bar의 친구이며, 필요로 정의된다

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

user-defined key extractors에 :

struct Foobar1qux 
{ 
    typedef int result_type; 

    int operator()(const Foo &x)const{return x.bar1.qux;} 
}; 

struct Foobar2qux 
{ 
    typedef int result_type; 

    int operator()(const Foo &x)const{return x.bar2.qux;} 
}; 

typedef multi_index_container< 
    Foo, 
    indexed_by< 
    ordered_non_unique<Foobar1qux>, 
    ordered_non_unique<Foobar2qux> 
    > 
> multi_t1; 

더 일반적인 접근법은 O one of the examples에 도시 된 바와 같이 키 추출기 캐스케이드하는 f 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;