[b]coding wegen Übersichtlichkeit nach unten verschoben..wurde editiert[/b]

siehe auch kommentare ... hilfe erbeten und wäre dankbar mit einen mentalen dankeschön
gruss sten

ps. wenn ich grad dabei bin ... gibt es auch nee möglichkeit lexikographisch zu sortieren, dh. nicht nur rein nach ASCII weil bei der map-sortierung geht es nur ASCII- mässig ..

Zweitens steht der Lesezeiger deiner Wörterbuch-Datei am Ende der Print_Eng() auf deren Dateiende. Das heißt, bevor du irgendwas sinnvolles mit der Datei machen kannst, mußt du deren Fehlerflag aufräumen (clear()) und sie wieder zurückdrehen auf Anfang (seekg(0) oder rewind()).

Erstmal solltest du die map(s) nur einmal einlesen und dann im Hauptprogramm lagern - an die statischen Variablen kommt nämlich niemand als die jeweiligen Funktionen heran.

okdoki da haste recht.. hab ich gemacht

#pragma warning( disable : 4244 )

#include "stdafx.h"

#include <cstdlib> // contains prototypes for functions srand and rand
using std::rand;
using std::srand;
#include <ctime> // contains prototype for function time
using std::time;

#include <string>
using std::string;
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
using std::ios;
using std::cerr;

#include <iomanip>
using std::setw;
using std::left;
using std::right;

#include <map>
typedef std::map<string, string, std::less<string>> StringMap;

#include <algorithm>
#include <iterator>

#include <fstream>
using std::ifstream;
using std::ostream;

enum Choices{PRINT_ENG='1', PRINT_GER='2', ENG_WORD='3', GER_WORD='4', END='5'};

char menu();
void Print_Eng(StringMap&);
void Print_Ger(StringMap&);
void Eng_Word(StringMap&,int);
void Ger_Word(StringMap&,int);
int random(int count);

int _tmain(int argc, _TCHAR* argv[])
{	

	ifstream infile("data.txt", ios::in);
	 if(!infile)
		{
			cerr<<"File could not be opened"<<endl;
			exit(1);
		}
	 StringMap Eng_wordPairs;
	 StringMap Ger_wordPairs;
	 string english, german;
    static int counter=-1; //zählt eins zuviel ?
	while(infile)
	 {
		 getline(infile, english, ',');
		 getline(infile, german, '\n');
		 Eng_wordPairs.insert(StringMap::value_type(english,german)); 
		 Ger_wordPairs.insert(StringMap::value_type(german,english));
		 ++counter;	
	}
	int whichword=random(counter);

	char choice;
	while((choice=menu())!=END)
	{
		switch(choice)
		{
		case PRINT_ENG:
			Print_Eng(Eng_wordPairs);
			break;

		case PRINT_GER:
			Print_Ger(Ger_wordPairs);
			break;

		case ENG_WORD:
			Eng_Word(Eng_wordPairs, whichword);
			break;

		case  GER_WORD:
			Ger_Word(Ger_wordPairs, whichword);
			break;

		default:
			cerr<<"Incorrect choice, try again!"<<endl;
			menu();
		}//end switch
	}//endwhile

	infile.close();
	return 0;
}
int random(int count)
{
	srand( time( 0 ) );
	int r = 1 + rand() % count;
	return r;
}

char menu()
{
	cout<<"****Vocable-Trainee(GER<->ENG)****"<<"\n";
	cout<<"**************Menu****************"<<endl;
	cout<<"1 english listing"<<"\n";
	cout<<"2 german listing"<<"\n";
	cout<<"3 random english vocable"<<"\n";
	cout<<"4 random german vocable"<<"\n";
    cout<<"5 End Programm"<<"\n";
	char menuChoice;
	cout<<"your choice: ";
	cin>>menuChoice;
	return menuChoice;
}

void Print_Eng(StringMap& Eng_wordPairs)
{
  cout<<"\nEnglish:"<<endl; 
	for(StringMap::const_iterator iter=Eng_wordPairs.begin();
		 iter!=Eng_wordPairs.end(); ++iter)
		 cout<<left<<setw(25)<<iter->first<<":"<<setw(25)<<left<<iter->second<<"\n";
}

void Print_Ger(StringMap& Ger_wordPairs)
{
   cout<<"\nDeutsch:"<<endl;
	 for(StringMap::const_iterator iter=Ger_wordPairs.begin();
		 iter!=Ger_wordPairs.end(); ++iter)
		 cout<<left<<setw(25)<<iter->first<<":"<<setw(25)<<left<<iter->second<<"\n";	
}

