Testprogramm bricht ab...??

Nexus

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.

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: /* ... */
}

kungfupanda

oh das sind ja ne menge vorschläge (da kommt viel arbeit auf mich zu :-))

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

kungfupanda

so kleiner nachtrag ... hab das ganze auf windows mit bloodshed laufen(hier compiliert er das ganze auch),
doch als ich gestern das ganze unter ubuntu compilieren wollte kamen jede menge fehlermeldungen. du hast also recht ich sollte den compiler wechseln.

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

Nexus

Anstatt vier Konstruktoren zu schreiben, kannst du Standardparameter einsetzen. Zudem wäre es besser, die Initialisierungsliste zu verwenden (anstatt der Zuweisungen im Konstruktorrumpf).

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.

kungfupanda

na das is doch mal ne ansage!
danke für den konstruktiven konstruktor tip
... werd das gleich mal testen

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 :))

unskilled

kungfupanda schrieb:

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...

drakon

Was? Wo bleibt den das ganze Standard-Zeugs?!
Leute.. ihr lasst nach..

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

kungfupanda

Ja ich weiss es ist schon lange her... aber ich hatte halt viel zu tun und es war auch nicht ganz einfach eure vorschläge unterzubringen muss ich sagen. Ich hab einfach wieder ein ganz neues prgramm angefangen, weil mir das zu umständlich war das alte komplett umzuschreiben.

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.

drakon

Ich weiss zwar nicht, was das Problem war/ist, aber das hier ist besser:

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.

kungfupanda

jo super hast recht so gehts auch danke !!!
funzt alles

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!!!