ich erzeuge dynamisch eine Struktur:

struct strVokabeln *myVokabel;
   myVokabel = new strVokabeln[iMaxLines];

diese übergebe ich dann eine Funktion:

//Prototype:
//void loadVokabeln ( std::ifstream &myFile, strVokabeln *myVocabulum );

loadVokabeln(myFile, myVokabel);

//und dann noch einer Funktion

//Prototype:
//void oneonetraining ( strVokabeln *myVocabulum, int *iMaxLines, int Durchlaeufe);

oneonetraining (myVokabel, &iMaxLines, 20);

Nun meine Frage, wie kann ich immer mit der einen struct arbeiten. Muss ich sie mir immer von der Funktion als return wert zurück geben lassen oder geht das noch anderes.

Den ich habe gemerkt wenn ich die eine Funktion "loadVokabeln" aufrufe und die struct voll machen ich den inhalt bei der nächsten Funktion oneonetraining (die Ausgabe) nicht mehr habe.

Wie kann ich das Ressourcenschonend lösen?

gruß und shcon mal dank

zyon

Du erzeugst mit obigen Aufruf keine Struktur, sondern ein Array der Größe iMaxLines von Strukturen. Du kannst dieses Array eigentlich schon so übergeben. Wo erzeugst du dieses Array denn? Vielleicht zeigst du mal ein wenig mehr Code. Woher weiß loadVokabeln wie groß das Array maximal sein darf? Du übergibst da iMaxLines nicht.

Nackte Arrays zu verwenden ist übrigens unklug. Dafür sollte man lieber einen std::vector nehmen. Die sind einfacher zu handhaben (würde fast wetten, daß dir der Fehler, der dir hier passiert ist, mit einem std::vector nicht unterlaufen wäre).

Hier mal der Code:

main.cpp

#include "Functions.h"
//---------------------------------------------------------------------------
using namespace std;

int main ( )
{
   int iMaxLines;

   ifstream myFile;
   myFile.open ("C:\\test.txt");

   if(!myFile){
      cout << "Fehler beim Oeffnen der Datei!\n";
      exit(1);
   }

   iMaxLines = getFileLines( myFile );
   struct strVokabeln *myVokabel;
   myVokabel = new strVokabeln[iMaxLines];

   loadVokabeln(myFile, myVokabel);

   oneonetraining (myVokabel, &iMaxLines, 20);

   myFile.close();
   delete [] myVokabel;
   cin.get();
   return 0;
}

Functions.h

//---------------------------------------------------------------------------
#include <iostream>
#include <fstream>
#include <string>
//---------------------------------------------------------------------------

struct strVokabeln
{
   std::string sDeutsch;
   std::string sEnglisch;
};

int getFileLines ( std::ifstream &myFile );
void loadVokabeln ( std::ifstream &myFile, strVokabeln *myVocabulum );
void oneonetraining ( strVokabeln *myVocabulum, int *iMaxLines, int Durchlaeufe);
int getRandomNumber ( int iMaxMumber );

Functions.cpp

#include "Functions.h"

using namespace std;

int getFileLines(ifstream &myFile )
{
   int iCount=0;
   if( myFile )
   {
      string ligne;
      while( getline( myFile, ligne ) )
      {
         iCount++;
      }

   }
   return iCount;
}

void loadVokabeln(ifstream &myFile, strVokabeln *myVocabulum )
{
   string sLine;
   int i=0;
   while ( myFile.good() ) {
       getline(myFile, sLine);
       string::size_type pos = sLine.find(":");

       myVocabulum[i].sDeutsch = sLine.substr(0,pos-1);
       myVocabulum[i].sEnglisch = sLine.substr(pos+1,sLine.length());

       ++i;
   }
}

int getRandomNumber(int iMaxMumber )
{
   srand( (unsigned) time(NULL) ) ;
   return(1 + ( rand() % iMaxMumber ));
}

void oneonetraining ( strVokabeln *myVocabulum, int *iMaxLines, int Durchlaeufe)
{
   int iRand = 0;
   string sWordCheck;
   for (int i=0; i <= Durchlaeufe;i++)
   {
      iRand = getRandomNumber(*iMaxLines);
      cout << myVocabulum[iRand].sDeutsch << " : ";
      cin >> sWordCheck;

      if(sWordCheck  == myVocabulum[iRand].sEnglisch )
      {
      cout << "\n RICHTIG " << endl;
      }
      else
      {
         cout << "\n FALSCH " << endl;
      }
   }
}

Z2 schrieb:

Der Code, soweit du ihn uns gezeigt hast, ist korrekt. Dein Problem muß an anderer Stelle liegen.

Nackte Arrays zu verwenden ist übrigens unklug. Dafür sollte man lieber einen std::vector nehmen. Die sind einfacher zu handhaben (würde fast wetten, daß dir der Fehler, der dir hier passiert ist, mit einem std::vector nicht unterlaufen wäre).

Ich habe es gestern mit eine map gemacht. Wollte mich aber bisschen mit ner struct schullen. Wenn diese Version läuft werde ich es sicher mal mit einem vector versuchen. Aber erst mal will ich es auch so lösen.

