Fun-Soft - Programmierforum

Autor

Thread - Seiten: [ 1 ] > 2 <

010
01.06.2008, 00:03 Uhr
0xdeadbeef
Gott
(Operator)

goto hat, gerade in C++, eine Reihe versteckter Gefahren. Zum Beispiel berücksichtigt es keine Objektzerstörungen, das heißt zum Beispiel

C++:

{
std::string s = "foo";
goto label;
}
label:

erzeugt ein Speicherleck, weil s nie zerstört wird. Auch kann eine Konstruktion übersprungen werden, was dann zu undefiniertem Verhalten führt. Ich gehe jetzt nicht in die Details, welche Auswirkungen das auf Exception-Handling haben kann, aber glaubt mir, da kann es richtig haarig werden. Zusätzlich dazu macht goto den Code in aller Regel äußerst unübersichtlich (vgl. Spaghetti-Code) - ich denke, das ist es, was Suba Esel sagen wollte.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

011
01.06.2008, 08:07 Uhr
Tommix

Zitat von Mind_Freak:

...aber der Hai und der Fisch, bewegen sich immer noch diagonal?!?
Ich glaub ich hab nen falschen ansatz

'Morgen,
zeig mal den geänderten Code in Gänze. Der Aufruf muß in etwa so aussehen:

C++:

//...
{
    feld[i][j]=wasser;
    move(i,j);
    feld[i][j]=fisch;
    fisch.bewegt=true;
}//end if
//...

- Tommix

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

012
01.06.2008, 08:32 Uhr
Mind_Freak

Guten Morgen, erstma danke 0xdeadbeef wegen der erklärung, aber mit was kannn ich goto
ersetzen? und wie sieht die syntax dau aus?

-------------------------------------------------

Morgen Tommix, hier ist der geänderte Code:

C++:

#include <cstdlib>
#include <iostream>
#include <time.h>
#include <stdio.h>
#include <windows.h>
#include <stdlib.h>

using namespace std;

struct Bewohner
{
string figur;
int zaehler;
bool bewegt;
};

int const MAX_LAENGE=10;

int move(int &pos, int &pos2)
{
    int pos3= pos;
    int pos4= pos2;

    unsigned srand(time(NULL));
    int i = rand()%2;

    if(i==0)
    {
       if(pos3!=(MAX_LAENGE-1))
       {
       pos3=pos3+1;
       return pos3;
       }
       else
       {
       pos3=0;
       return pos3;
       }
    }

    if(i==1)
    {
       if(pos3!=0)
       {
       pos3=pos3-1;
       return pos3;
       }
       else
       {
       pos3=(MAX_LAENGE-1);
       return pos3;
       }
    }

    if(i==2)
    {
       if(pos4!=(MAX_LAENGE-1))
       {
       pos4=pos4+1;
       return pos4;
       }
       else
       {
       pos4=0;
       return pos4;
       }
    }

    if(i==3)
    {
       if(pos4!=0)
       {
       pos4=pos4-1;
       return pos4;
       }
       else
       {
       pos4=(MAX_LAENGE-1);
       return pos4;
       }
    }

}// bewege_horizontal_links

