hi joaquin, a) here's a ready to use code snippet (see below). i isolating the problem by writing the snippet to the reuse of objects or using local temporary objects; i thought multi_index maps store copies of data objects, that where inserted. am i wrong? b) why it isn't possible to write (with "?" is a class attribute or template parameter; see snippet): template<typename MAP, typename ELM, typename SC1, typename IT1, typename SC2, typename IT2> const ELM *tCanMap<MAP,ELM,SC1,IT1,SC2,IT2>::getmapelm(STRING stNme) const { IT1 itr = this->_mpMap.get<?>().find(stNme); if ( itr != this->_mpMap.get<?>().end() ) { return &(*itr); } } thank you daniel //--- BEG ---------------------------------------------------------------------- #if defined(_Windows) || defined(_MSC_VER) || defined (__GNUC__) #define STRICT #include <windows.h> #endif #include <string> #define BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING #define BOOST_MULTI_INDEX_ENABLE_SAFE_MODE #include <boost/multi_index_container.hpp> #include <boost/multi_index/member.hpp> #include <boost/multi_index/mem_fun.hpp> #include <boost/multi_index/ordered_index.hpp> #include <boost/multi_index/hashed_index.hpp> //------------------------------------------------------------------------------ #define UINT32 unsigned long #define STRING std::string //------------------------------------------------------------------------------ // choose one //#define VERSION01 //#define VERSION02 //#define VERSION03 //#define VERSION04 //------------------------------------------------------------------------------ template<typename MAP, typename ELM, typename SC1, typename IT1, typename SC2, typename IT2> class tCanMap { protected: mutable MAP _mpMap; // map mutable SC1 *_scNme; // sorting criteria name ... have to init from derived class mutable SC2 *_scDat; // sorting criteria name ... have to init from derived class public: tCanMap (); MAP &getmap () const; UINT32 setmapelm (ELM val); #if defined (VERSION01) || defined (VERSION02) const ELM *getmapelm (STRING stNme) const; const ELM *getmapelm (UINT32 uiDat) const; #endif }; template<typename MAP, typename ELM, typename SC1, typename IT1, typename SC2, typename IT2> tCanMap<MAP,ELM,SC1,IT1,SC2,IT2>::tCanMap() { this->_scNme = NULL; this->_scDat = NULL; } template<typename MAP, typename ELM, typename SC1, typename IT1, typename SC2, typename IT2> MAP &tCanMap<MAP,ELM,SC1,IT1,SC2,IT2>::getmap() const { return this->_mpMap; } template<typename MAP, typename ELM, typename SC1, typename IT1, typename SC2, typename IT2> UINT32 tCanMap<MAP,ELM,SC1,IT1,SC2,IT2>::setmapelm(ELM val) { if (this!=NULL) { this->_mpMap.insert(val); return 0; } return 1; } #if defined (VERSION01) || defined (VERSION02) template<typename MAP, typename ELM, typename SC1, typename IT1, typename SC2, typename IT2> const ELM *tCanMap<MAP,ELM,SC1,IT1,SC2,IT2>::getmapelm(STRING stNme) const { try { if ( this!=NULL && this->_scNme!=NULL ) { IT1 itr = this->_scNme->find(stNme); if ( itr != this->_scNme->end() ) { return &(*itr); } } } catch(...) {} return NULL; } template<typename MAP, typename ELM, typename SC1, typename IT1, typename SC2, typename IT2> const ELM *tCanMap<MAP,ELM,SC1,IT1,SC2,IT2>::getmapelm(UINT32 uiDat) const { try { if ( this!=NULL && this->_scDat!=NULL ) { IT2 itr = this->_scDat->find(uiDat); if ( itr != this->_scDat->end() ) { return &(*itr); } } } catch(...) {} return NULL; } #endif //------------------------------------------------------------------------------ class cClass00 { private: STRING _nme; UINT32 _dat; public: cClass00() {} cClass00(STRING nme, UINT32 dat) { this->_nme=nme; this->_dat=dat; } STRING getnme () const { return this->_nme; } UINT32 getdat () const { return this->_dat; } }; typedef boost::multi_index_container < cClass00, boost::multi_index::indexed_by < boost::multi_index::hashed_unique < BOOST_MULTI_INDEX_CONST_MEM_FUN(cClass00,STRING,getnme) >, boost::multi_index::ordered_unique < BOOST_MULTI_INDEX_CONST_MEM_FUN(cClass00,UINT32,getdat) >

mClass00;

