hab das ganze auf einem dell notebook mit window xp laufen

hier erstmal der code

// consolengame.cpp
#include <iostream>
#include <cstring>

using namespace std;

class Player {
      public:

      enum Geschlecht { MANN, FRAU};

      private:
      char player_name[23];
      unsigned int player_alter;
      int player_lvl;
      int player_leben;
      int player_schaden;
      bool p_geschlecht; // 0 m , 1 w
      void test_geschlecht(void);

      public:
      // methoden von player 
      void sehen(const char* objekt);
      void laufen(const int* richtung);
      void schlagen(const char* objekt);
      void sprechen(const char* person);
      void nehmen(const char* objekt);
      // einen player erzeugen
      void erzeuge( char* p_n = "unbekannt", unsigned int* p_a = 0, int p_lvl = 0, bool g = FRAU);
      void print(void);
};

// main 
int main(void) {
    Player spieler_einz, spieler_zwei;
    spieler_einz.erzeuge();
    spieler_einz.sehen("hund");
}

// funktionen

void Player::sehen( const char* objekt) {
     cout << player_name << " sieht " << objekt << "\n";
}

void Player::erzeuge( char* p_n, unsigned int* p_a, int p_lvl, bool g) {

     int check = 0;
     while( check==0) {

                   cout << "name : " ;
                   cin.getline( p_n, sizeof( p_n)); // evt. liegt fehler hier
                   if( p_n) {
                        ++check;
                   }
                   else {
                        cout << "falsch\n";
                   } 
     }                  
     while(check==1) {
                   cout << "alter :" ;
                   if(cin >> *p_a) {
                          ++check;
                   }    
                   else {
                        cout << "falsch\n";
                   }
     }

     strncpy( player_name, p_n, sizeof(player_name)-1);
     player_name[sizeof(player_name)] = '\0';
     player_alter = *p_a;
     player_lvl = p_lvl;
     p_geschlecht= g;
}

vielleicht geht das ja bei euch reibungslos oder jemand weiss woran es liegt
danke schonmal im voraus.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Dieser Thread wurde von Moderator/in rüdiger aus dem Forum Rund um die Programmierung in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

sachma forumbot, kannst du auch einmal in deinem leben was zum thema sagen?!??!!
immer nur "mh, wird verschoben blablabla"
du bist voll langweilig, aber ok, jetzt weiss ich auch wie man über 10000 posts hinbekommt

b2t:
warum arbeitest du überall mit pointern?

// consolengame.cpp
#include <iostream>
#include <cstring>

using namespace std;

class Player {
      public:

      enum Geschlecht { MANN, FRAU};

      private:
      char player_name[23];
      unsigned int player_alter;
      int player_lvl;
      int player_leben;
      int player_schaden;
      bool p_geschlecht; // 0 m , 1 w
      void test_geschlecht(void);

      public:
      // methoden von player
      void sehen(const char* objekt);
      void laufen(const int* richtung);
      void schlagen(const char* objekt);
      void sprechen(const char* person);
      void nehmen(const char* objekt);
      // einen player erzeugen
      void erzeuge( char* p_n = "unbekannt", unsigned int* p_a = 0, int p_lvl = 0, bool g = FRAU);
      void print(void);
};

// main
int main(void) {
    Player spieler_einz, spieler_zwei;
    spieler_einz.erzeuge();
    spieler_einz.sehen("hund");
}

// funktionen

void Player::sehen( const char* objekt) {
     cout << player_name << " sieht " << objekt << "\n";
}

