void MyClass::fillMap(const char* dir, map<char*,myVal*>* _map);

Ich plane jetzt damit rekursiv durch die directories zu klappern, und bestimmte Teile bestimmter Files einzulesen, welche in der Map abgelegt werden. Mein Code sieht so aus:

void MyClass::fillMap(const char* dir, map<char*,myVal*>* _map)
{
	DIR* pDir;
	dirent* dp;
	string sCurDir = dir;
	string sCurFile;
      myVal* values = new myVal();

	if(sCurDir.rfind("/") == sCurDir.length()-1)
	{
		sCurDir = sCurDir.substr(0,sCurDir.length()-1);
	}

	string::size_type pos = sCurDir.rfind("/");
	string sCurKey = sCurDir.substr(pos+1,sCurDir.length()-1);

	printf("Entering: %s\n",sCurDir.c_str());

	pDir = opendir(sCurDir.c_str());
	while((dp = readdir(pDir)) != NULL)
	{
		if(dp->d_type == DT_DIR)
		{
			if(strcmp(dp->d_name,".") && strcmp(dp->d_name,".."))
			{
				sCurDir += "/";
				sCurDir += dp->d_name;
				fillMap(curDir.c_str(),_map);
                        sCurDir = dir;

			}
		}
		else if(dp->d_type == DT_REG)
		{
			sCurFile = sCurDir;
			sCurFile += "/";
			sCurFile += dp->d_name; 
			myVal = loadValue(sCurFile);
			//printf("file: %s\n",sCurFile.c_str());
		}
	} 
	(void)closedir(pDir); 

	printf("INSERTING!\n");
	_map->insert(make_pair((char*)sCurKey.c_str(),myVal));
	printf("key: %s,size: %i\n",sCurKey.c_str(),_map->size());

      /*nur zum testen*/
	map<char*,CSprite*>::iterator it;
	for(it = _map->begin(); it != _map->end(); it++)
	{
		printf("%s\n",it->first);
	}
	return;
}

Eigentlich sollte jetzt jede Value mit dem Verzeichnis-Namen als Key in der Map abgelegt sein. Doch nur der letzte Verzeichnisname ist am Ende als Key enthalten, und dann noch 2Mal irgendwelcher Garbage. Insgesamt werden jedoch 16 Inserts gemacht (sind ja auch 16 directories). Was mache ich denn nur falsch?

Wäre nett wenn mir jemand helfen könnte,
Bye!

Dein sCurKey ist nur in der Funktion gültig. Nach dem Verlassen der Funktion wird der std::string zerstört, du merkst dir in der std::map also einen Zeiger auf ungültigen Speicher, ich vermute mal, dass daher dein Müll kommt.

map<std::string,myVal*>

Das wäre besser.
Bei myVal habe ich jetz nicht geschaut, auch hier musst du drauf achten, dass du einen Zeiger speicherst und der Speicherbereich auch wirklich noch gültig ist.

myVal ist doch der Name des Types und nicht die Variable oder?

myVal* values = new myVal();

also müsstest du ja values reinhauen, weil das der Zeiger ist.

Ansonsten new benutzt du ja schon, das ist richtig so. Darfst dann natürlich nicht das delete vergessen an entsprechender Stelle.

void MyClass::fillMap(const char* dir, map<char*,myVal*>* _map, myVal** vals)
{

static int count = 0;
...
/*an geeigneter Stelle*/
vals[count] = new myVal();
...
}

Das Teil liefert auch wirklich einen Zeiger zurück?