typedef mClass00::nth_index<0>::type mClass00ByNme; typedef mClass00ByNme::iterator mClass00ByNmeItr; typedef mClass00::nth_index<1>::type mClass00ByDat; typedef mClass00ByDat::iterator mClass00ByDatItr; //------------------------------------------------------------------------------ class cClass01 : public tCanMap<mClass00,cClass00,mClass00ByNme,mClass00ByNmeItr,mClass00ByDat,mClass00ByDatItr> { private: STRING _nme; UINT32 _dat; public: cClass01() {} cClass01(STRING nme, UINT32 dat) { this->_nme=nme; this->_dat=dat; this->_scNme = &(this->_mpMap.get<0>()); this->_scDat = &(this->_mpMap.get<1>()); } STRING getnme() const { return this->_nme; } UINT32 getdat() const { return this->_dat; } #if defined (VERSION03) || defined (VERSION04) const cClass00 *getmapelm (STRING stNme) const { try { if ( this!=NULL ) { mClass00ByNmeItr itr = this->_mpMap.get<0>().find(stNme); if ( itr != this->_mpMap.get<0>().end() ) { return &(*itr); } } } catch(...) {} return NULL; } const cClass00 *getmapelm (UINT32 uiDat) const { try { if ( this!=NULL ) { mClass00ByDatItr itr = this->_mpMap.get<1>().find(uiDat); if ( itr != this->_mpMap.get<1>().end() ) { return &(*itr); } } } catch(...) {} return NULL; } #endif }; typedef boost::multi_index_container < cClass01, boost::multi_index::indexed_by < boost::multi_index::hashed_unique < BOOST_MULTI_INDEX_CONST_MEM_FUN(cClass01,STRING,getnme) >, boost::multi_index::ordered_unique < BOOST_MULTI_INDEX_CONST_MEM_FUN(cClass01,UINT32,getdat) >

mClass01;

typedef mClass01::nth_index<0>::type mClass01ByNme; typedef mClass01ByNme::iterator mClass01ByNmeItr; typedef mClass01::nth_index<1>::type mClass01ByDat; typedef mClass01ByDat::iterator mClass01ByDatItr; //------------------------------------------------------------------------------ class cClass02 : public tCanMap<mClass01,cClass01,mClass01ByNme,mClass01ByNmeItr,mClass01ByDat,mClass01ByDatItr> { public: cClass02() { this->_scNme = &(this->_mpMap.get<0>()); this->_scDat = &(this->_mpMap.get<1>()); } #if defined (VERSION03) || defined (VERSION04) const cClass01 *getmapelm (STRING stNme) const { try { if ( this!=NULL ) { mClass01ByNmeItr itr = this->_mpMap.get<0>().find(stNme); if ( itr != this->_mpMap.get<0>().end() ) { return &(*itr); } } } catch(...) {} return NULL; } const cClass01 *getmapelm (UINT32 uiDat) const { try { if ( this!=NULL ) { mClass01ByDatItr itr = this->_mpMap.get<1>().find(uiDat); if ( itr != this->_mpMap.get<1>().end() ) { return &(*itr); } } } catch(...) {} return NULL; } #endif }; //------------------------------------------------------------------------------ int main(void) { #if defined (VERSION01) || defined (VERSION03) // works fine in any case cClass00 objClass00_01 = cClass00( "elm00_01", 1 ); cClass00 objClass00_02 = cClass00( "elm00_02", 2 ); cClass00 objClass00_03 = cClass00( "elm00_03", 3 ); cClass00 objClass00_04 = cClass00( "elm00_04", 4 ); cClass01 objClass01_01 = cClass01( "elm01_01", 11 ); cClass01 objClass01_02 = cClass01( "elm01_02", 12 ); objClass01_01.setmapelm( objClass00_01 ); objClass01_01.setmapelm( objClass00_02 ); objClass01_02.setmapelm( objClass00_03 ); objClass01_02.setmapelm( objClass00_04 ); cClass02 *ptrClass02_01 = new cClass02(); ptrClass02_01->setmapelm( objClass01_01 ); ptrClass02_01->setmapelm( objClass01_02 ); printf("START\n"); printf("\n"); printf( "1. try: %02d\n", ptrClass02_01->getmapelm("elm01_01")->getdat() ); printf( "2. try: %02d\n", ptrClass02_01->getmapelm("elm01_02")->getdat() ); printf("\n"); printf( "3. try: %02d\n", ptrClass02_01->getmapelm("elm01_01")->getmapelm("elm00_01")->getdat() ); printf( "4. try: %02d\n", ptrClass02_01->getmapelm("elm01_02")->getmapelm("elm00_04")->getdat() ); printf("\n"); printf( "5. try: %s\n", ptrClass02_01->getmapelm("elm01_01")->getmapelm(2)->getnme().c_str() ); printf( "6. try: %s\n", ptrClass02_01->getmapelm("elm01_02")->getmapelm(3)->getnme().c_str() ); printf("\n"); printf("DONE\n"); #elif defined (VERSION02) || defined (VERSION04) // run into segvault if object become overwritten OR // object for filling multi_index is only a local variable of a filling function cClass02 *ptrClass02 = new cClass02(); cClass01 objClass01; cClass00 objClass00; objClass01 = cClass01("elm01_01", 11); objClass00 = cClass00("elm00_01", 1); objClass01.setmapelm(objClass00); objClass00 = cClass00("elm00_02", 2); objClass01.setmapelm(objClass00); objClass01 = cClass01("elm01_02", 12); objClass00 = cClass00("elm00_03", 4); objClass01.setmapelm(objClass00); objClass00 = cClass00("elm00_04", 3); objClass01.setmapelm(objClass00); ptrClass02->setmapelm(objClass01); printf("START\n"); printf( "dat = %d\n", ptrClass02->getmapelm("elm01_01")->getdat() ); // seg_vault // printf( "dat = %d\n", ptrClass02->getmapelm("elm01_02")->getdat() ); // works fine printf("DONE\n"); #endif } //--- END ---------------------------------------------------------------------- ______________________________________________________ Bis 50 MB Dateianhänge? Kein Problem! http://freemail.web.de/club/landingpage.htm/?mc=025556