void Player::erzeuge( char* p_n, unsigned int* p_a, int p_lvl, bool g)
/* der char pointer ist ok, aber wieso gibst du einen default wert an wenn du ihn direkt wieder neu abfragst und überschreibst, abgesehen davond ass du in speicherzellen schreibst die nicht allocated sind (also nicht per new angelegt wurden)
warum dann der zeiger auf uint? wegen schelligkeit? google mal nach premature optimizing, die build in datentypen sind schnell genug für alles was man in deinem stadium macht
*/
{

     int check = 0;
     while( check==0) {

                   cout << "name : " ;
                   cin.getline( p_n, sizeof( p_n)); // evt. liegt fehler hier
                   if( p_n) {
                        ++check;
                   }
                   else {
                        cout << "falsch\n";
                   }
     }                  
     while(check==1) {
                   cout << "alter :" ;
                   if(cin >> *p_a) {
                          ++check;
                   }    
                   else {
                        cout << "falsch\n";
                   }
     }

     strncpy( player_name, p_n, sizeof(player_name)-1);
     player_name[sizeof(player_name)] = '\0';
/*
hier liegt auch ein grosser fehler, sizeof(player_name) gibt 23 zurück, aber der index geht nur von 0 -> n-1, also von 0 -> 22
*/
     player_alter = *p_a;
     player_lvl = p_lvl;
     p_geschlecht= g;
}

// consolengame 2 (class.cpp)
#include <iostream>
#include <cstring>

using namespace std;

// klassen 

class Figur 
{
      private:
             //initialisierung der klassen variablen
             char name[30];
             unsigned int alter;
             unsigned int level;
             int exp;
             int klasse;
             unsigned int leben;
             unsigned int staerke;
             unsigned int mana;
             char klass_name[10];

      public:
             // kassenmethoden
             void daten_eingabe(void);
             void daten_ausgabe(void);
             void char_eingabe(void);
             void spiel(void);
             void spieler_erzeugen( unsigned int l=0,unsigned int m=0, unsigned int s=0);
             int hauptschleife(void);
}spieler;

// begruessung wird initialisiert

void begruessung(void);
void beenden(void);

// main programm

int main(void) {
    Figur spieler;
    begruessung();
    spieler.daten_eingabe();
    spieler.char_eingabe();
    spieler.spiel();
    beenden();
    return 0;
}

// funktionen

void begruessung()
{
     cout << "\n\n\n\n\n\n\n\n\n\n\n                ----------------------------------------------\n" 
     << "                |                                            |\n"
     << "                |         >>> KUNGFUPANDA s GAME <<<         |\n"
     << "                |KungFuPanda:-]                    v.01(2009)|\n"
     << "                ----------------------------------------------\n\n\n\n\n\n\n\n\n\n\n\n";
}

void beenden()
{
     cout << "\n\n\n\n\n\n\n\n\n\n\n                ----------------------------------------------\n" 
     << "                |***          thanks for testing!         ***|\n"
     << "                |**      visit www.scheissaufalle.de       **|\n"
     << "                |***             KungFuPanda:-]           ***|\n"
     << "                ----------------------------------------------\n\n\n\n\n\n\n\n\n\n\n\n";
}

void Figur::daten_eingabe()
{

     spieler.level=0;
     spieler.exp=0;
     spieler.leben=0;
     spieler.mana=0;
     spieler.staerke=0;
     cout << "CharackterName: ";
     cin >> spieler.name;
     cout << "Dein Alter: ";
     if(!(cin >> spieler.alter)) {
              cerr << "falsche eingabe";
              exit(1);
              }
}

void Figur::daten_ausgabe()
{

     while( (cin.get()) != 32) {
            cout << "\n\n\n\n   >>> SPIELER DATEN <<<   \n\n\n\n\n\n";
            cout << "\n" << spieler.name << "\n\n"
            << spieler.klass_name << " "
            << spieler.alter << " Jahre" << "\nLevel: " << spieler.level
            << "\nErfahrung: " << spieler.exp << "\nLeben: "
            << spieler.leben << "\nMana: " << spieler.mana << "\nStaerke: " << spieler.staerke << "\n\n\n\n\n\n\n\n";
            cout << "---------------------------------------------------------------"
            << "\n(space=esc)                                        >Go$uNo$u< ...\n";
     }
}