int main(int argc, char *argv[])
{

    Bewohner fisch;
    fisch.figur = "o)=(";
    fisch.zaehler = 6;
    fisch.bewegt=false;

    Bewohner hai;
    hai.figur = "o##(";
    hai.zaehler = 8;
    hai.bewegt=false;

    Bewohner wasser;
    wasser.figur ="~~~~";



    Bewohner feld[MAX_LAENGE][MAX_LAENGE];

    for (int i=0; i<MAX_LAENGE;i++)
      for (int j=0; j<MAX_LAENGE; j++)
        feld[i][j] = wasser;



// der Planet erhält einen Fisch und einen Hai
   feld[3][4] =  fisch;
   feld[MAX_LAENGE-1][MAX_LAENGE-1] =  hai;

nochmal:;
if(cin.get())
{
  system("CLS");
  for(;;)//  endlosschleife
  {
    // hier kommt die Ausgabe...
    cout << "\n";
    cout << "\n"<<"--------------------Matrix Fisch-------------------"<<"\n";


    for (int i=0; i<MAX_LAENGE;i++)
    {
      cout <<"\n";
      for (int j=0; j<MAX_LAENGE; j++)
      {
          cout << feld[i][j].figur;
      }
    }

    //  Ende Ausgabe

    //    Fische  bewegen sich....
   for (int i=0; i<MAX_LAENGE;i++)
    {
      for (int j=0; j<MAX_LAENGE; j++)
      {
        if ((feld[i][j].figur == "o)=(")&&(feld[i][j].bewegt==false))
        {
             feld[i][j]=wasser;
             int neu_pos = move(i,j);
             feld[neu_pos][neu_pos]=fisch;
             fisch.bewegt=true;
        }//end if
      }//end for
    }//end for
    cout << "\n";
    cout << "\n"<<"---------------------------------------------------"<<"\n";

       for (int i=0; i<MAX_LAENGE;i++)
    {
      for (int j=0; j<MAX_LAENGE; j++)
      {
        if ((feld[i][j].figur == "o##(")&&(feld[i][j].bewegt==false))
        {
           feld[i][j]=wasser;
           int neu_pos = move(j,i);
           feld[neu_pos][neu_pos]=hai;
           hai.bewegt=true;
        }//end if
      }//end for
    }//end for


    for (int i=0; i<MAX_LAENGE;i++)
    {
      for (int j=0; j<MAX_LAENGE; j++)
      {
        if ((feld[i][j].figur == "o)=(")||(feld[i][j].figur=="o##("))
        {
             feld[i][j].bewegt=false;
        }
      }
    }

   goto nochmal;
  }// end for
}
    cin.get();
    return EXIT_SUCCESS;
}

LG

Mind_Freak

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

013
01.06.2008, 11:10 Uhr
Tommix

Nein...

Zitat:

C++:

int pos3= pos;
int pos4= pos2;

Der Sinn der Referenzen ist ja gerade daß die Daten nicht kopiert werden, damit Du sie ändern kannst.

C++:

void move(int& row, int& column)
{
    switch (rand()%4)
    {
         case 0:
             if (row == MAX_LAENGE-1) row = 0; else ++row;
             break;

         case 1:
             if (row == 0) row = MAX_LAENGE-1; else --row;
             break;

         case 2:
             if (column == MAX_LAENGE-1) ... usw

Das srand mach' nur einmal am Programmbeginn.

- Tommix

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

014
01.06.2008, 12:33 Uhr
Mind_Freak

Vielen Dank, Die Fische bewegen sich endlich überall hin.
Ich werd jt versuchen das sich jt die Fische vermehren und die Haie die Fische fressen sollen.
Denn das Programm soll ungefähr so aus sehn:

C++:

#include <stdio.h>
#include <stdlib.h>

#define TRUE  1
#define FALSE  0

/*
* Wator wird in quadratische Sektoren unterteilt;
* insgesamt gibt es ZEILEN*SPALTEN Sektoren
*/
#define ZEILEN    14
#define SPALTEN   32

#define RICHTUNGEN 4  /* jedes Feld hat 4 Nachbarn */

/*
* in einem Sektor gibt es entweder einen Hai, einen Fisch oder nur Wasser
*/
#define LEER  ' '
#define HAI   'O'
#define FISCH '.'

int nfische;      /* Anzahl der Fische und */
int nhaie;        /* ... Haie zu Beginn */
int fbrut;        /* wann haben die Fische Nachwuchs? */
int hbrut;        /* und die Haie? */
int fasten;       /* solange halten die Haie ohne Nahrung durch */
char wator[ZEILEN][SPALTEN];   /* das Meer von Wator */
int geburt[ZEILEN][SPALTEN];   /* Geburtzeit des Lebewesens auf wator[x][y] */
int hunger[ZEILEN][SPALTEN];   /* Hungerzeit des Hais auf wator[x][y] */
int gezogen[ZEILEN][SPALTEN];  /* Lebewesen auf wator[x][y] bereits bewegt? */
int chronos;      /* Uhr */

void wator_ausgabe()      /* Ausgabe des Feldes `wator' */
{  int zeile, spalte;

   for (zeile = 0; zeile < ZEILEN; ++ zeile)
   {
      for (spalte = 0; spalte < SPALTEN; ++ spalte)
     putchar(wator[zeile][spalte]);
      putchar('\n');
   }
}

void skip_nl()        /* ueberliest den Zeilentrenner */
{  int ch;

   while ((ch = getchar()) != EOF && ch != '\n')
      ;
}

int weiter()      /* liefert TRUE, falls es weiter gehen soll */
{  int ch;

   printf("Weiter? ");
   if ((ch = getchar()) == EOF)
      return FALSE;
   if (ch == '\n')
      return TRUE;
   skip_nl();
   return ch != 'n' && ch != 'N';
}

/*
* liest einen Wert ein
*    `prompt' wird zu Beginn ausgegeben
*    `tip'    ist die Voreinstellung (wird bei Eingabe von <RETURN> gewaehlt)
*/
int wert_einlesen(char *prompt, int tip)
{  int wert;
   int ch;

   do {
      printf("%s [%3d] ", prompt, tip);
      if ((ch = getchar()) == EOF)
         exit(1);  /* Abbruch */
      if (ch == '\n')
         return tip;
      ungetc(ch, stdin);   /* ch zum Wiedereinlesen zurueckgeben */
      scanf("%d", & wert); /* scanf beruecksichtigt jetzt auch `ch' */
      skip_nl();
   } while (wert <= 0);
   return wert;
}

/*
* Initialisierung der Random-Funktion, muss vor dem ersten Aufruf
* von random() aufgerufen werden
*/
void random_init()
{  long seedval;

   printf("Bitte eine beliebige Zahl eingeben: ");
   scanf("%ld", & seedval); skip_nl();
   srand(seedval);
}

/* liefert eine gleichverteilte Zufallszahl innerhalb [von..bis] */
int random(int von, int bis)
{

   long lrand = rand() % 48;
   return von + lrand % (bis - von + 1);
}

/*
* fuellt `anzahl' mal das `lebewesen' gleichverteilt
* auf Felder des Feldes `wator', wobei bereits belegte
* Felder unangetastet bleiben;
* `brut' ist der [hf]brut Parameter des entsprechenden Lebewesens
*/
void fuelle(int anzahl, char lebewesen, int brut)
{  int zeile, spalte;
   int i;

   for (i = 0; i < anzahl; ++i) {
      do {
         zeile = random(0, ZEILEN-1);
         spalte = random(0, SPALTEN-1);
      }
      while (wator[zeile][spalte] != LEER);
      wator[zeile][spalte] = lebewesen;
      geburt[zeile][spalte] = random(0, brut-1);
      hunger[zeile][spalte] = random(0, fasten-1);
   }
}

/*
* initialisiert das Feld `wator' und belegt es mit
*   `nfische'    Fischen und
*   `nhaie'      Haie
* falls die Anzahl zu gross ist, wird FALSE zurueckgeliefert
*/
int init_wator(int nfische, int nhaie)
{  int zeile, spalte;

   if (nfische + nhaie > ZEILEN*SPALTEN)
      return FALSE;

   for (zeile = 0; zeile < ZEILEN; ++ zeile)
      for (spalte = 0; spalte < SPALTEN; ++ spalte)
         wator[zeile][spalte] = LEER;

   fuelle(nhaie, HAI, hbrut);
   fuelle(nfische, FISCH, fbrut);
   return TRUE;      /* alles OK */
}

void init_gezogen()      /* Initialisierung von gezogen[][] */
{  int zeile, spalte;

   for (zeile = 0; zeile < ZEILEN; ++ zeile)
      for (spalte = 0; spalte < SPALTEN; ++ spalte)
         gezogen[zeile][spalte] = FALSE;
}

/*
* Ueberpruefe, ob in wator[zeile][spalte] feldtyp vorliegt,
* wenn ja, wird in nx[index] und ny[index] zeile und spalte abgelegt
* und 1 zurueckgeliefert, ansonsten 0;
* die Koordinaten zeile, spalte duerfen den Rand um eins verlassen -
* in diesem Fall wird zeile und spalte entsprechend der Torusform
* korrigiert
*/
int teste(int zeile, int spalte, char feldtyp,
          int nx[RICHTUNGEN], int ny[RICHTUNGEN], int index)
{
   /* Torusform von Wator */
   if (zeile == -1)
      zeile = ZEILEN-1;
   else if (zeile == ZEILEN)
      zeile = 0;
   if (spalte == -1)
      spalte = SPALTEN-1;
   else if (spalte == SPALTEN)
      spalte = 0;

   if (wator[zeile][spalte] == feldtyp) {
      nx[index] = zeile;
      ny[index] = spalte;
      return 1;
   } else
      return 0;
}

/*
* sucht nach einem Nachbarfeld zu [zeile][spalte] mit
* der Belegung `feldtyp';
* falls erfolgreich (Return-Wert TRUE),
* wird in x und y die Nachbarposition abgelegt
*/
int suche(int zeile, int spalte, char feldtyp, int *x, int *y)
{  int anzahl;    /* Anzahl der Moeglichkeiten */
   int i;
   int nx[RICHTUNGEN], ny[RICHTUNGEN];  /* Nachbarfelder */

   anzahl = 0;
   anzahl += teste(zeile-1, spalte  , feldtyp, nx, ny, anzahl);
   anzahl += teste(zeile  , spalte-1, feldtyp, nx, ny, anzahl);
   anzahl += teste(zeile  , spalte+1, feldtyp, nx, ny, anzahl);
   anzahl += teste(zeile+1, spalte  , feldtyp, nx, ny, anzahl);

   if (anzahl) {
      i = random(0, anzahl-1);
      * x = nx[i];
      * y = ny[i];
      return TRUE;
   } else
      return FALSE;
}

/*
* bewege das Lebewesen auf [zeile][spalte] (HAI oder FISCH)
* entsprechend seiner Vorlieben;
* ggf. gibt es ein Junges
*/
void bewege_tier(int zeile, int spalte)
{  int nx, ny;    /* die Nachbarkoordinaten */
   char art;    /* HAI oder FISCH */
   int brut;    /* Wert von hbrut oder fbrut je nach art */
   int bewegen = FALSE;    /* kann es sich bewegen? */

   art = wator[zeile][spalte];
   if (art == FISCH) {
      bewegen = suche(zeile, spalte, LEER, & nx, & ny);
      brut = fbrut;
   } else { /* art == HAI */
      if (suche(zeile, spalte, FISCH, & nx, & ny)) {
         bewegen = TRUE;
         hunger[nx][ny] = 0;
      } else if (suche(zeile, spalte, LEER, & nx, & ny)) {
     bewegen = TRUE;
         hunger[nx][ny] = hunger[zeile][spalte] + 1;
      }
      if (hunger[zeile][spalte] == fasten) {
         bewegen = FALSE;
         wator[zeile][spalte] = LEER;
      }
      brut = hbrut;
   }
   if (bewegen) {
      wator[nx][ny] = art;
      geburt[nx][ny] = geburt[zeile][spalte];
      if (geburt[zeile][spalte] % brut != chronos % brut)
         wator[zeile][spalte] = LEER;
      else  /* Geburt */
         hunger[zeile][spalte] = 0;
      gezogen[nx][ny] = TRUE;
   }
}

/*
* bewege alle Tiere der Art `art'
*/
void bewege_tiere(char art)
{  int zeile, spalte;

   for (zeile = 0; zeile < ZEILEN; ++ zeile)
      for (spalte = 0; spalte < SPALTEN; ++ spalte)
         if (! gezogen[zeile][spalte] && wator[zeile][spalte] == art)
        bewege_tier(zeile, spalte);
}

int main()
{
   /*printf("\n*** WA-TOR ***\n\n");

   printf("Parameter:\n");
   nfische = wert_einlesen("nfische", 200);
   nhaie =   wert_einlesen("nhaie  ",  20);
   fbrut =   wert_einlesen("fbrut  ",   3);
   hbrut =   wert_einlesen("hbrut  ",  10);
   fasten =  wert_einlesen("fasten ",   3);*/

   random_init();
   if (!init_wator(nfische, nhaie)) {
      printf("Zuviele Haie oder Fische!\n");
      exit(1);
   }

   for (chronos = 0; wator_ausgabe(), weiter(); ++chronos)
   {  init_gezogen();
      bewege_tiere(FISCH);
      bewege_tiere(HAI);
   }

   return 0;
}

ich weiß es ist ein weiter weg dahin, aber ich werd es irgendwann schaffen, danke an alle.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

015
01.06.2008, 14:52 Uhr
Mind_Freak

Ich hätte da mal noch eine frage, und zwar wie stelle ich das an , das der Hai nur den Fisch fressen darf und nicht umgekehrt oder wenn ein Hai auf ein Hai trifft, das die sich nciht gegenseitig treffen?

danke im Voraus

MfG

Mind_Freak

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: [ 1 ] > 2 < [ C / C++ (WinAPI, Konsole) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: