Segmentation Fault! C

LaNgSuYaR

LaNgSuYaR

Power Member
Boas! É o seguinte, eu estou a implementar a recursividade numa função em que os argumentos são dois arrays bi-dimensionais e 2 coordenadas a serem aplicadas a estes. Para a função, envio os apontadores dos respectivos arrays que são do tipo char.

Como eu preciso de verificar a vizinhança de uma célula - verificar elementos num raio de 1 célula - chamo a função que criei recursivamente, com um caso de paragem, obviamente! O que acontece é que, se eu chamar apenas 4 vezes a função (i.e. para os elementos "acima" e para um lateral relativos à celula que estou a considerar) a função funciona correctamente. No entanto, se chamar 5 ou mais vezes - necessito da chamada 8 vezes para cada célula - o programa acaba em "segmentation fault". Disseram-me inclusivé que poderia ser devido a estar a apontar para um array bi-dimensional e eu lá mudei o código todo para um array uni-dimensional funcionando do mesmo modo mas obtenho o mesmo problema!

Alguém me pode esclarecer? Visto que tenho que ter o trabalho pronto em breve, e estou a "stressar" com isto!

Tnkx in advance!
Cumps!
 
dsclpa, não estava no meu PC quando postei!! aqui vai:

Código: 
int vizinhanca(int vert, int hor, int dim, char *field, char *h_field)
{
 int i=0, j;
 
 if(field[(vert)*dim+(hor)] == '0')
  {
  	h_field[vert*dim+hor] = field[vert*dim+hor];
  	i += vizinhanca(vert-1, hor-1, dim, field, h_field);
  	i += vizinhanca(vert-1, hor, dim, field, h_field);
  	i += vizinhanca(vert-1, hor+1, dim, field, h_field);
  	i += vizinhanca(vert, hor-1, dim, field, h_field);
  	i += vizinhanca(vert, hor+1, dim, field, h_field);
  	i += vizinhanca(vert+1, hor-1, dim, field, h_field);
  	//i += vizinhanca(vert+1, hor, dim, field, h_field);
  	//i += vizinhanca(vert+1, hor+1, dim, field, h_field);
  	
      h_field[vert*dim+hor] = '0';
  	return(++i);
  	
  
  }
 else {h_field[vert*dim+hor] = field[vert*dim+hor]; return (++i);}

}

o apontador field e h_field têm os endereços dos arrays que falei anteriormente!

Tenho também uma versão com arrays uni-dimensionais, mas funciona de forma análoga percorrendo um vector atraves da formula [i*dim + j].

Cumps!
 
talvez o melhor seja usar um debbuger.
provavelmente o erro está no critério de paragem, mas não conhecendo as matrizes em que isto vai ser usado não estou a ver qual é o problema.
 
as matrizes estão limitadas por caracteres alfabéticos e a recursividade é assegurada a cada vez que é encontrado um '0'. Como tal, não há maneira de entrar em ciclo infinito i guess!!!

Quanto ao depurador, eu já tentei mas não tenho conseguido! Não tenho muita experiência a nível de depuração! No entanto, se tiver ajuda acerca dos comandos necessários, não há como tentar! Eu uso mac OS X, pelo que há algumas diferenças da depuração em UNIX!
 
LaNgSuYaR disse:
Quanto ao depurador, eu já tentei mas não tenho conseguido! Não tenho muita experiência a nível de depuração! No entanto, se tiver ajuda acerca dos comandos necessários, não há como tentar! Eu uso mac OS X, pelo que há algumas diferenças da depuração em UNIX!
Clicar para expandir...

compila o programa com a flag '-g' (isto permitir-te-á usar opções como o 'list' no gdb, caso precises de ver o código).
depois executa-o com o gdb.
depois executa o comando 'break vizinhanca'.
depois é só fazer 'run' e 'continue' (sempre que o programa parar). entretanto poderás ver quais os argumentos com que a função 'vizinhanca' foi chamada.
 
já está a funcionar! faltava uma condição no primeiro if. Não considerei que o aplicar a função à vizinhança ele ia aplica-la de novo à celula anterior!!

De qualquer das formas, tnkx pela info acerca da depuração!

Cumps!
 
Inicie sessão ou registe-se para poder participar.
Back
Topo