void Figur::char_eingabe()
{

     cout << "KLASSEN - AUSWAHL\n\n"
     << "Druecke 1 um 'Krieger'\n"
     << "zu werden, oder 2 um 'Magier'\n"
     << "auszuwaehlen!\n\n";
     if (!(cin >> spieler.klasse)) {
               cerr << "falsche eingabe";
               exit(1);
               }
     switch(spieler.klasse) {
                            case 1:
                                 // kopieren von Krieger in klass_name 
                                 strncpy(spieler.klass_name, "Krieger",sizeof(spieler.klass_name)-1);
                                 spieler.klass_name[sizeof(spieler.klass_name)-1]='\0';
                                 // kopiert die werte in leben mana und staerke
                                 spieler.spieler_erzeugen( 100, 10, 20);
                                 break;
                            case 2:
                                 strncpy(spieler.klass_name, "Magier",sizeof(spieler.klass_name)-1);
                                 spieler.klass_name[sizeof(spieler.klass_name)-1]='\0';
                                 spieler.spieler_erzeugen( 50, 100, 5);
                                 break;
                            default:
                                    cerr << "falsche eingabe\n";
                                    exit(1);
                                    }

}

void Figur::spiel()
{

     int cha; 
     // hauptschleife solange man nicht space drückt
     while((cha =cin.get()) !=32) {
               switch((char)cha) {
                           case 'd':
                                spieler.daten_ausgabe();
                                break;
                           default:
                                // hier kommt das spiel rein
                                spieler.hauptschleife();
                                }
     }

}

void Figur::spieler_erzeugen( unsigned int l, unsigned int m, unsigned int s)
{
     //hier werden die übergebenen werte an die klassen variablen übergeben... 

     spieler.mana=m;
     spieler.staerke=s;
     spieler.leben=l;
}

int Figur::hauptschleife()
{
    cout << "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nSpiel laueft...\n\n\n\n"
    << "---------------------------------------------------------------\n"
    << "(daten=d)                                           (space=esc) \n";
}

das ding funzt jetzt auch ... wer trozdem noch verbesserungs vorschläge hat. bitte raus damit

• Einrückung wäre toll
• Konstruktor auch

}spieler;