Gruß

zyon

void loadVokabeln(ifstream &myFile, strVokabeln *myVocabulum, int size )
{
   string sLine;
   int i=0;
   while ( myFile.good() && i<size ) {
       getline(myFile, sLine);
       string::size_type pos = sLine.find(":");
       if( myFile.good() && pos != string::npos)
       {
          myVocabulum[i].sDeutsch = sLine.substr(0,pos-1);
          myVocabulum[i].sEnglisch = sLine.substr(pos+1,sLine.length());
          ++i;
       }  
   }
}

while ( myFile.good() && i < iMaxLines) {

so auch nicht:

while ( myFile.good()) {

ganz komisch.

Dieses Problem tritte auf weill ich zuvor dieses machen:

iMaxLines = getFileLines( myFile );

probiers ma mit myFile.close();

ich will es ja nicht schliessen.

ich ahbe es schon versucht indem ich den Poiter wieder am anfang gesetzt habe:

myFile.seekg (0, ios::beg);

geht leider auch nicht.

myFile.clear();
   myFile.seekg (0, ios::beg);

besten dnak CStoll. haber es halt nur amanfang gesetzt ohne das eofbit weg zu machen.

Danke

gruß

zyon

Nackte Arrays zu verwenden ist übrigens unklug. Dafür sollte man lieber einen std::vector nehmen. Die sind einfacher zu handhaben

Irgendwie weiß icht nicht wie meine struct:

struct strVokabeln
{
   std::string sDeutsch;
   std::string sEnglisch;
};

struct strVokabeln *myVokabel;
myVokabel = new strVokabeln[iMaxLines];

als vector aussehen soll. Sprich ich brauch 2 vectoren.. oder? Kann mir da jemand helfen?

struct strVokabeln
{
   std::string sDeutsch;
   std::string sEnglisch;
};

std::vector<strVokabeln> Woerterbuch;

jetzt kannst du mit push_back() neue Wörter einfügen, die Größe per resize() anpassen, über []-Operator auf einzelne Elemente zugreifen etc.

(im Magazin findest du den Artikel "Aufbau der STL 1", dort solltest du mal reinlesen)

PS: Als Bonus könntest du deinem struct noch einen Konstruktor und Stream-Operatoren verpassen.

iMaxLines = getFileLines( myFile );
   vector < strVokabeln > Woerterbuch;
   Woerterbuch.resize(iMaxLines);
   Woerterbuch[1].sDeutsch

Das ich mit push_back() reinschreiben kann ist mir auch klar. Aber wie unterscheid ich das dann in die einzelnen Felder (sDeutsch,sEnglisch)?

CStoll schrieb:

PS: Als Bonus könntest du deinem struct noch einen Konstruktor und Stream-Operatoren verpassen.

?

Besten Dank

CStoll

Das ich mit push_back() reinschreiben kann ist mir auch klar. Aber wie unterscheid ich das dann in die einzelnen Felder (sDeutsch,sEnglisch)?

Wie du es oben schon gemacht hast: "Woerterbuch[i].sDeutsch" für den Deutsch-Teil, "Woerterbuch[i].sEnglisch" für den Englisch-Teil der i-ten Vokabel.

CStoll schrieb:

PS: Als Bonus könntest du deinem struct noch einen Konstruktor und Stream-Operatoren verpassen.

?

Der Konstruktor ist recht nützlich, um dir Schreibarbeit zu ersparen, damit kannst du statt

strVokabeln vok;
vok.sDeutsch = "Hund";
vok.sEnglisch = "dog";
Woerterbuch.push_back(vok);

einfach alles zusammenfassen zu:

Worterbuch.push_back(strVokabeln("Hund","dog");

(außerdem finde ich, daß eine Klasse mit Konstruktoren leichter zu handeln ist)

Stream-Operatoren kannst du definieren, um eine Vokabel über IO-Streams eingeben zu können (ist aber nicht unbedingt erforderlich)

PS: Ein Vorteil von vector<> ist, daß er mitwachsen kann - du mußt also nicht die Größe im Voraus berechnen:

string zeile;
while(getline(myFile,zeile))
{
  size_t trenn = zeile.find(' ');
  Worterbuch.push_back(strVokabeln(zeile.substr(0,trenn),zeile.substr(trenn+1)));
}

CStoll schrieb:

PS: Als Bonus könntest du deinem struct noch einen Konstruktor und Stream-Operatoren verpassen.

?
Der Konstruktor ist recht nützlich, um dir Schreibarbeit zu ersparen, damit kannst du statt

Finde das ganze sehr nett, aber wie kann ich den einen Konstruktor eine struct zuweissen? Versehe das mit dem Konstruktor nicht so ganz.

struct strVokabeln
{
  string sDeutsch;
  string sEnglisch;

  strVokabeln(const string& de,const string& en) : sDeutsch(de),sEnglisch(en) {}
};

(PS: Und ich empfehle dir ein Buch über die Grundlagen von C++)