Discussion :

[djdelarue]

Bonjour à tous, voila je suis bien embeter car j'ai une erreur dans mon programme mais je n'arrive pas à trouver ou elle se situe (du moins à quel moment :\ )

Voici ma fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
char** cle_complete(char** cle_final) //Cree tout les types de clé possible
{
 int x,i,j,l,m;
 char** aux=malloc(sizeof(char*));
 i=0;
 l=0;
 for(i=0;i<nb_car.nb[0];i++)
 {
   j=0;
   for(j=0;j<nb_car.nb[1];j++)
   {
	 x=0;
	 for(x=0;x<nb_car.nb[2];x++)
	 {
	   aux=realloc(aux,sizeof(char*)*(l+1));
	   for(m=0;m<3;m++)
		{
		   aux[l] = realloc(aux,sizeof(char)*(m));
		}
	   aux[l][0]=cle_final[0][i];
	   aux[l][1]=cle_final[1][j];
	   aux[l][2]=cle_final[2][x];
	   l++;
	 }
   }
 }
 return aux;
}

Alors cle_final est un tableau contenant un tableau de caractères et le but est de créer tout les mots possibles que je vais mettre dans mon aux, je n'aurai jamais plus de 3 occurences dans aux donc le programme est bon (du moins dans l'idée)
Voila donc quand j'execute le programme, il s'execute bien, rempli mon tableau aux et une fois que j'arrive tout à la fin de mes boucles, que tout le boulot est fait j'ai le droit à un segmentation fault

voici un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
C1[0]:aib
C1[1]:eak
C1[2]:Npm
1 aeN
2 aep
3 aem
4 aaN
5 aap
6 aam
7 akN
8 akp
9 akm
10 ieN
11 iep
12 iem
13 iaN
14 iap
15 iam
16 ikN
17 ikp
18 ikm
19 beN
20 bep
21 bem
22 baN
23 bap
24 bam
25 bkN
26 bkp
27 bkm
Segmentation fault (core dumped)

Du coup c'est assez embetant car ça me bloque :\

Avez-vous une idée du pourquoi de cette erreur?

Merci d'avance de vos prochaines réponses

[Bousk]

Bonjour,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
aux=realloc(aux,sizeof(char*)*(l+1));
	   for(m=0;m<3;m++)
		{
		   aux[l] = realloc(aux,sizeof(char)*(m));
		}

Pourquoi faire 2 réallocations à la suite ? Alors que je ne vois aucune allocation auparavant. Pour initialiser 3 cases à priori, c'est vraiment trop compliqué.

D'où sort nb_car ? Quel est cet entité ?
Es-tu sûr que cle_final est correctement initialisé et a la valeur que tu espères y trouver ?

Edit:
Je trouve qu'il serait plus clair de réaliser une structure pour gérer un résultat

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
struct Result
{
  char result[4];
}
 
Result* GetResults(char** cle)
{
  Result* aux;
  int i,j,k,l;
  aux = malloc(3*3*3*sizeof(Result)); // 3*3*3 pour les dimensions
  l = 0;
  for (i = 0; i < 3; ++i)
  {
    for (j = 0; j < 3; ++j)
    {
      for (k = 0; k < 3; ++k)
      {
        aux[l].result[0] = cle[0][i];
        aux[l].result[1] = cle[1][j];
        aux[l].result[2] = cle[2][k];
        aux[l].result[3] = '\0';
        ++l;
      }
    }
  }
  return aux;
}

J'ai gardé ta structure de lecture de cle.

[djdelarue]

Je fais un realloc pour le premiere indice soit le char* et un deuxieme pour mes char car si je ne faisais pas cette realocation j'avais un segmentation fault :\

Ah oui j'ai oublié de le dire nb_car est une structure contenant le nombre de caractères par indice de cle_final (la dans l'exemple il y en a que 3 mais je peux en avoir jusqu'a 10) cela depend

Edit: Le probleme étant que dans mon cahier des charges je dois faire un tableau dynamique et non une structure sinon je suis d'accord la structure est mieux. Mais bon je pense que je vais passer sur une structure car le tableau dynamique est une prise de tete pour ce cas la :\

[Bousk]

La structure n'influe en rien sur l'aspect "tableau dynamique".

Le fait est que, amha, tes alloc sont au petit bonheur la chance.

Tu connais la taille de ton tableau dès le début, alors les realloc au milieu ne sont que sources d'erreur supplémentaires potentielles.
Quant au 2° realloc, il est éronné puisqu'il s'agit de la première initialisation, et on devrait donc y trouver un malloc simple.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char** aux=malloc(sizeof(char*)*nb_car.nb[0]*nb_car.nb[1]*nb_car.nb[2]);

et supprimer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

aux=realloc(aux,sizeof(char*)*(l+1));

Remplacer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for(m=0;m<3;m++)
		{
		   aux[l] = realloc(aux,sizeof(char)*(m));
		}

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

aux[l] = malloc(4*sizeof(char));

En écrivant et lisant ça, la source d'erreur est sûrement cette dernière allocation : tu alloues 2 char (m max vaudra 2), et tu y stockes 3 caractères !

[djdelarue]

Je te remercie beaucoup ça a résolue un de mes premier soucis mais par contre j'ai encore un probleme, impossible de retourner mon char** dès que j'accede au return j'ai un segmentation fault. Tu crois que ça viens de cette fonction ou d'ailleurs?

Voici la fonction après tes conseils:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
char** cle_complete(char** cle_final) //Cree tout les types de clé possible
{
 int x,i,j,l,m;
 char** aux=malloc(sizeof(char*)*nb_car.nb[0]*nb_car.nb[1]*nb_car.nb[2]);
 l=0;
 for(i=0;i<nb_car.nb[0];i++)
 {
   j=0;
   for(j=0;j<nb_car.nb[1];j++)
   {
	 x=0;
	 for(x=0;x<nb_car.nb[2];x++)
	 {
	   aux[l] = malloc(4*sizeof(char));
	   aux[l][0]=cle_final[0][i];
	   aux[l][1]=cle_final[1][j];
	   aux[l][2]=cle_final[2][x];
	   aux[l][3]='\0';
	   l++;
	 }
   }
 }
 return aux;
}

En tout cas je te remercie énormement tu m'as fait comprendre que les realloc ne sont pas toujours la solution à adopter

[Bousk]

Un segfault sur le return ?
Non je vois pas... Regarde du côté de l'appelant peut-être.