Ist sehr C
*  ```cpp
char name[30];

std::string ist auch zum benutzen da

• Aufteilung in versch. Dateien wäre auch was schönes

ja konstruktoren kommen als nächstes ...
ähmm einrückung... ist doch eingerückt oder was meinste ?

und zu }spieler;

wenn ich das nicht hinschreibe muss ich in jeder funktiion

Figur spieler;

definieren ...oder ?

hatte es so und dann gab es ein problem mit dem übergeben der werte

und von std::string (wussenähhhh) hab ich leider noch nichts gehört ... bin noch ein kleiner anfänger:)
haste da vieleicht nen link zu ??

das aufteilen in mehrere dateien hat ich sowieso noch vor... bin irgendwie nur zu faul:)

Globale Variablen sind "böse". Also sollte man meiden, wenn möglich (was eigl. fast immer möglich ist..)

Hier hast du eine Referenz:
http://www.cplusplus.com/reference/string/

Da hat es auch noch andere nützliche Dinge, wie std::vector , algorithmen usw. drin beschrieben.

int Figur::hauptschleife() 
{ 
    cout << "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nSpiel laueft...\n\n\n\n" 
    << "---------------------------------------------------------------\n" 
    << "(daten=d)                                           (space=esc) \n"; 
}

Das kompiliert tatsächlich? Falls ja, unbedingt den Compiler/die IDE wechseln. (Tipp: Rückgabewert)

Für Variablen, die nur wenige bestimmte Werte annehmen können, lohnt sich ein enum . Das ist eine Sammlung von integralen Konstanten, die leicht über ihren Namen angesprochen und zu einem Typ zusammengefasst werden können.

enum klassentyp
{
    sehr_geheimnisvoller_ninja,
    kungfu_master,
    karate_kid
};

klassentyp klasse;

Das geht auch gut bei switch() :

switch (klasse)
{
    case sehr_geheimnisvoller_ninja: /* ... */
    case kungfu_master: /* ... */
    case karate_kid: /* ... */
}

hab jetzt erstmal das proggi aufgeteilt und konstruktoren dazu jemacht!

so sieht das ganze jetzt aus :

// msmain.cpp

#include "msheader.h"

// main programm

int main(void) {
    Figur spieler;
    begruessung();
    spieler.daten_eingabe();
    spieler.char_eingabe();
    spieler.spiel();
    beenden();
    return 0;
}

...das ist die header datei:

// msheader.h

#include <iostream>
#include <cstring>

#ifndef _MSHEADER_H_
#define _MSHEADER_H_

using namespace std;

// klassen 

class Figur 
{
      private:
             //initialisierung der klassen variablen
             char name[30];
             unsigned int alter;
             unsigned int level;
             int exp;
             int klasse;
             unsigned int leben;
             unsigned int staerke;
             unsigned int mana;
             char klass_name[10];

      public:
             // konstruktoren
             Figur( unsigned int, unsigned int, unsigned int);
             Figur( unsigned int, unsigned int);
             Figur( unsigned int);
             Figur();

             // kassenmethoden
             void daten_eingabe(void);
             void daten_ausgabe(void);
             void char_eingabe(void);
             void spiel(void);
             void spieler_erzeugen( unsigned int l=0,unsigned int m=0, unsigned int s=0);
             int hauptschleife(void);
};

// funktionen werden initialisiert

void begruessung(void);
void beenden(void);

#endif

und zum schluss noch die definitionen:

// meinspiel.cpp

#include <iostream>
#include <cstring>
#include "msheader.h"

using namespace std;

// definition der konsturktoren

Figur::Figur( unsigned int l, unsigned int m, unsigned int s)
{
              leben=l;
              mana=m;
              staerke=s;
}

Figur::Figur( unsigned int l, unsigned int m)
{
              leben=l;
              mana=m;
              staerke=1;
}

Figur::Figur( unsigned int l)
{
              leben=l;
              mana=1;
              staerke=1;
}

Figur::Figur()
{
              leben=1;
              mana=1;
              staerke=1;
}

// funktionen

void begruessung()
{
     cout << "\n\n\n\n\n\n\n\n\n\n\n                ----------------------------------------------\n" 
     << "                |                                            |\n"
     << "                |         >>> KUNGFUPANDA s GAME <<<         |\n"
     << "                |KungFuPanda:-]                    v.01(2009)|\n"
     << "                ----------------------------------------------\n\n\n\n\n\n\n\n\n\n\n\n";
}

void beenden()
{
     cout << "\n\n\n\n\n\n\n\n\n\n\n                ----------------------------------------------\n" 
     << "                |***          thanks for testing!         ***|\n"
     << "                |**      visit www.scheissaufalle.de       **|\n"
     << "                |***             KungFuPanda:-]           ***|\n"
     << "                ----------------------------------------------\n\n\n\n\n\n\n\n\n\n\n\n";
}

void Figur::daten_eingabe()
{

     spieler.level=0;
     spieler.exp=0;
     spieler.leben=0;
     spieler.mana=0;
     spieler.staerke=0;
     cout << "CharackterName: ";
     cin >> spieler.name;
     cout << "Dein Alter: ";
     if(!(cin >> spieler.alter)) {
              cerr << "falsche eingabe";
              exit(1);
              }
}

void Figur::daten_ausgabe()
{

     while( (cin.get()) != 32) {
            cout << "\n\n\n\n   >>> SPIELER DATEN <<<   \n\n\n\n\n\n";
            cout << "\n" << spieler.name << "\n\n"
            << spieler.klass_name << " "
            << spieler.alter << " Jahre" << "\nLevel: " << spieler.level
            << "\nErfahrung: " << spieler.exp << "\nLeben: "
            << spieler.leben << "\nMana: " << spieler.mana << "\nStaerke: " << spieler.staerke << "\n\n\n\n\n\n\n\n";
            cout << "---------------------------------------------------------------"
            << "\n(space=esc)                                        >Go$uNo$u< ...\n";
     }
}

void Figur::char_eingabe()
{

     cout << "KLASSEN - AUSWAHL\n\n"
     << "Druecke 1 um 'Krieger'\n"
     << "zu werden, oder 2 um 'Magier'\n"
     << "auszuwaehlen!\n\n";
     if (!(cin >> spieler.klasse)) {
               cerr << "falsche eingabe";
               exit(1);
               }
     switch(spieler.klasse) {
                            case 1:
                                 // kopieren von Krieger in klass_name 
                                 strncpy(spieler.klass_name, "Krieger",sizeof(spieler.klass_name)-1);
                                 spieler.klass_name[sizeof(spieler.klass_name)-1]='\0';
                                 // kopiert die werte in leben mana und staerke
                                 spieler.spieler_erzeugen( 100, 10, 20);
                                 break;
                            case 2:
                                 strncpy(spieler.klass_name, "Magier",sizeof(spieler.klass_name)-1);
                                 spieler.klass_name[sizeof(spieler.klass_name)-1]='\0';
                                 spieler.spieler_erzeugen( 50, 100, 5);
                                 break;
                            default:
                                    cerr << "falsche eingabe\n";
                                    exit(1);
                                    }

}

void Figur::spiel()
{

     int cha; 
     // hauptschleife solange man nicht space drückt
     while((cha =cin.get()) !=32) {
               switch((char)cha) {
                           case 'd':
                                spieler.daten_ausgabe();
                                break;
                           default:
                                // hier kommt das spiel rein
                                spieler.hauptschleife();
                                }
     }

}

void Figur::spieler_erzeugen( unsigned int l, unsigned int m, unsigned int s)
{
     //hier werden die übergebenen werte an die klassen variablen übergeben... 

     spieler.mana=m;
     spieler.staerke=s;
     spieler.leben=l;
}

int Figur::hauptschleife()
{
    cout << "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nSpiel laueft...\n\n\n\n"
    << "---------------------------------------------------------------\n"
    << "(daten=d)                                           (space=esc) \n";
}

so werd mir das ganze mal zu angucken...

ich hoffe ich hab nicht allzuviel falsch gemacht bei mir funzt es aufjedenfall bis hier hin

welchen compiler sollte ich unter windows verwnden, damit mir sowas nicht mehr passiert ?

Beim Aufteilen in Header und Implementierungsdatei daran denken, das using namespace std; nicht in den Header zu schreiben. Sonst inkludierst du das möglicherweise an anderen Orten und legst den Namensraum frei, obwohl du das gar nicht willst.

also in meinem buch (c++ von a bis z), hat er das halt in die header datei reingeschrieben, darum hab ich das einfach mal auch gemacht. naja werd wohl mal wieder ein bischen rumbasteln und ausprobieren müssen

...bis die tage

Figur::Figur( unsigned int l = 1, unsigned int m = 1, unsigned int s = 1)
: leben(l), mana(m), staerke(s) // <- Initialisierungsliste initialisert Member
{

}

So kannst du den Konstruktor wahlweise mit 0, 1, 2 oder 3 Argumenten aufrufen. Für die Argumente, die du weglässt, wird automatisch 1 angenommen (der Wert hinter dem =).

Edit: Unter Windows würde ich unbedingt Microsoft Visual C++ 2008 Express empfehlen, die ist kostenlos und meines Erachtens sehr gut. Ansonsten gibts auch noch Code::Blocks.

ps visual express läd schon runter(huch ist ja umsonst, was ist denn nur mit unserem bill los, nicht das er krank ist oder so :))

huch ist ja umsonst, was ist denn nur mit unserem bill los, nicht das er krank ist oder so :))

der grund sollte auf der hand liegen...
wenn die leute das programmieren mit msvc erlernen, liegt es ja auch nah, dass sie später mit dieser ide arbeiten möchten, weil sie sich dann schon damit auskennen...

int main(void) {

void in Funktionen anzugeben, die keine Parameter erwarten ist unnötig und imo bäh..
Tragik: gering

...

return 0;
}

Ein return ist bei main nicht erforderlich (im Gegensatz zu allen anderen Funktionen, die einen Wert zurückgeben. Imo eine schrekliche Inkonsistenz)
Tragik: keine

using namespace std;

Das in einem Header.. Das das noch niemand beanstandet hat verwundert mich..
Dein Header wird von anderen Dateien inkludiert und ohne es zu wissen gibst du allem darunter vor, dass sie den Namensraum std benutzen sollen.
Tragik: hoch

char name[30];

Ein C-Array für einen Namen? - Wir leben in Zeiten von C++ und std::string.
Tragik: hoch

Allgemeine Einrückung: Schreklich (habe aber schon schlimmeres gesehen)
Tragik: mittel (schlecht eingerückten Code liest niemand gerne und verwirrt nur unnötig)

#ifndef _MSHEADER_H_

Bezeichner mit Unterstrichen sind für den Compiler reserviert. Du kannst und solltest dieses define so kryptisch nennen, wie du willst, aber eine Regel gibt es: Fang nie mit einem Unterstrich an.
Tragik: mittel (solange der Bezeichner nicht gengut wird, gehts gut. Falls schon: viel Spass beim suchen.

Figur( unsigned int, unsigned int, unsigned int);

Auch wenn es nicht notwending ist bei der Deklaration Namen für die Parameter zu vergeben, würde ich es dringenst empfehlen, da die für sich sprechen und ein besseres Verständnis für die Schnittstelle geben.
Tragik: mittel

hier ist jetzt das ergebnis...
main datei:

//main
#include "kungfu.h"

using namespace std;

int main()
{
	begruessung();
	Figur spieler("unbekannt",0,0,0,0,0,0);
	unsigned int k = spieler.klassen_wahl();
	spieler.klassen_uebergabe(k);
	spieler.hauptschleife();
	verabschiedung();
	return 0;
}

header datei:

// kungfu.h

#include <iostream>
#include <string>

#ifndef _KUNGFU_H_
#define _KUNGFU_H_

class Figur
{
private:
	std::string name;
	std::string klasse;
	unsigned int alter;
	unsigned int level;
	unsigned int leben;
	unsigned int mana;
	unsigned int staerke;
	unsigned int char_klasse;

public:
	//konstuktoren
	Figur( std::string str1, unsigned int a, unsigned int lvl, unsigned int l, unsigned int m, unsigned int s, unsigned int c);
	Figur( std::string str1, unsigned int a, unsigned int lvl, unsigned int l, unsigned int m, unsigned int s);
	Figur( std::string str1, unsigned int a, unsigned int lvl, unsigned int l, unsigned int m);
	Figur( std::string str1, unsigned int a, unsigned int lvl, unsigned int l);
	Figur( std::string str1, unsigned int a, unsigned int lvl);
	Figur( std::string str1, unsigned int a);
	Figur( std::string str1);
	Figur();

	//methoden
	void mache_neuen_spieler( std::string str1, unsigned int a, unsigned int lvl, unsigned int l,unsigned int m, unsigned int s, unsigned int c);
	void zeige_spieler_daten(void);
	unsigned int klassen_wahl(void);
	void klassen_uebergabe( unsigned int ck);
	void hauptschleife();
};

void begruessung(void);
void verabschiedung(void);

#endif

der rest:-):

// kungfu.cpp
#include <iostream>
#include <string>
#include "kungfu.h"

using namespace std;

// normale funktionen 

void begruessung(void)
{
	cout << "\n\n\n\n\n               *----------------------------------------------------------------------------*\n" << 
	"               *                             KungFuPand`s Game                              *\n" <<
	"               *----------------------------------------------------------------------------*\n\n\n\n\n\n";
}

