Ich möchte eine Char Zeichenkette als Key in einer Map speichern jedoch funktioniert das Finden nicht! Er geht da glaub auf den Pointer nur weiß ich nicht wie ich das umändern muss damit er auf den Inhalt des Char geht?

#include <iostream>
#include <map>
using namespace std;

int main()
{ 
   map< char*, int> months;
	char snr[] = "as";
	char b[] = "as";

  months.insert(std::make_pair(snr,3));

  	std::map< char*, int> ::iterator it ;  
	 for( it = months.begin(); it != months.end(); it++ ) {
		 std::cout << "word: " << it->first << ", count: " << it->second << std::endl;
	 }
	 std::map< char*, int>::iterator i;
	it = months.find(b);
	if(it != months.end()){
		cout<<"ja";
		std::cout <<it->second;		
	}

system("PAUSE");
  return 0;
}

thx downset

mmmm ich würde das aber gerne mit unsigned char machen? hab aber keine ahnung wo ich da ansetzten soll?

also ein Variablenfeld von "unsigned char"s oder wie?
std::vector<unsigned char> würde ich spontan vorschlagen

map<unsigned char*, int> months;

mit einem schlüssel der unsigned char sein sollte?
und dann mit map.find( ) den wenn vorhandenen schlüssel finden?

struct StrCmp
{
    bool operator()(const char* lhs, const char* rhs)
    {
        return strcmp(lhs, rhs) < 0;
    }
};

map<const char*, int, StrCmp> myMap;

struct UStrCmp
{
	bool operator()(const unsigned char* lhs_, const unsigned char* rhs_) const
	{
		unsigned char* lhs = const_cast<unsigned char*>(lhs_);
		unsigned char* rhs = const_cast<unsigned char*>(rhs_);
		while(*lhs != 0 && *rhs != 0)
		{
			if(*lhs < *rhs)
				return true;
			if(*lhs > *rhs)
				return false;
			++lhs;
			++rhs;
		}
		return false;
	}
};

#include <mbstring.h>
using namespace std;

	struct StrCmp 
{ 
    bool operator()(const unsigned char* lhs, const unsigned char* rhs) const
    {		
		if (sizeof(lhs)==sizeof(rhs)){
			return _mbsnicmp(lhs, rhs,sizeof(lhs)) < 0; 
		}else {
			return false;
		}
    } 
};

thx hab was für unsigned char gefunden ->

#include <mbstring.h>
using namespace std;

	struct StrCmp 
{ 
    bool operator()(const unsigned char* lhs, const unsigned char* rhs) const
    {		
		if (sizeof(lhs)==sizeof(rhs)){
			return _mbsnicmp(lhs, rhs,sizeof(lhs)) < 0; 
		}else {
			return false;
		}
    } 
};

WTF??? Das würde ich umschreiben:

bool operator()(const unsigned char* lhs, const unsigned char* rhs) const {		
	if (true == true && true != false && false == false && false != true) {
		return _mbsnicmp(lhs, rhs,sizeof(lhs)) < 0; 
	}
	else if (true != true || true == false || false != false || false == true) {
		return !true == (false != true); 
	}
	else {
		return true ? false : true;
	}
}

Ernsthaft: sizeof(lhs)==sizeof(rhs) ist immer wahr, da du hier nur die Größe zweier Pointer vergleichst und die ist für gleiche Pointer-Typen natürlich immer identisch.

_mbsnicmp(lhs, rhs,sizeof(lhs)) < 0;

Der Aufruf ist sicher nicht das was du willst: du vergleichst höchstens sizeof(unsigned char*) viele Zeichen, auf einer 32-bit-Maschine also 4. Sinnvoller wäre der Einsatz der Funktion _mbsicmp.

Zusammengefasst:

bool operator()(const unsigned char* lhs, const unsigned char* rhs) const {		
   return _mbsicmp(lhs, rhs,) < 0; 
}

#fachmann betreten
* ChanServ gibt Voice-Status an windbird
<Grober__> bool operator()(const unsigned char* lhs, const unsigned char* rhs) const {
<Grober__> if (true == true && true != false && false == false && false != true) {
<Grober__> return mbsnicmp(lhs, rhs,sizeof(lhs)) < 0;
<Grober_> }
<Grober__> else if (true != true || true == false || false != false || false == true) {
<Grober__> return !true == (false != true);
<Grober__> }
<Grober__> else {
<Grober__> return true ? false : true;
<Grober__> }
<Grober__> }
<Besitzer> LINK ?
<Grober__> EGAL !
<Grober__> http://www.c-plusplus.net/forum/viewtopic-var-p-is-1262086.html#1262086

DU HAST DIE HAAAAARE SCHÖÖÖN (und die birne leer)