使用本地静态std :: map的访问冲突 <std::string, std::weak_ptr> 在成员函数中（C ++ 11 / STL）

Question

My Problem is somehow complicated, but I try to describe it simply. I want to implement an static method in one of my classes with an local static member (of type std::map<std::string, std::weak_ptr> ). Every time this method is called, it should look up if theres an object in the map with the passed argument as key. The value that is returned by the method is an std::shared_ptr (constructed from the std::weak_ptr in the map, if the std::weak_ptr can be locked - otherwise an new std::shared_ptr is constructed and added as std::weak_ptr to the std::map ). But I receive 'sometimes' an access violation on the line where I call std::map.find() .

'Sometimes' means: If one std::weak_ptr is added to the map, then erased because it couldn't be locked - and an new std::shared_ptr is constructed, added as std::weak_ptr to the std::map . The next time my static method try to look up inside the std::map there MIGHT BE (occasionally) an Access Violation coming from:

File: Microsoft Visual Studio 11.0\VC\include\xtree
Line: 2092
Method: _Nodeptr _Lbound(const key_type& _Keyval)
Access Violation at reading: '_Nodeptr _Pnode = _Root();'

I can't find any way then to debug the problem better - any help here is greatly appreciated.

Last but not least some code I rewrited to have an short, self-explaining example. But I couldn't reproduce an access violation here so far.

#include <map>
#include <memory>
#include <string>
#include <iostream>

class MyClass{
public:
  MyClass(int a){
    this->a = a;
  }
  virtual ~MyClass(){ }
private:
int a;
};

class MyStaticClass{
public:
  static std::shared_ptr<MyClass> myMethod(const char* string){
    static std::map<std::string, std::weak_ptr<MyClass>> map;
    std::shared_ptr<MyClass> retVal = nullptr;
    std::map<std::string, std::weak_ptr<MyClass>>::iterator iter = map.find(std::string(string));

    if(iter != map.end()){
      retVal = iter->second.lock();
      if(!retVal){
        /* ptr is gone already, so remove it from map */
        iter = map.erase(iter);
      }
    }
    if(!retVal){
      /* not found in map OR erased - need to be created again */
      retVal = std::make_shared<MyClass>(atoi(string));
      std::weak_ptr<MyClass> weakRetVal = retVal;
      map.insert(std::make_pair(std::string(string), weakRetVal));
    }
    return std::move(retVal);
  }
};

int main(int argc, char* argv[]){
  {
    std::shared_ptr<MyClass> myIntPointer = MyStaticClass::myMethod("1");
  }
  {
    std::shared_ptr<MyClass> myIntPointer = MyStaticClass::myMethod("1");
  }
  {
    std::shared_ptr<MyClass> myIntPointer = MyStaticClass::myMethod("1");
  }
  return 0;
}

Compiler / Platform: VS 2012 / Windows 8

Edit: I found out so far, that the size of 'map' is always 0 again (at least according to the debugger), when this fault happens. So ie I start the program with map uninitalized (size is 0 of course). Then entrys are added using myMethod() - the size of the map is ie 4. Now the std::weak_ptr expires and I make again calls to myMethod(). The debugger shows now map.size() would be 0 again (map entrys are never removed, so this shouldn't be possible).

Edit2: When the size should be 0x00000004 there is also the case, that the debugger shows 0xff000004 as size (and of course most 'entries' can't be displayed then). Could there be any 32bit/64bit issue involved with local static storage?

Answer 1

I found the soulution for my problem like suggested by the comments in an stack/heap corruption from a different piece of code. Just in case someone with a similiar problem will find this question one day, I will briefly describe what were going wrong exactly and my steps to found the cause out.

1.) Because I didn't faced that problem when using an plain global function and an global static std::map it indicates that there were a problem in an similiar storage scope (local function static). The reason why that access violation didn't happened for me when using an global static std::map was simply, that my stack/heap corruption taked place with an different local function static object in a different class. So side effects to objects in the same storage scope are more likely than side effects with different storage scopes (ie local function static VS global static).

2.) I just executed my code plenty of times to recognize a pattern when exactly the access violation happens and what my steps are to reproduce that behaviour. Then I noticed, that my access violations happened with increased regularity if I was pressing an key on the keyboard. That seemed already like an very strange side effect to me and made me check specially my input classes.

3.) There I found the fatal piece of code: I used the singleton approach for one of my input classes (which means: the class got an static getInstance() method which returns an local function static object of the class itself). As a reminder: My access violation also happened with an local function static object. Very suspiciously... Looking deeper through this class, I found an member to store the actual key values in an array. The array size was declared with the use of some obscure macros which resolved simplified to something like:

unsigned char keyValues[sizeof(unsigned short)];

But of course the sizeof() operator doesn't return the maximum value of an type - but rather the size in Bytes (ie 2 on x86 & x64 - or in some cases 4 because of alignment). So if I replaced sizeof(unsigned short) by 65536 (or USHRT_MAX from <climits> ) my code runs clenaly without any access violtion... :( Stupid mistake with fatal consequences...