feld mit klassen, geht das? Habe einen Knoten im Hirn.



  • Ich hoffe die Überschrift implementiert es schon:
    Ich habe ein übel großes Verständnisproblem und brauche eventuell Hilfe/Denkanstöße.

    Ich code gerade schmutzig vor mich hin. Ein kleines Game Of Life soll entstehen.
    (das ganze mit Hilfe der libSDL auf Linux(zuHause) -> um es später einfach nach Windoof(Schule) portieren zu können).

    Themengebiet ist OOP, also sollen das hübsch' Klassen eingebaut werden.

    Nun habe ich schon das Ausgabefeld mit Hilfe von struct als Feld(auf dynamische Größe ausgelegt) so quasi mit pointern auf das NachfolgeStruct aufgebaut - so viel zur grafischen Ausgabe.

    Aber die klasse, die später das eigentliche Spielfeld für die Berechnung aufnimmt bekomme ich auf diese Weise nicht hin.
    ...bin einfach noch zu dumm.

    Nun ist die Frage, wie arbeite ich mit pointern in Klassen?
    Und können überhaupt mir klassen (sinnvoll) Felder angelegt werden?
    Oder gibt es noch viele andere tipps, eventuell eine andere Lösung?

    hier meine ersten versuche:
    golclass.h

    #ifndef golclass_h
    #define golclass_h
    
    class Lebensform
    {
    private:
    	class Lebensform *next;
    	short x;
    	short y;
    	short life;
    	short tmp;
    
    protected:
    
    public:
    	//Konstruktor
    	//Lebensform(class *Lebensform);
    	Lebensform();
    	//Destruktor
    	~Lebensform();
    	//Methoden
    	void AddLebensform(class Lebensform);
    	int WertAusgabe(int, int);
    
    };
    
    #endif
    

    golclass.cc

    #include "golclass.h"
    
    //Lebensform::Lebensform(class Lebensform *lifestart)
    //{
    //	class Lebensform *lifestart=0;
    //}
    
    Lebensform::Lebensform()
    {
    	x=1;
    	y=1;
    	life=0;
    	tmp=0;
    }
    
    Lebensform::~Lebensform()
    {
    
    }
    
    void Lebensform::AddLebensform(class Lebensform *lifestart)
    {
    	life->next = lifestart;
    	lifestart = life;	
    }
    
    int Lebensform::WertAusgabe(int X, int Y)
    {
     return 0;
    }
    

    Auszug aus main.cc

    [...]
    	class Lebensform *lifestart = 0;
     for(short i=1; i <= (gamesizeX*gamesizeY); i++)
      {
         class Lebensform *life();
    	 //*life = (class Lebensform *)malloc( sizeof( class Lebensform));
    	 *life.AddLebensform(&lifestart);
      }
    [...]
    

    DANKE für eure Mühe.
    sollte ich noch wesentliche Infos vergessen haben, einfach annörgeln. 😉

    PS: Natürlich hab ich vorher viel gegooglet, gesucht und selber ausprobiert.



  • Naja will ja nicht rumnörgeln

    aber deine klasse und somit das programm ist nicht der hit

    In deiner Klasse Lebensform kommt das rein, was eine "lebensform" ist.

    sprich

    life
    x
    y ( koordinaten )
    energy
    was weiss ich
    dasBildderLebensform

    dann machst du eine 2te klasse "FELD" z.b. die im konstruktor die grösse hat ( z.b. 20*50 feld )

    und dann setzt du in feld eine lebensform oder wenn es die klasse FELD zulässt mehrere lebensformen

    in deiner "klasse"

    in main() da erzeugst du zuerst ein objekt FELD und dann setzt du die lebensformen rein und kannst das feld ausgeben

    die ausgabe des feldes erfolgt in der klasse FELD

    z.b.

    Feld meinfeld(20,50);
    meinfeld.addlebensform(2,5);// hier überprüfen ob die parameter stimmen können
    oder auch
    meinfeld.add_in_jedes_feld();
    
    meinfeld.ausgeben();  // hier wird z.b. in der konsole oder grafisch unter SDL das feld gezeichnet mit den lebensformen
    


  • hm.

    ich glaube ich verstehe dich nicht ganz.
    ... und du mich glaube ich auch nicht^^

    ich habe aber einfach noch bissel weitergewerkelt.
    Ich denke so ähnlich müsste ich eine Feld erzeugen können.

    ich poste einfach nochmal meinen Fehlerhaften Code.
    Hab bischen verfeinert und bekomme jetzt nur noch wenige Fehler.

    main.cc

    [...]
    class Lebensform *lifestart = 0;//Startmarke des class-Feldes
    for(short i=1; i <= gamesizeX; i++)
    {
     for(short j=1; j <= gamesizeY; j++)
      {
       class Lebensform life(i, j);
       //*life = (class Lebensform *)malloc( sizeof( class Lebensform));//entfällt?
       *life.AddLebensform(*lifestart, *life);//einfuegen von life in das Feld
     }
    }
    [...]
    

    golclass.h

    #ifndef golclass_h
    #define golclass_h
    
    class Lebensform
    {
    private:
    	class Lebensform *next;
    	short x;
    	short y;
    	short life;
    	short tmp;
    
    protected:
    
    public:
    	//Konstruktor
    	//Lebensform(class *Lebensform);
    	Lebensform(short, short);
    	//Destruktor
    	~Lebensform();
    	//Methoden
    	void AddLebensform(class Lebensform *lifestart, class Lebensform *life);
    	int WertAusgabe(int, int);
    
    };
    
    #endif
    

    golclass.cc

    #include "golclass.h"
    
    //Lebensform::Lebensform(class Lebensform *lifestart)
    //{
    //	class Lebensform *lifestart=0;
    //}
    
    Lebensform::Lebensform(short X, short Y)
    {
    	x=X;
    	y=Y;
    	life=0;
    	tmp=0;
    }
    
    Lebensform::~Lebensform()
    {
    
    }
    
    void Lebensform::AddLebensform(class Lebensform *lifestart, class Lebensform *life)
    {
    	life->next = lifestart; //erschaffene Klasse *life, soll 
    	lifestart = life;		//in das Feld eingefuegt werden
    }
    
    int Lebensform::WertAusgabe(int X, int Y)
    {
     return 0; //Dummy-Wert
    }
    

    Die Fehler liegen in der main.cc im Aufruf von AddLebensform().
    Vermutlich übergebe ich die pointeradressen falsch. Ich denke doch, dass ich die übergeben muss und nichts anderes?!?
    Vermutlich sind aber auch die Zeigerdeklarationen im AddLebensform-Kopf falsch(class Lebensform *lifestart, class Lebensform *life -> Augenmerk auf die Sternchen, gehören die dahin?).
    Oder auch etwas gaaanz anderes.



  • ok, ich hab es jetzt hinbekommen.
    Allerdings ist die Aufbauzeit derart gruselig, dass ich noch nach einer besseren Lösung suchen werde.

    golclass.h

    /***************************************************************************
     *            golclass.h
     *
     *  Sun Mar 13 13:39:02 2005
     *  Copyright  2005  User
     *  Email
     ****************************************************************************/
    
    /*
     *  This program is free software; you can redistribute it and/or modify
     *  it under the terms of the GNU General Public License as published by
     *  the Free Software Foundation; either version 2 of the License, or
     *  (at your option) any later version.
     *
     *  This program is distributed in the hope that it will be useful,
     *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     *  GNU Library General Public License for more details.
     *
     *  You should have received a copy of the GNU General Public License
     *  along with this program; if not, write to the Free Software
     *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
     */
    
    #include <stdlib.h>
    #include <iostream>
    #ifndef golclass_h
    #define golclass_h
    
    class Lebensform
    {
    private:
    	Lebensform *next;
    	short x;
    	short y;
    	short alive;
    	short tmp;
    
    protected:
    
    public:
    	//Konstruktor
    	//Lebensform(class *Lebensform);
    	Lebensform(short, short);
    	//Destruktor
    	~Lebensform();
    	//Methoden
    	void AddLebensform(Lebensform*);
    	short WertHolen(Lebensform*, short, short);
    	short Lebensform::WertSetzen(Lebensform*, short, short, short, short, short);
    	void Lebensform::NGeneration(Lebensform*, short, short);
    
    };
    
    #endif
    

    golclass.cc

    /***************************************************************************
     *            golclass.cc
     *
     *  Sun Mar 13 13:41:22 2005
     *  Copyright  2005  User
     *  Email
     ****************************************************************************/
    
    /*
     *  This program is free software; you can redistribute it and/or modify
     *  it under the terms of the GNU General Public License as published by
     *  the Free Software Foundation; either version 2 of the License, or
     *  (at your option) any later version.
     *
     *  This program is distributed in the hope that it will be useful,
     *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     *  GNU Library General Public License for more details.
     *
     *  You should have received a copy of the GNU General Public License
     *  along with this program; if not, write to the Free Software
     *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
     */
    
    #include <stdlib.h>
    #include <iostream>
    #include "SDL.h"
    #include "golclass.h"
    
    //Lebensform::Lebensform(class Lebensform *lifestart)
    //{
    //	class Lebensform *lifestart=0;
    //}
    
    Lebensform::Lebensform(short X, short Y)
    {
    	x=X;
    	y=Y;
    	alive=0;
    	tmp=0;
    }
    
    Lebensform::~Lebensform()
    {
    
    }
    
    void Lebensform::AddLebensform(Lebensform *lifestart)
    {
    	next = lifestart; //erschaffene Klasse *life soll an life start angehängt werden
    }
    
    short Lebensform::WertHolen(Lebensform *lifestart, short X, short Y)
    {
    	//std::cout << lifestart << std::endl;
    	for(Lebensform *p_life=lifestart; p_life ; p_life = p_life->next)
    	{
    		if((p_life->x==X) && (p_life->y==Y))
    		{
    			return p_life->alive;
    			break;
    		}
    	}
    
    	return 0;
    }
    
    short Lebensform::WertSetzen(Lebensform *lifestart, short X, short Y, short A, short procedure, short alive_or_tmp)
    {
    	int ret = 0;
    	for(Lebensform *p_life=lifestart; p_life ; p_life = p_life->next)
    	{
    		if((p_life->x==X) && (p_life->y==Y))
    		{
    			switch(procedure)
    			{
    				case 1:
    				if(p_life->alive==1){A = 1;} //leben erhalten
    				break;
    
    				default: //brutal ueberschreiben
    				break;
    			}
    
    			switch(alive_or_tmp)
    			{
    				case 0:
    				p_life->alive = A;
    				break;
    
    				case 1:
    				p_life->tmp = A;
    				break;
    
    				case 2:
    				p_life->alive = A;
    				p_life->tmp = A;
    				break;
    
    				default: 
    				break;
    			}
    
    			ret = A;
    			break;
    
    		}
    	}
    	return A;
    }
    
    void Lebensform::NGeneration(Lebensform *lifestart, short X, short Y)
    {
    	short nearbes;
    	short nearbe[8]={0, 0, 0, 0, 0, 0, 0, 0};
    	for(short i=X+1; i>=2; i--)
    	{
    		for(short j=Y+1; j>=2; j--)
    		{
    			Lebensform *Wechselbalg;
    
    			for(Lebensform *p_life=lifestart; p_life; p_life = p_life->next)
    			{
    				if((p_life->x==i) && (p_life->y==j))
    				{
    					if(p_life->alive>0) {nearbe[0]=1;}
    
    					if((p_life->next->x==i) && (p_life->next->y=j-1))
    					{if(p_life->next->alive>0) {nearbe[1]=1;}}
    					else
    					{if(p_life->WertHolen(lifestart, i, j-1)>0) {nearbe[1]=1;}}
    
    					if((p_life->next->next->x==i) && (p_life->next->next->y=j-2))
    					{if(p_life->next->next->alive>0) {nearbe[2]=1;}}
    					else
    					{if(p_life->WertHolen(lifestart, i, j-2)>0) {nearbe[2]=1;}}
    
    					continue;
    				}
    
    				if((p_life->x==i-1) && (p_life->y==j))
    				{
    					if(p_life->alive>0) {nearbe[3]=1;}
    
    					if((p_life->next->x==i-1) && (p_life->next->y=j-1))
    					{Wechselbalg = p_life->next;}
    					else
    					{
    						for(Lebensform *e_life=lifestart; e_life ; e_life = e_life->next)
    						{if((e_life->x==i-1) && (e_life->y==j-1)) {Wechselbalg = e_life; Wechselbalg->tmp = 1;}}
    					}
    
    					if((p_life->next->next->x==i-1) && (p_life->next->next->y=j-2))
    					{if(p_life->next->next->alive>0) {nearbe[4]=1;}}
    					else
    					{if(p_life->WertHolen(lifestart, i-1, j-2)>0) {nearbe[4]=1;}}
    
    					continue;
    				}
    
    				if((p_life->x==i-2) && (p_life->y==j))
    				{
    					if(p_life->alive>0) {nearbe[5]=1;}
    
    					if((p_life->next->x==i-2) && (p_life->next->y=j-1))
    					{if(p_life->next->alive>0) {nearbe[6]=1;}}
    					else
    					{if(p_life->WertHolen(lifestart, i-2, j-1)>0) {nearbe[6]=1;}}
    
    					if((p_life->next->next->x==i-2) && (p_life->next->next->y=j-2))
    					{if(p_life->next->next->alive>0) {nearbe[7]=1;}}
    					else
    					{if(p_life->WertHolen(lifestart, i-2, j-2)>0) {nearbe[7]=1;}}
    
    					break;
    				}
    			}
    
    			for(short i=0; i<=7; i++)
    			{
    				nearbes = nearbes + nearbe[i];
    				nearbe[i]=0;
    			}
    
    			if(nearbes==3) {Wechselbalg->tmp = 1;}
    			if((nearbes<2) || (nearbes>3)) {Wechselbalg->tmp = 0;}
    			nearbes=0;
    
    		}
    	}
    	//uebertragen (von tmp nach alive)
    	for(Lebensform *p_life=lifestart; p_life; p_life = p_life->next)
    	{
    		p_life->alive = p_life->tmp;
    	}
    }
    

    main.cc

    //SPIELFELD ERZEUGEN
    Lebensform *lifestart = 0;//Startmarke des class-Feldes
    for(short i=0; i <= gamesizeX+1; i++)
    {
    	for(short j=0; j <= gamesizeY+1; j++)
    	{
    		Lebensform *life;
    		life = new Lebensform(i, j);
    		life->AddLebensform(lifestart);//einfuegen von life in das Feld
    		lifestart = life; //lifestart bekommt neue Adresse
    	}
    }
    std::cout << "Set Lebensform" << std::endl;
    std::cout << lifestart << std::endl;
    
    [...]
    
    			// +RANDOM & RESET ANFANG
    			if(((random) || (reset)) && (stop))
    			{
    				srand(endzeit);
    				for(short i=1; i <= gamesizeX; i++)
    				{
    					for(short j=1; j <= gamesizeY; j++)
    					{
    						short alive;
    						short leben_erhalten;
    
    						if(random)
    						{
    							if((rand() %50+1)<15)
    							{
    								alive=1;
    								leben_erhalten=1;
    							}
    							else
    							{
    								alive=0;	
    								leben_erhalten=1;
    							}
    						}
    
    						if(reset)
    						{
    							alive=0;
    							leben_erhalten=0;
    						Lebensform *life;
    						life->WertSetzen(lifestart, i, j, alive, leben_erhalten, 2);
    						}
    
    						Lebensform *life;
    						life->WertSetzen(lifestart, i, j, alive, leben_erhalten, 2);
    					}
    				}
    				random = 0;
    				reset = 0;
    			}
    			// +RANDOM & RESET ENDE
    
    			// AUFBAU ANFANG
    			switch(zoom)
    			{
    				//case 0: felderzahlx=(ex-sx)/2; felderzahly=(ey-sy)/2; zoomi=2; break;
    				case 1: felderzahlx=(field_endx-field_startx)/4; felderzahly=(field_endy-field_starty)/4; zoomi=4; break;
    				case 2: felderzahlx=(field_endx-field_startx)/8; felderzahly=(field_endy-field_starty)/8; zoomi=8; break;
    				case 3: felderzahlx=(field_endx-field_startx)/12; felderzahly=(field_endy-field_starty)/12; zoomi=12; break;
    				case 4: felderzahlx=(field_endx-field_startx)/16; felderzahly=(field_endy-field_starty)/16; zoomi=16; break;
    				default: felderzahlx=(field_endx-field_startx)/8; felderzahly=(field_endy-field_starty)/8; zoomi=8; break;
    			}
    
    			int anzahl = 1;
    			for(short i=1; ((i <= felderzahlx) && (anzahl <= (felderzahlx*felderzahly))); i++)
    			{
    				for(short j=1; ((j <= felderzahly) && (anzahl <= (felderzahlx*felderzahly))); j++, anzahl++)
    				{
    					struct golo *g;
    					Lebensform *life;
    
    					if (first_call==0) 
    					{
    						for(g = start; g; g = g->next)
    						{
    							if((g->x==i) && (g->y==j))
    							{
    								short lifewert = life->WertHolen(lifestart, i+move_leftright, j+move_updown);
    								if(g->t != lifewert)
    								{
    									g->t = lifewert;
    									if (g->t==0)
    									{
    										g->image = IMG_Load("gold.bmp");
    									}
    									else 
    									{
    										g->image = IMG_Load("goll.bmp");
    									}
    									TestImage(g->image);
    									//Move_Field_Image(SCREEN, g->image, 0, 0, ((i*zoomi)-zoomi)+133, ((j*zoomi)-zoomi)+33, zoomi, zoomi, field_startx, field_endx, field_starty, field_endy, move_updown, move_leftright);
    									MoveImage(SCREEN, g->image, 0, 0, ((i*zoomi)-zoomi)+133, ((j*zoomi)-zoomi)+33, zoomi, zoomi);
    								}
    							}
    						}
    					}
    	 				else
    					{
    						g = (struct golo *)malloc( sizeof( struct golo));
    						g->x = i;
    						g->y = j;
    						g->t = life->WertHolen(lifestart, i+move_leftright, j+move_updown);
    						if (g->t==0) {g->image = IMG_Load("gold.bmp");}
    						else {g->image = IMG_Load("goll.bmp");}
    						TestImage(g->image);
    						//Move_Field_Image(SCREEN, g->image, 0, 0, ((i*zoomi)-zoomi)+133, ((j*zoomi)-zoomi)+33, zoomi, zoomi, field_startx, field_endx, field_starty, field_endy, move_updown, move_leftright);
    						MoveImage(SCREEN, g->image, 0, 0, ((i*zoomi)-zoomi)+133, ((j*zoomi)-zoomi)+33, zoomi, zoomi);
    						g->next = start;
    						start = g;
    					}
    				}
    			}
    			first_call = 0;
     			// AUFBAU ENDE
    
    			// LET'S GO
    			if(!stop)
    			{
    				Lebensform *life;
    				life->NGeneration(lifestart, gamesizeX, gamesizeY);
    			}
    			// ENDE
    		}
    

  • Mod

    mit OOP hat das aber nicht viel zu tun. ist auch noch eine menge gruseliges C drin.


Log in to reply