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!

#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();
}

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!