void Eng_Word(StringMap& Eng_wordPairs,int count)
{}

void Ger_Word(StringMap& Ger_wordPairs,int)
{}

jetzt bleibt noch das problem mit dem lexikalischen ordnen hmmm ? hab da bisher in meiner literatur nichts besseres gefunden (zur zeit sortiert es nur nach ASCII zeichen, d.h. erst werden kleinbuchstaben sortiert dann grossbuchstaben)
achja gibt es nee möglichkeit wie ich zugriff auf ein beliebiges element bekomme? (möchte nämlich ein zufallswort generieren)
oder muss ich tatsächlich vorwärts iterieren :(.. wollte mit ner zufallsfunktion
ein index generieren und zugreifen aber leider gibt es bei map anscheinend keine indizierung (naja hätte auch vector nehmen können aber will das mit map machen )

gruss sten
ps. danke schonmal für eure hilfe

jetzt bleibt noch das problem mit dem lexikalischen ordnen hmmm ?

das ist net ganz so einfach, dafür musst du die vergleichsfunktion separat angeben

das geht in etwa so:

#include <locale>//das muss zusätzlich rein

struct lexicalCompare
{
  bool operator()(const string& s1, const string& s2) const
  {
    //jetzt wirds ätzend
    const std::collate<char>& cmp=std::use_facet<std::collate<char> >(std::locale());
    return cmp.compare(&*s1.begin(),&*s1.end(),&*s2.begin(),&*s2.end())<0;
  }
};
//die map
typedef std::map<string, string, lexicalCompare> StringMap;

achja gibt es nee möglichkeit wie ich zugriff auf ein beliebiges element bekomme? (möchte nämlich ein zufallswort generieren)
oder muss ich tatsächlich vorwärts iterieren

jep, musst du. in einer map ist sowas was du willst nicht schnell zu implementieren, und bei der stl geht es um geschwindigkeit.

Debug Assertion Failed!

Progamm: blala pfadangabe...

Expression:string iterator not deferencable

For information on how your programm can cause assertion
falure, see... docublabla

void Eng_Word(StringMap& Eng_wordPairs, int& counter)
{
	int whichword=random(counter);
	cout<<"\nwhichword:"<<whichword<<endl;

	StringMap::const_iterator iter=Eng_wordPairs.begin();
	for(int randomcounter=0; randomcounter<whichword; randomcounter++)
	{
		++iter;		
	}cout<<"\nZufallswort:"<<iter->first;

}

so ich hab die zufallsfunktion implementiert , was meint ihr iss das ok oder is das spagetticode falls ja ich bin für nee performantere lösung dankbar...
das mit dem Lexikalisch ordnen iss kompliziert ich hab die vermutung das otze da ein funktionsobjekt programmiert hat , allerdings sind mir die stl-funktionen unbekannt bzw ich steig da net durch was die macht naja iss auch wurst wenn der fehler noch bereinigt werden könnte oder wenn jemand nee andere lösung hat, nicht zögern hier rein zu schreiben. ein mentaler dank ist demjenigen gewiss

ich vermute, dass das dereferenzieren von end() nicht erlaubt ist.

dann halt bissl anders:

struct lexicalCompare
{
  bool operator()(const string& s1, const string& s2) const
  {
    //jetzt wirds ätzend
    const std::collate<char>& cmp=std::use_facet<std::collate<char> >(std::locale());
    return cmp.compare(s1.data(),s1.data()+s1.size(),s2.data(),s2.data()+s2.size())<0;
  }
};

was genau passiert:

ich bastel hier nen funktor der folgendes macht:
zuerst hol ich mir das collate objekt aus dem globalen locale. in diesem locale sind die informationen darüber gespeichert, wie in der eingestellten umgebung strings sortiert werden(neben noch vielem mehr). Collate ist dabei das Objekt,d ass sich nur ums sortieren kümmert.
von diesem objekt ruf ich dann compare auf, die eigentliche vergleichsfunktion.

struct lexicalCompare
{
  bool operator()(const string& s1, const string& s2) const
  {
    //jetzt wirds ätzend
    const std::collate<char>& cmp=std::use_facet<std::collate<char> >(std::locale());
    return cmp.compare(s1.data(),s1.data()+s1.size(),s2.data(),s2.data()+s2.size())<0;
  }
};

danke aber deine funktionsobjekt macht das gleiche wie mein

typedef std::map<string, string, std::less<string>> StringMap;

von der stl.
ich möchte das das grosse A und das kleine a genauso behandelt werden.
als beispiel:
ich habe diese wörter in der txt-datei:

Arbeit
Besen
Leben
argwöhnisch
bösartig
Leben

nach Ascii wird es so sortiert, also nach meiner genauso wie nach deiner variante:

Arbeit
Besen
Leben
argwöhnisch
bösartig
lieblich

d.h. erst die grossen buchstaben dann die kleinen buchstaben:
ich möchte aber:
Arbeit
argwöhnisch
Besen
bösartig
Leben
lieblich
garnet so einfach hmmm irgendwie muss man wohl, eventuell die operatoren > < überladen . vielleicht gehts dann frag mich nur wie? hmmm.

ps. und das problem geht weiter ! "umlaute äöü...!" die muüssen auch richtig sortiert werden (meine umschalttaste klemmt (bin nur zu faul *gg)also nicht wundern warum alles klein geschrieben ist )

hmm ... std::transform(string.begin(), string.end(), string.begin(), std::tolower); ... dann sortieren ...

ich glaube std::transform kann man nicht anwenden bei maps
ich hab die codezeile zwischen 65 und 66 eingefügt

std::transform(Ger_wordPairs.begin(), Ger_wordPairs.end(), Ger_wordPairs.begin(), std::tolower);

gibt 12 fehlermeldungen u.a
fehlermeldung:

error C2780: '`global namespace'::std::_Enable_if<!std::_Is_checked_iterator<_OutIt>::_Result||!std::_Is_checked_iterator<_OutIt>::_Result,_OutIt>::_Result std::transform(_InIt1,_InIt1,_InIt2,_OutIt,_Fn2)': Erwartet 5 Argumente - 4 unterstützt
        c:\programme\microsoft visual studio 8\vc\include\algorithm(867): Siehe Deklaration von 'std::transform'

ich glaube ausserdem würde dann alles kleingeschrieben sein oder?. is ja auch nicht Sinnvoll... hmmm

struct ignorecase
{
    std::locale loc;
    bool operator()(const string& s1, const string& s2) const
    {
        string::const_iterator iter1 = s1.begin();
        string::const_iterator iter2 = s2.begin();
        while ((iter1!=s1.end()) && (iter2!=s2.end()))
        {
            // tolower aus locale. Beruecksichtigt die
            // landesspezifischen Umwandlungen
            char cs1 = std::tolower(*iter1,loc);
            char cs2 = std::tolower(*iter2,loc);
            if (cs1<cs2)
                return true;
            if (cs1>cs2)
                return false;
            ++iter1;
            ++iter2;
        }
        return false;
    }
};

und dann mit

typedef std::map<string, string, ignorecase> StringMap;

so jetzt gibt es nur noch das problem mit dem Umlauten die soll er auch locker floggig sortieren nach lexikon. Im moment sortiert er erst die ä und dann erst a
beispiel:

ärgern 
Arbeit

normalerweise sollte erst Arbeit dann ärgern kommen.
wenn jemand ne idee hat ..

wobei auf console wird das zeichen wg. zeicheninkomp. nicht richtig dargestellt
gibs wohl keine lösung dafür

Vermutlich mußt du das tolower() noch mit dem collate<>-Ansatz von oben zusammenfassen, um die Sonderzeichen mit in die Suchfolge einzubinden.

wie das ?
std::collate<char> cs1 = std::tolower(*iter1,loc); oder dergleichen .. ?? geht nicht..kenn die grammatik und wirkung von std::collate nicht

string sten;
sten="ich bin doch ein BAP..(BAP = Blödster Anzunehmenster Programmierer)";

bool lexical_compare::operator()(string s1,string s2)//Übergabe per Wert ist beabsichtigt
{
  //1) Umwandlung in Kleinbuchstaben:
  transform(s1.begin(),s1.end(),s1.begin(),bind2nd(std::tolower,std::locale());
  transform(s2.begin(),s2.end(),s2.begin(),bind2nd(std::tolower,std::locale());
  //Notiz an mich: Ich bin nicht ganz sicher, ob der bind2nd so klappt

  //2) Locale-abhängig vergleichen:
  const std::collate<char>& cmp=std::use_facet<std::collate<char> >(std::locale());
    return cmp.compare(s1.data(),s1.data()+s1.size(),s2.data(),s2.data()+s2.size())<0;
}

map<string,string,locale> localized_map(locale("de_DE.UTF-8"));

falls das locale de_DE.UTF-8 vorhanden ist, kümmert es sich automatisch um die richtige lexikographische ordnung. (dafür reicht z.b. unter linux im CLI localedef -f UTF-8 -i de_DE de_DE.UTF-8)

alternativ kannst du dir dein eigenes facet ableiten:

class CollateIgnoreCase : public collate<char>
{
   int do_compare (const char *A, const char* B, const char* X, const char* Y) const
   {
      /* leave it to you */
   }

   std::string do_transform (const char* A, const char* B) { /* ... */ }

   ~CollateIgnoreCase () {} //dtor privat machen. s.u.
};

void foo();

int main ()
{
   locale(locale(""), new CollateIgnoreCase); //locale kümmert sich um das delete
   //edit: das speichermanagement von locales und facets ist sowieso ein eigenes kapitel und imo nicht sehr intuitiv geregelt. wenn du das facet stand-alone verwenden willst, musst du dem basisklassenkonstruktor z.b. eine "1" übergeben. andernfalls schadet es sicherlich auch nicht, den destruktor privat (oder protected zu halten)
   foo();
}

void foo ()
{
 map<string,string,locale> localized_map (locale(""));
 //hier musst du die "" angeben, weil locale keine funktion, sondern ein konstruktor ist und der ausdruck sonst eine funktionsdeklaration wäre.
 //...
}

CStoll schrieb:

Achtung - nicht getestet:

bool lexical_compare::operator()(string s1,string s2)//Übergabe per Wert ist beabsichtigt
{
  //1) Umwandlung in Kleinbuchstaben:
  transform(s1.begin(),s1.end(),s1.begin(),bind2nd(std::tolower,std::locale());
  transform(s2.begin(),s2.end(),s2.begin(),bind2nd(std::tolower,std::locale());
  //Notiz an mich: Ich bin nicht ganz sicher, ob der bind2nd so klappt

  //2) Locale-abhängig vergleichen:
  const std::collate<char>& cmp=std::use_facet<std::collate<char> >(std::locale());
    return cmp.compare(s1.data(),s1.data()+s1.size(),s2.data(),s2.data()+s2.size())<0;
}

selbst, wenn das funktionieren würde, wäre es eine schlechte idee.
gegeben seien zwei strings, a und b, die sich jeweils nur in der groß/kleinschreibung unterscheiden. mit dieser implementation passiert es, dass lexical_compare::operator()(a,b) und lexical_compare::operator()(b, a) true liefern, was gleichbedeutend ist mit a == b. folglich wird ein element nicht einfügt, obwohl es das eigentlich sollte. vorstellbar z.b. bei "angeln - v, i, regulär" vs "Angeln - n, pl von Angel".

das müsste man sowohl bei einer eigenen funktion/funktor korrigieren (a < A < b < B ...) als auch bei einer eigenen implementation von collate - wenn du das passende locale allerdings auf deinem pc hast (de_DE oder whatever), macht es das automatisch - das verhalten von solchen locales liegt aber außerhalb der definitionsmacht des C++ standards. eine lösung mit multimap wäre nicht zu empfehlen.

nur so nebenbei: locale besitzt selbst einen operator(), der genau dafür gedacht ist.

map<string,string,std::locale> localized_map(std::locale("de_DE.UTF-8"));

also ich hab das bei mir eingebaut und ich vermute das "de_DE.UTF-8" nicht bei mir existiert.. hab hier ein "deutsches XP" laufen..mit Visual 2005 express (german)als Entwicklungsumgebung. was funktioniert ist

map<string,string,locale> localized_map;

ohne (std::locale("de_DE.UTF-8")); <<< wenn ich das einfüge gibs ein runtimeerror mit dem tollen hinweis: "This application has requested the Runtime to terminate it in an unusual way. please contact the application´s support team for more informations. "<< hihi da bin ja dann wohl ich gemeint..

falls ichs weglasse dieses (std::locale("de_DE.UTF-8") sortiert der wieder stupide erst grossbuchstaben dann klein.. nun da es wohl schwierig ist ein std: möglichkeit zu finden muss ich wohl oder übel selbst was bauen was die Umlaute richtig einsortiert. irgend ne billig switch case in der art

string result = str;

	for (size_t i=0; i < result.length(); i++)
	{
		result[i] = tolower(str[i]);

		switch(result[i])
		{
		case 'ä':
			result[i] = 'a';
			break;...

.. mal sehn ob ich das hinbekomm

locale::global(locale(""));
//und lass dir den namen des locales ausgeben
cout << "verwende nun " << locale().name() << endl;

ich hab jetzt keinen standard bei mir, aber ich glaube nämlich, dass das globale locale standardmäßig auf das C (=en_US) locale gesetzt wird.