void verabschiedung(void)
{
	cout << "\n\n\n\n\n               *----------------------------------------------------------------------------*\n" << 
	"               *                                 Aufwiedersehn                              *\n" <<
	"               *----------------------------------------------------------------------------*\n\n\n\n\n\n";
}

// klassen konstruktoren

Figur::Figur( std::string str1="unbekannt", unsigned int a=0, unsigned int lvl=0, unsigned int l=0, unsigned int m=0, unsigned int s=0, unsigned int c=0)
	:name(str1), alter(a), level(lvl), leben(l), mana(m), staerke(s), char_klasse(c)
{
	cout << "Neuen Charackter erstellen!\nBitte geben Sie den Namen ein: " << "\n";
	getline(cin, name);
	cout << "\nBitte geben Sie ihr Alter ein: " << "\n";
	if(!(cin >> alter)) 
	{
	cerr << "falsch" << "\n";
	exit (1);
	}
}

Figur::Figur()
	:name("unbekannt"), alter(0), level(0), leben(0), mana(0), staerke(0), char_klasse(0)
{

}

// klassen methoden

/* nicht mehr notwendig da konstruktor vorhanden
void Figur::mache_neuen_spieler( std::string str1, unsigned int a, unsigned int lvl, unsigned int l,unsigned int m, unsigned int s, unsigned int c)
{

	cout << "name: " << "\n";
	getline(cin, name);
	cout << "alter: " << "\n";
	if(!(cin >> alter))
	{
		cerr << "falsch" << "\n";
		exit (1);
	}
}
*/

