crash généré lors de la destruction de hash_map

Question

J'utilise hash_map en application comme

typedef hash_map<DWORD,CComPtr<IInterfaceXX>> MapDword2Interface; 

En application principale J'utilise instance statique de cette carte

static MapDword2Interface m_mapDword2Interface; 

J'ai un vidage sur incident d'un des les machines clientes qui pointent vers le crash en effaçant cette carte

J'ai ouvert ce crash dump et voici l'assemblage pendant le débogage

> call  std::list<std::pair<unsigned long const ,ATL::CComPtr<IInterfaceXX> >,std::allocator<std::pair<unsigned long const ,ATL::CComPtr<IInterfaceXX> > > >::clear 
> mov   eax,dword ptr [CMainApp::m_mapDword2Interface+8 (49XXXXX)] 

Voici le code où le vidage sur incident pointe. Ci-dessous le code est de stl: fichier de liste

void clear() 
     { // erase all 

#if _HAS_ITERATOR_DEBUGGING 
     this->_Orphan_ptr(*this, 0); 
#endif /* _HAS_ITERATOR_DEBUGGING */ 

     _Nodeptr _Pnext; 
     _Nodeptr _Pnode = _Nextnode(_Myhead); 
     _Nextnode(_Myhead) = _Myhead; 
     _Prevnode(_Myhead) = _Myhead; 
     _Mysize = 0; 

     for (; _Pnode != _Myhead; _Pnode = _Pnext) 
      { // delete an element 
      _Pnext = _Nextnode(_Pnode); 
      this->_Alnod.destroy(_Pnode); 
      this->_Alnod.deallocate(_Pnode, 1); 
      } 
     } 

crash pointe vers le this->_Alnod.destroy(_Pnode); déclaration dans le code ci-dessus. Je ne suis pas capable de deviner, ce qui pourrait être une raison.

Des idées ???

Comment est-ce que je peux m'assurer, même s'il y a quelque chose de mal avec la carte, il ne devrait pas planter?

Answer 1

Il est mon hypothèse:

OLE a besoin appel de paires global à l'échelle OleInitialize/OleUninitialize - mais la carte de hachage statique détruit après que le système de gestion de la mémoire OLE a été détruite. Assurez-vous donc que la carte est effacée avant OleUninitialize.