Elemente zählen

Hallo,
ich habe eine Textdatei, in der steht:
Jan:Fitness
Jan:Fitness
Lina:Jogging
Rudi:Fitness
Rudi:Jogging
Lina:Schwimmen

Nun will ich diese einlesen (kein Problem!) und dann zählen, wie oft für jeden Namen rechts neben dem Doppelpunkt "Fitness" steht. Hier wäre die Ausgabe also
Jan:2
Lina:0
Rudi:1

Wie bewerkstellige ich das am besten mit Managed c++? Sollte ich das über ein mehrdimensionales Array machen? Die Namen sind übrigens variabel, sprich ich weiß vorher nicht, wer da alles genannt wird.

Danke!

Erhard Henkes

..

Hallo Erhard,
danke für die schnelle Reaktion, aber ich verstehe nicht mal ansatzweise, was das mit meinem Problem zu tun hat. Die Stringseparierung kann ich, ich frage mich nur, wie ich das Zählen hinkriege. Dank Dir!

*D*Evil

?? Geh das mit ner schleife durch und guck immer ob der string = der gewünschte ist...

Ich möchte wissen, welche Datenstruktur ich am besten zugrunde lege, die ich dann nachher durchlaufen muß. Ich muß ja immer Name und Hobby pro Zeile festhalten.

Erhard Henkes

Beispiel für Struktur:

#include <iostream>
#include <conio.h>
using namespace std;

int main()
{
    struct moebelstueck 
    {   
        string name;  
        int    preis;  
        bool   isVerkauft; 
    };

    moebelstueck x[2];

    x[0].name        = "Couchtisch rustikal";
    x[0].preis       = 1200;
    x[0].isVerkauft  = true;
    x[1].name        = "Wohnzimmerschrank rustikal";
    x[1].preis       = 7200;
    x[1].isVerkauft  = false;

    for( int i=0; i<2; ++i )
        cout << "\n\n" << x[i].name << "\n" << x[i].preis << " Euro\n" 
             << ( x[i].isVerkauft ? "verkauft" : "nicht verkauft" );

    getch();
}

In Deinem Fall eben:

struct person 
{   
  CString name;  
  CString hobby;  
  //...
};

oder

struct person 
{   
  CString name;  
  CString hobby[10];  
  //...
};

oder Du baust Dir eine Klasse Person und weitest diese entsprechend aus ...

#include <iostream>
#include <iomanip>
#include <conio.h>
#include <string>
#include <sstream>

using namespace std;

class Person
{
  private:
    const unsigned _d;
    const unsigned _m;
    const unsigned _y;
    string _hobby;

  public:
    Person(unsigned d, unsigned m, unsigned y);
    const string getBirthday() const;
    string getHobby() const;
    void setHobby(string hobby); 
};

Person::Person(unsigned d, unsigned m, unsigned y):_d(d),_m(m),_y(y){}

const string Person::getBirthday() const
{
    stringstream sstream;
    sstream<<setfill('0')
    <<setw(2)<<_d<<"."
    <<setw(2)<<_m<<"."
    <<setw(2)<<_y;
    return sstream.str();
}

string Person::getHobby() const
{
    return _hobby;
}

void Person::setHobby(string hobby)
{
    _hobby = hobby;
}

int main()
{
    Person A(12,1,1953), B(3,11,1981);
    A.setHobby("Schach spielen"); 
    B.setHobby("Snooker spielen"); 
    cout << A.getBirthday() << "  " << A.getHobby()<<endl;
    cout << B.getBirthday() << "  " << B.getHobby()<<endl;
    getch();
}

Du kannst auch eine abgeleitete Kindklasse von Person schaffen, hier ein Beispiel:

#include <string>
#include <iostream>

void wait()
{
    std::cin.clear();

    std::streambuf* pbuf = std::cin.rdbuf();
    std::streamsize size = pbuf->in_avail();
    std::cin.ignore(size);

    std::cin.get();
}

class Person
{
private:
	std::string Vorname;
	std::string Name;
	unsigned int Alter;
public:
	~Person();
	Person();
	void setVorname(const std::string& value);
	const std::string& getVorname() const;
	void setName(const std::string& value);
	const std::string& getName() const;
	void setAlter(const unsigned int & value);
	const unsigned int & getAlter() const;
};

const unsigned int & Person::getAlter() const
{
  return Alter;
}

void Person::setAlter(const unsigned int & value)
{
  Alter = value;
}

const std::string& Person::getName() const
{
  return Name;
}

void Person::setName(const std::string& value)
{
  Name = value;
}

const std::string& Person::getVorname() const
{
  return Vorname;
}

void Person::setVorname(const std::string& value)
{
  Vorname = value;
}

Person::Person(){}

Person::~Person(){}

class Dozent : public Person
{
private:
	unsigned int Kurse_noch_geplant;
	unsigned int Kurse_gehalten;
public:
	void setKurse_noch_geplant(const unsigned int & value);
	const unsigned int& getKurse_noch_geplant() const;
	void setKurse_gehalten(const unsigned int & value);
	const unsigned int& getKurse_gehalten() const;
	~Dozent();
	Dozent();
};

Dozent::Dozent() : Kurse_gehalten(0), Kurse_noch_geplant(0) {}

Dozent::~Dozent(){}

const unsigned int & Dozent::getKurse_gehalten() const
{
  return Kurse_gehalten;
}

void Dozent::setKurse_gehalten(const unsigned int & value)
{
  Kurse_gehalten = value;
}

const unsigned int & Dozent::getKurse_noch_geplant() const
{
  return Kurse_noch_geplant;
}

void Dozent::setKurse_noch_geplant(const unsigned int & value)
{
  Kurse_noch_geplant = value;
}

int main()
{
  Dozent obj;
  obj.setName("Allwissend");
  obj.setVorname("Hugo");  
  obj.setAlter(85);
  obj.setKurse_gehalten(13);
  obj.setKurse_noch_geplant(2);
  std::cout << obj.getVorname() << " " << obj.getName() << " " << obj.getAlter() << " Jahre alt" << std::endl;
  std::cout << obj.getKurse_gehalten() << " Kurse schon gehalten." << std::endl;  
  std::cout << obj.getKurse_noch_geplant() << " Kurse noch geplant." << std::endl;  

  wait();
}

Wow, das waren mal umfangreiche Beispiele, die selbst ich endlich verstanden hab. Dank Dir!!

Eine letzte Frage noch: Welche dieser Strukturen eignet sich denn am Besten hierfür, es sollen für alle Namen gezählt werden, wie oft sie als Hobby "Sport" angegeben haben, dopptelte Einträge sollen aber nicht gezählt werden:
Jan # Sport # Fitness
Jan # Kultur # Musik
Jan # Sport # Radeln
Jan # Sport # Fitness
Lina # Kultur # Malen

Ergebnis müßte dann sein:
Jan:2
Lina:0

Danke nochmal!