void Figur::zeige_spieler_daten(void)
{
	int schleifen_abfrage;
	while( ( schleifen_abfrage = cin.get()) != 32)
	{	
	cout << "\n-------Spieler Daten-------" << "\n";
	cout << "::" << klasse << "::\n";
	cout << "CharakterName: " << name << "\n";
	cout << "Dein Alter: " << alter << "\n";
	cout << "Dein Level: " << level << "\n";
	cout << "Lebensenergie: " << leben << "\n";
	cout << "Mana: " << mana << "\n";
	cout << "Staerke: " << staerke << "\n";
	cout << "---------------------------\n";
	cout << "(SPACE=EXIT)\n";
	}
}

unsigned int Figur::klassen_wahl(void)
{
	cout << "\nKlassen Auswahl!\n" <<
	"(1=KampfPanda)(2=KarateYeti)\n";
	if(!(cin >> char_klasse))
	{
		cerr << "falsch";
	}
	return char_klasse;
}

void Figur::klassen_uebergabe( unsigned int ck)
{
	switch(char_klasse)
	{
		case 1:
			klasse= "KampfPanda";
			staerke= 100;mana=10;leben=200;
			break;
		case 2:
			klasse= "KarateYeti";
			staerke= 50;mana=100;leben=100;
			break;
		default:
			klasse= "KeineKlasse";
	}
}

