3. Anfängerfragen zu einem Projekt mit Klassen

Anfängerfragen zu einem Projekt mit Klassen

  • V

    Wie solln sie den anders dargestellt werden?

    ... bei der for-Schleife musst du nicht schon vorher definieren

    for(int i = 0; ...

    Gruß Simon

    0

  • @venti

    Vorhin wolltest du noch Wörter zählen oder suchen.
    Jetzt suchst du nach einzelnen Buchstaben...

    Was genau willst du jetzt eigentlich? 🙂

    0
  • V

    ... Wenn du natürlich nur die Buchstaben zählen willst, dann reicht auch ein std::vector<int> oder ein std::map<char, int> ...

    Gruß Simon

    0
  • V

    ja, ich muss doch mal alles probieren und nur so kann ich lernen und ey bekomm ich hier nich mal ein Lob, ich hab mir alles allein zusamm geknistert!

    void Ctext_analyse::datei_suchen(void)
{ 
	int i; 
	int z=0; 
	for(i=0; i<lang; i++)
	{
		if('r'==text[i]) // text[i] an der Stelle i wird auf gleichheit mit r geprüft, wenn dann true wird
			{
			z=z+1;		
			}
	}
	cout << "Anzahl: "<<z/*text[i]*/ << endl;  
}

    **
    Nocmal zum Programm!**

    ich will ein Wort suchen das mit r beginnt und er soll mir alle Wörter mit r beginnend ausgeben, so wie google

    ja und ich komm bei der Schleife nicht weiter, jemand ne Idee 😃

    gruß
    Venti

    0
  • N

    ventilatores schrieb:

    und ey bekomm ich hier nich mal ein Lob, ich hab mir alles allein zusamm geknistert!

    Braver venti, das hast du gut gemacht! :p
    (Weshalb erwartest du für etwas Code schreiben ein Lob?)

    ventilatores schrieb:

    ich will ein Wort suchen das mit r beginnt und er soll mir alle Wörter mit r beginnend ausgeben, so wie google

    Dann schau doch, ob vor dem 'r' jeweils ein Whitespace steht (Leerzeichen/Zeilenende/Tabulator), falls ja, beginnt dort ein Wort...

    0
  • V

    Du könntest ja schaun ob

    Nexus schrieb:

    ... vor dem 'r' jeweils ein Whitespace steht (Leerzeichen/Zeilenende/Tabulator), falls ja, beginnt dort ein Wort...

    ... und ob danach noch mindestens ein Zeichen kommt ...

    Falls du aber abprüfen willst, ob auch nur buchstaben nach dem 'r' kommen musst du schon mehr prüfen, oder per RegEx (Regular Expression) ...

    Gruß Simon

    0
  • V

    morjens,

    ich probiere das Wort "Wert" in meine Text zu suchen und die Anzahl der gefundenen Wörter (Wert) anzuzeigen, wo ist hier mein Denkfehler?

    void Ctext_analyse::datei_suchen(void)
{ 
	int i; 
	int wert;
	int z=0; 
	cout << "Welches Wort suchen Sie?" << endl;
	cin >> wert;
	for(i=0; i<lang; i++)
	{
		if('wert'==text[i]) 
			{
			z=z+1;		
			}
			cout << "*";
	}
	cout << "Anzahl: "<<z<< wert << endl; 

}

    gruß
    Vetila....tores

    0
  • V

    Jetz suchst du ein eingegebenes Wort zu suchen, was willst du denn nun? ...

    void Ctext_analyse::datei_suchen(void)
{
    int i;
    int wert;
    int z=0;
    cout << "Welches Wort suchen Sie?" << endl;
    cin >> wert;
    for(i=0; i<lang; i++)
    {
        if('wert'==text[i]) // Wieso liest du dann erst ein Wort ein?
            {               // Außerdem verlgeichst du einen string mit einem buchstaben ...
            z=z+1;       
            }
            cout << "*";
    }
    cout << "Anzahl: "<<z<< wert << endl;
}

    Du musst erstmal klar ausdrücken was du überhaupt machen willst und nicht wie du es machen willst ...

    ... wenn es ums Wörterzählen geht, dann ist z.B. eine std::map<std::string, int> möglich ....

    Gruß Simon

    0

  • Hast du denn inzwischen mal versucht die Datei Zeilenweise einzulesen und einzelne Wörte herauszufiltern? Genug Tipps hast du ja eigentlich bekommen 🙂

    0
  • V

    relax, relax, ja ich muss char benutzen...

    nachdem ich ja gestern es geschafft hatte die Anzahl von r zu ermitteln und auf der Konsole auszugeben wollte ich heute alles ein wenig schicker gestalten.
    Also ich probiere etwas rum, da muss man schon etwas flexibel mit mir sein.
    Ist ja klar das man als Anfänger erstmal hin und her macht...

    void Ctext_analyse::datei_suchen(void)
{ 
	int i; 
	int z=0; 
	for(i=0; i<lang; i++)
	{
		if('r'==text[i]) 
			{
			z=z+1;		
			}
	}
	cout << "Anzahl: "<<z<< endl; 
	}

    Also aktuell will ich ein Wort suchen das auf der Konsole augegeben wird und mir die Anzahl angezeigt wird.

    Ich wollte alles in einer Schleife packen, ist das o.k.? oder besser mehrere Schleifen, hm.....hab da ne Denkblockade grade

    gruß
    Venta

    0
  • V

    Hier mal n paar Denkansätze:

    - überlege dir, wie du die Wörter brauchst
    -> musst du beim Speichern beachten
    - mit was willst du das eingelesene Vergleichen/oder Zählen
    -> geeigneten Container finden, der die Anzahl pro Wort speichert
    - sieh' dir nochmal alle geposteten Sachen an und überlege ob die Ratschläge dir helfen können

    Du darfst gerne Fragen stellen, aber bitte so, dass es jeder versteht und du am besten schon ein bisschen Code von deinen Ansätzen zeigst ...

    ... es ist nicht schlimm, wenn du dein Programm erweitern willst, aber du bist mit deimen Code immer noch so weit wie zu Anfang (wartest du etwa auf eine Musterlösung?) ...

    0
  • V
     

    void Ctext_analyse::datei_suchen(void)

{ 
	FILE *fp;
   int i;
   char text[255];
   char suchwort[2][20]={"wert","so"};
   int AnzahlSuchwoerter=2;
   char* ptr;

   fp = fopen ("collection.txt","rt");
   if (fp==NULL)
   {
      printf("Fehlen von diso_b_text.ini\r\n");
   }
   else
   {
      i=0;
      while ( feof( fp ) != EOF )
      {

         fgets(text,255, fp);

         for(int i =0;i<AnzahlSuchwoerter;i++)
         {
            ptr = strstr (text,suchwort[i]);

            if ( ptr != NULL )
            {
               printf("%s ",suchwort[i]);
               //printf("%s\r\n",text);

            }
         }
      }
   }

}
    0
  • V

    wie bekomme ich es jetzt Ordentlich ausgegeben, also die Anzahl von ... beträgt ...

    0
  • D

    Hallo ventilatores, ich hab mal zum Spass dir eine Klasse geschrieben die Dir die Wörter aus deiner Datei auflistet, zählt und sortiert, so wie du es im letzten Post gerne gehabt hättest. Viel Spass 🙂

    Dauer 3Std 45min.

    Datei wc.hpp

    #ifndef WC_HPP_INCLUDED
#define WC_HPP_INCLUDED

#include <string>
#include <fstream>
#include <vector>
#include <map>

struct Wort
{
    std::string Name;
    int         Anzahl;
};

class CWortCount
{
    private:
      std::vector<Wort> m_Worte;                     // enthält die Worte : Anzahl für die Ausgabe
      std::ifstream* m_pfs;                          // zeiger auf file handle
      void ZaehleWorte(std::ifstream* fs);           // zerlegt die Datei in Worte

      void WortZurMap(std::string& strWort,
                std::map<std::string, int>& mapWorte);  // fügt neue Worte ein, erhöht den Zähler

      void KopiereMapZuVektor(std::vector<Wort>& vecWorte,
                std::map<std::string,int>& mapWorte);// kopiert die Worte in einen vektor für den
                                                     // besseren Zugriff
    public:
      void SortCount(bool asc = true);               // sortieren nach Anzahl
      void SortWord(bool asc = true);                // lexikalisch sortieren
      bool OeffneDatei(std::string& Datei);          // Oeffnet die Datei zu lesen
      Wort& operator[](const long idx);               // liefert alle Wörter und deren Anzahl
      long WortAnzahl() { return m_Worte.size(); }   // Anzahl der gefunden Woerter
};

#endif // WC_HPP_INCLUDED

    Datei: wc.cpp

    #include "wc.hpp"

#include <iostream>
#include <map>

using namespace std;

bool CWortCount::OeffneDatei(string& Datei)
{
    m_pfs = new ifstream(Datei.c_str());

    if (!m_pfs->is_open())
    {
      delete m_pfs;
      return false;
    }

    ZaehleWorte(m_pfs);

    // aufräumen brauchen wir nicht mehr
    // close wird automaisch aufgerufen
    delete m_pfs;
    return true;
}

void CWortCount::ZaehleWorte(ifstream* fs)
{
    // Zerlegen des input streams in worte
    char c;
    string wort;
    map<string, int> mapWorte;  // enthält die gefundenen (Worte:Anzahl)

    while (fs->get(c))
    {
        switch (c)
        {
            case ',': case '.': case ' ': case '\n': case ';':
            // worttrenner gefunden
              if (wort.length() > 0)
              {
                WortZurMap(wort, mapWorte);
                wort.clear();
              }
            break;
            default:
              wort.push_back(c); // addiere Zeichen zum Wort;
            break;
        }
    }

    if (!fs->eof()) cout << "DBGM: Filestream nicht leer !!" << endl;

    KopiereMapZuVektor(m_Worte, mapWorte);
}

void CWortCount::WortZurMap(string& strWort,
                            map<string, int>& mapWorte)
{

    pair<map<string,int>::iterator,bool> cmp;

    // versuche das wort einzufügen
    cmp = mapWorte.insert (pair<string,int>(strWort,1) );

    // wort ist schon vorhanden erhöhe den Zähler;
    if (cmp.second == false)
         (*cmp.first).second++;
}

Wort& CWortCount::operator[](const long idx)
{
    return m_Worte.at(idx);
}

void CWortCount::KopiereMapZuVektor(vector<Wort>&    vecWorte,
                        map<string,int>& mapWorte )
{
    map<string,int>::iterator it;
    for (it = mapWorte.begin(); it != mapWorte.end(); it++)
    {
        Wort w = { (*it).first, (*it).second };
        vecWorte.push_back(w); // erzeugt eine Kopie und wird owner
    }
}

void CWortCount::SortCount(bool asc)
{
    // ganz billige sortierung!
    for(size_t i = 0; i < m_Worte.size()-1; i++)
    {
        for(size_t j = i+1 ; j < m_Worte.size(); j++)
          if ((m_Worte.at(i).Anzahl > m_Worte.at(j).Anzahl) == asc)
          {
            Wort temp = m_Worte.at(j);
            m_Worte.at(j) = m_Worte.at(i);
            m_Worte.at(i) = temp;
             // kleinstes element speichern
          }
    }
}

void CWortCount::SortWord(bool asc)
{
    // ganz billige sortierung!
    for(size_t i = 0; i < m_Worte.size()-1; i++)
    {
        for(size_t j = i+1 ; j < m_Worte.size(); j++)
          if ((m_Worte.at(i).Name > m_Worte.at(j).Name) == asc)
          {
            Wort temp = m_Worte.at(j);
            m_Worte.at(j) = m_Worte.at(i);
            m_Worte.at(i) = temp;
             // kleinstes element speichern
          }
    }
}

    Datei: main.cpp

    #include <iostream>
#include "wc.hpp"

using namespace std;

int main()
{
    string datei = "meine.dat";
    CWortCount wc;

    // Ich hatte keine Lust den operator! zu überladen um zu prüfen
    // ob der Vorgang erfolgreich war, daher ist die Initialsierung
    // im Konstruktor noch nicht möglich
    if (!wc.OeffneDatei(datei))
     cout << "Kann die Datei nicht oeffnen : " << datei << endl;

    wc.SortWord();
    cout << "Alle gefunden Wörter in: " << datei << endl;
    for(int i = 0; i < wc.WortAnzahl(); i++)
      cout << "Anzahl von : " << wc[i].Name
           << " beträgt : " << wc[i].Anzahl
           << endl;
    return 0;
}

    Eine mögliche Ausgabe könnte so aussehen:

    Alle gefunden Wörter in: meine.dat
Anzahl von : Aenean beträgt : 5
Anzahl von : Aliquam beträgt : 3
Anzahl von : Curabitur beträgt : 5
Anzahl von : Curae beträgt : 2
Anzahl von : Donec beträgt : 5
Anzahl von : Duis beträgt : 3
Anzahl von : Etiam beträgt : 3
Anzahl von : Fusce beträgt : 6
Anzahl von : In beträgt : 1
Anzahl von : Integer beträgt : 5
Anzahl von : Lorem beträgt : 1
Anzahl von : Maecenas beträgt : 4
Anzahl von : Mauris beträgt : 1
Anzahl von : Morbi beträgt : 2
Anzahl von : Nulla beträgt : 4
Anzahl von : Nullam beträgt : 2
Anzahl von : Nunc beträgt : 3
Anzahl von : Pellentesque beträgt : 3
Anzahl von : Phasellus beträgt : 3
Anzahl von : Praesent beträgt : 1
Anzahl von : Proin beträgt : 2
Anzahl von : Quisque beträgt : 4
Anzahl von : Sed beträgt : 5
Anzahl von : Suspendisse beträgt : 5
Anzahl von : Ut beträgt : 3
Anzahl von : Vestibulum beträgt : 3
Anzahl von : Vivamus beträgt : 3

    Grüssle DC!

    0
  • ?

    Und jetzt mal bissl eleganter:

    string filetxt = "";
ifstream fileIn("...");

copy(istreambuf_iterator<char>(fileIn), istreambuf_iterator<char>(), back_inserter(filetxt));

// 1. Methode: Bustaben zählen:
map<char, size_t> charCount;

for (size_t i = 0; i < filetxt.size(); ++i) ++charCount[filetxt[i]];
cout << "Anzahl r's :" << charCount['r'] << "\nAnzahl a's :" << charCount['a'] << endl;

// 2. Methode: Wörter zählen:
boost::tokenizer<> toki(filetxt);
map<string, size_t> wordCount;

for (boost::tokenizer<>::iterator it=toki.begin(); it!=toki.end(); ++it) ++wordCount[*it];
cout << "Anzahl bla's :" << wordCount["bla"] << "\nAnzahl blub's :" << wordCount["blub"] << endl;

    Dauer: 2min 45s 😉

    0
  • D

    @KasF Deinen Tipp finde ich gut, aber was daran eleganter sein sollte, weiß ich noch nicht, der Klassenansatz gefällt mir persönlich besser (von boost war ja noch nicht die Rede :)), da man das Konstrukt ('we can load anything, weapons, equipment and training simulations' 🙂 ) erweitern kann.

    Allerdings hast du recht das der Tokenizer die gleiche Arbeit wie meine Funktion ZaehleWorte() eleganter erledigt, nur kann ich dort eben nicht mehr in den Code eingreifen und komplexe Bedingungen für die Wortgrenze zu definieren.

    Auch istreambuf_iterator war mir in den Sinn gekommen, habe ihn aber wieder verworfen da ich nur den Teil im Speicher haben wollte den ich tatsächlich auch benötige und den Rest einfach verwerfe.

    Ansonsten hätte ich auch so gemacht 😉

    So long and thank's for all the fish! (HG)
    Grüssle DC!

    0
  • V

    @DeepCopy hey hey, thanx für die wirklich tolle Arbeit von dir, jetzt habe ich wenigstens mal ein Beispiel und kann alles genau analysieren und mein Lehrer freut sich auch, der hatte mich schon auf dem Kicker.

    @KasF puh, das ist mir noch zu hoch

    Trotzdem, tausend Dank an euch beiden! 👍

    Venti 🙂

    0
  • V

    Könnten wir die Ausgabe jetzt noch ein wenig, mit DeepCopy's Code, etwas edler machen?

    z.Bsp.:
    --------------------------------------------------------------------------------
    Welches Wort suchen Sie?...eingabe Wort.....

    Die Anzahl Ihres gesuchten Wortes beträgt: .......Anzahl Wort....

    --------------------------------------------------------------------------------

    0
  • ?

    DeepCopy schrieb:

    @KasF Deinen Tipp finde ich gut, aber was daran eleganter sein sollte, weiß ich noch nicht, der Klassenansatz gefällt mir persönlich besser

    Das waren auch nur Codeschnipsel 😉 das kann man immernoch schön verpacken.

    DeepCopy schrieb:

    Allerdings hast du recht das der Tokenizer die gleiche Arbeit wie meine Funktion ZaehleWorte() eleganter erledigt, nur kann ich dort eben nicht mehr in den Code eingreifen und komplexe Bedingungen für die Wortgrenze zu definieren.

    Meinst du die Wortgrenzen bei boost::Tokenizer ? Das Trennzeichen kann man dort auch definieren.

    DeepCopy schrieb:

    Auch istreambuf_iterator war mir in den Sinn gekommen, habe ihn aber wieder verworfen da ich nur den Teil im Speicher haben wollte den ich tatsächlich auch benötige und den Rest einfach verwerfe.

    Benötigte ? Rest ? im Speicher ? Wo, wie was ? 😃

    Noch ein paar kleine Verbesserungsvorschläge zu deinem Code:
    1.) Wieso ist der Stream aufm Heap und nicht aufm Stack ?
    2.) Wieso reichst du deinen Member m_pfs in der Klasse rum ? Falls das Absicht ist, damit ZaehleWorte() auch mit anderen Quellen benutzt werden kann, stimmt hier was mit der Kohärenz nicht ?
    3.) Dein ZaehleWorte() ist nicht unbedingt performant mit den ganzen Stream-Zugriffen.
    4.) WortZurMap kann ein Einzeiler sein, siehe mein Code und die Referenz deiner Wahl.
    5.) Für die Container-Kopieroperationen gibts es schöne Konstruktoren und std::copy.

    Und für *Nicht-Boost-Haben-Woller* 🙂 :

    class SimpleTokenizer
{
    private:
        vector<string> toki;
    public:
        typedef vector<string>::const_iterator  TokiIt;

        SimpleTokenizer(const string& str)
        {
            string blub = "";
            stringstream sstr(str);

            while(sstr>>blub) toki.push_back(blub);
        }

        vector<string>::const_iterator begin() const { return toki.begin(); }
        vector<string>::const_iterator end()    const { return toki.end();   }
};

// 2. Methode: Wörter zählen:
SimpleTokenizer toki(filetxt);

map<string, size_t> wordCount;

for (SimpleTokenizer::TokiIt  it=toki.begin(); it!=toki.end(); ++it) ++wordCount[*it];
cout << "Anzahl bla's :" << wordCount["bla"] << "\nAnzahl blub's :" << wordCount["blub"] << endl;
    0
  • ?

    ventilatores schrieb:

    Könnten wir die Ausgabe jetzt noch ein wenig, mit DeepCopy's Code, etwas edler machen?

    z.Bsp.:
    --------------------------------------------------------------------------------
    Welches Wort suchen Sie?...eingabe Wort.....

    Die Anzahl Ihres gesuchten Wortes beträgt: .......Anzahl Wort....

    --------------------------------------------------------------------------------

    Wenn du das nicht alleine schaffst, dann brauchst du auch gar nicht DC's Code zu benutzen. 😉

    0
Anmelden zum Antworten