std::map find() liefert immer "Bad Pointer" ?!

[T0bi]

Hi Community,

ich schreibe hier gerade ein simples Programm das mir Werte in eine Map speichern soll. Das Ganze habe ich in Klassen gekapselt. Die Klasse CmdReader ist ein Singleton das die Kommandozeilen-Parameter liest. Weitere Klassen sollen dann über ein Interface der CmdReader-Klasse in der Map nach evtl. Parametern suchen können.
Soweit steht auch alles, nur zur Laufzeit liefert die find() Methode immer "Bad Pointer". Hier mal der Code:

// test2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

// COMMAND LINE READER
class CmdReader {

private:

    static CmdReader *Instance;

	std::map< char*, char* > registry;

    CmdReader() {

    }

public:

    static CmdReader* GetInstance();

	void ParseCommandline( int argc, char *argv[] );

	// return value from registry by key
	float GetValueByKey( char *key );
};

CmdReader* CmdReader::Instance = NULL;

CmdReader* CmdReader::GetInstance() {

    if( Instance == NULL ) {

        Instance = new CmdReader();
    }

    return Instance;
}

void CmdReader::ParseCommandline( int argc, char *argv[] ) {

	// there must be pairs argv_n : key / argv_n+1 : value
	if( (argc % 2) != 0 )
		return;

	for( int i = 0; i < argc; i += 2 )
		this->registry[ argv[i] ] = argv[i + 1];
}

float CmdReader::GetValueByKey( char *key ) {

	std::map< char*, char* >::iterator iter;

	iter = this->registry.find( key );
	if( iter == this->registry.end() )
		return NULL;

	return atof( iter->second );
}

class A {

private:

	int a;

public:

	A() { 

		CmdReader *reader = CmdReader::GetInstance();

		this->a = reader->GetValueByKey( "-a" );
	}

	~A() { }
};

class B {

private:

	int a;
	float b;

public:

	B() { 

		CmdReader *reader = CmdReader::GetInstance();

		this->a = reader->GetValueByKey( "-b" );
		this->b = reader->GetValueByKey( "-c" );
	}

	~B() { }
};

class C {

private:

	float a;

public:

	C() { 

		CmdReader *reader = CmdReader::GetInstance();

		this->a = reader->GetValueByKey( "-d" );
	}

	~C() { }
};

int main(int argc, char* argv[] ) {

	CmdReader *reader = CmdReader::GetInstance();

	reader->ParseCommandline( argc - 1, &argv[1] );

	A *a = new A();
	B *b = new B();
	C *c = new C();

	delete a;
	delete b;
	delete c;

	return 0;
}

float CmdReader::GetValueByKey( char *key ) {

	std::map< char*, char* >::iterator iter;

	iter = this->registry.find( key );  <--- Immer Bad Pointer!
	if( iter == this->registry.end() )
		return NULL;

	return atof( iter->second );
}

Könntet ihr mir da weiter helfen?

Lg Tobi

[EDIT]
Die Map (registry) besitzt Werte:

registry [6]((0x00154cc5 "-a", 0x00154cc8 "1"),(0x00154cca "-b", 0x00154ccd "2"),(0x00154ccf "-c", 0x00154cd2 "3.23"),(0x00154cd7 "-d", 0x00154cda "234.023"),(0x00154ce2 "-e", 0x00154ce5 "34"),(0x00a8d888 "1", 0x00000000 <Bad Ptr>)) std::map<char *,char *,std::less<char *>,std::allocator<std::pair<char * const,char *> > >

[CStoll]

Warum nimmst du denn dort nackte char-Pointer? Abgesehen davon, daß die Default-Vergleichsfunktion für Zeiger nicht wirklich das macht, was du erwartest, und du dich selber um die Gültigkeit kümmern mußt, ist die Arbeit mit nackten Zeigern auch deutlich instabiler. Bessere Lösung dürfte es sein, eine map<string,string> zu verwenden.

[T0bi]

Was meinst du mit nackt?

Lg Tobi

[CStoll]

etwa soviel wie "pur" oder "ohne Hilfsmittel". Bei einem char* mußt du selber darauf achten, ob er auf einen gültigen Wert zeigt. Außerdem mußt du C-Funktionen verwenden zum Vergleichen und Verarbeiten der Strings. Im Gegensatz dazu verpackt std::string die Zeichenkette und liefert dir komfortablen Zugriff darauf.

[Jonas OSDever]

T0bi schrieb:

Was meinst du mit nackt?

Lg Tobi

Er meint, das du bei char-Pointern die ganze Arbeit (Memory-Management, Gültigkeit, Vergleich) selbst übernehmen musst und dir std::string die Arbeit abnimmt.

EDIT: Mist, zu langsam.

[T0bi]

Ok, danke. Ich hab jetzt std::string genommen, damit geht es.

Lg Tobi