void Figur::hauptschleife(void)
{
	int schleifen_abfrage;
	while( (schleifen_abfrage= cin.get()) != EOF)
	{
		switch( (char)schleifen_abfrage)
		{

			case 'd':
				zeige_spieler_daten();
				break;
			case 'h':
				cout << "HELP :-)";
				break;
			default:
				// spiel
				cout << "\n\n\n\n\n\n\n        *****SPIEL LAEUFT*****\n\n\n\n\n\n\n";
				cout << "(STRG-D=EXIT)(d=SPIELER-DATEN)(h=HELP)\n\n";
		}

	}
}

der gesammte code ist jetzt viel kürzer und
meiner meinung auch übersichtlicher, das ergebnis ist
aber so in etwa das gleiche wie vorher.
hab natürlich auch den compiler gewechselt
das ganze hab ich jetzt unter ubuntu mit kdevelop gemacht.

Figur( std::string str1="unbekannt", unsigned int a=0, unsigned int lvl=0, unsigned int l=0, unsigned int m=0, unsigned int s=0, unsigned int c=0);

Dann kannst du dir die ganzen Implementierungen sparen (was du eigl. auch falsch gemacht hast.. )

Das sieht dann nur so aus:

Figur::Figur( std::string str1, unsigned int a, unsigned int lvl, unsigned int l, unsigned int m, unsigned int s, unsigned int c)
    :name(str1), alter(a), level(lvl), leben(l), mana(m), staerke(s), char_klasse(c)
{...}

Merke: Keine Defaultwerte in der Implementierung. Das gehört in den Header.

ps : wer möchte das ich den ganzen code nochmal poste kann das ja sagen,
ich denke aber sollte auch so klar sein.
nochmal thx für eure hilfe!!!