3. Segfault in if-Anweisung

Segfault in if-Anweisung

  • B

    Hallo,

    erstmal möchte ich mich für den folgenden Quelltext entschuldigen, da er eine Mischung aus C und C++ ist und nur wenig strukturiert.

    Mein Problem ist in folgendem Programm zu finden (im wesentlich die fette if-Anweisung):

    #include <cstdlib>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <iostream>

using namespace std; 

#define lmax 200
#define rs (rmax+2.)
#define rd (rmax+5.)
#define rkill (100.*rmax)

double pi = acos(-1), rmax = 1.0;

double max(double a, double b)
{
 double maxi;
 if(a>b) maxi = a;
 else maxi = b;
 return(maxi);
}

double dim(int counter)
{
 double D;
 D=log((double)counter)/log((double)lmax);
 return(D);      
}

/*============================================================================*/
/*============================================================================*/
/*============================================================================*/
/*===============================Entering=====================================*/
/*============================================================================*/
/*=============================Main-Function==================================*/
/*============================================================================*/
/*============================================================================*/
/*============================================================================*/
/*============================================================================*/

int main(int* argc, char* argv[])
{
 FILE* f=fopen(argv[1],"w");
 int i,j,counter;
 int k=0;
 int rx=0,ry=0;
 double D, phi, x, y, r;

 int **xf=new int*[lmax];
 for(i=0;i<lmax;i++)
 {
  xf[i]=new int[lmax];
 }

 for(i=0;i<lmax;i++)
 for(j=0;j<lmax;j++)
 {
  xf[i][j]=0;                   
 }

 xf[lmax/2][lmax/2]=1;

 phi=(double)(rand()/RAND_MAX*2.*pi);
 rx=(int)(rs*cos(phi));
 ry=(int)(rs*sin(phi));

 srand(time(NULL));
 i=rand()%5;
 {
  if(i==0) rx+=1;
  if(i==1) rx+=-1;
  if(i==2) ry+=1;
  if(i==3) ry+=-1;
 }

 while(1)
 {
  k++;
  printf("%d  \n", k);
  if(sqrt(rx*rx+ry*ry)>rkill)
  { 
    phi=(double)(rand()/RAND_MAX*2.*pi);
    rx=(int)(rs*cos(phi));
    ry=(int)(rs*sin(phi)); 
    //srand(time(NULL));
    i=rand()%5;
    {
     if(i==0) rx+=1;
     if(i==1) rx+=-1;
     if(i==2) ry+=1;
     if(i==3) ry+=-1;
    }
  }
  [b]if(rx<lmax/2 && ry<lmax/2 && rx > -lmax/2 && ry >-lmax/2 && xf[rx+1+lmax/2][ry+lmax/2]+xf[rx-1+lmax/2][ry+lmax/2]+xf[rx+lmax/2][ry+1+lmax/2]+xf[rx+lmax/2][ry-1+lmax/2]>0 )
  { 
    xf[rx+lmax/2][ry+lmax/2]+=1;
    x=(double)rx;y=(double)ry;
    rmax = max(rmax,sqrt(x*x+y*y));
    if(rmax>lmax/2.-5.) {printf("\7");getchar();exit(1);};
    phi=(double)(rand()/RAND_MAX*2.*pi);
    rx=(int)(rs*cos(phi));
    ry=(int)(rs*sin(phi));

    //srand(time(NULL));
    i=rand()%5;
    {
     if(i==0) rx+=1;
     if(i==1) rx+=-1;
     if(i==2) ry+=1;
     if(i==3) ry+=-1;
    } 
  }[/b]
  if(sqrt(rx*rx+ry*ry)>=rd)
  { 
    phi=(double)(rand()/RAND_MAX*2.*pi);
    x=(double)rx; y=(double)ry; r=sqrt(x*x+y*y);
    rx+=(int)((r-rs)*cos(phi));
    ry+=(int)((r-rs)*sin(phi));
  }
  else
  { 
    //srand(time(NULL));
    i=rand()%5;
    {
     if(i==0) rx+=1;
     if(i==1) rx+=-1;
     if(i==2) ry+=1;
     if(i==3) ry+=-1;
    }
  }
 }

 for(rx=0;rx<lmax;rx++)
 for(ry=0;ry<lmax;ry++)
 {
  if(xf[rx+lmax/2][ry+lmax/2]!=0)
  {
   counter+=1;
   fprintf(f,"%d  %d \n", rx+lmax/2,ry+lmax/2);
  }
 }
 D=dim(counter);
 cout << "Simulation beendet" <<endl;
 cout << "Die fraktale Dimension (Boxdimension) lautet:   " << D << endl;
 cout << "Bitte drücken Sie eine Taste, um das Programm zu verlassen. Sie finden Íhre Ergebnisse in:  "<< argv[0] <<endl;
 getchar();
 for(i=0;i<lmax;i++)
 {
  delete[] xf[i];                  
 }

 delete[] xf;   
 fclose(f);  
}

    Ich sitze jetzt wirklich einige Tage davor und weiß nich, woher der segfault kommt, weil ich eigentlich der Meinung bin, genügend Speicher alloziert zu haben.

    Wäre nett, wenn mir jemand helfen könnte (und entschuldigt bitte nochmals die grauenhafte Form).

    MfG

    Borninger

    0
  • C

    *mal kurz überfliegt* lmax ist 200, also lmax/2==100 - damit liegen die Werte für rx und ry im Bereich -99..99 und du greifst auf die Indizes von 2..200 bzw. 1..199 (für "xf[rx+1+lmax/2][ry+lmax/2]") zu - ersterer liegt bereits außerhalb des verfügbaren Speicherplatzes.

    0
  • B

    Hey Danke,

    das war das Problem. Naja is nich gut, wenn man nich rechnen kann.

    Ich versuche jetzt mal das alles zu simulieren.

    Ciao

    0
  • T

    Noch ein Nachtrag:
    Wenn bei dir 'lmax' sowieso eine Konstante (bzw. define) ist, warum reservierst du dann dynamisch Speicher?

    const int LMAX = 200; // besser als define
int xf[LMAX][LMAX];

    Und sehr leserlich ist der Code nicht (Einrückungen, alles in der main-Funktion, ...).
    Zumindestens für

    i=rand()%5;
if(i==0) rx+=1;
if(i==1) rx+=-1;
if(i==2) ry+=1;
if(i==3) ry+=-1;

    solltest du dir eine (Inline-)Funktion definieren (hast du 4x in deinem kurzen Code), z.B. so

    inline
void DoRandom(int &x, int &y)
{
  switch(rand()%5)
  {
    case 0: x+=1; break;
    case 1: x-=1; break;
    case 2: y+=1; break;
    case 3: y-=1; break;
    case 4: break; // do nothing
  }
}

//Aufruf dann einfach mit
DoRandom(rx, ry);
    0
Anmelden zum Antworten