Erreur de segmentation (core dumped)

**ben_tiba_asma** · 03/11/2011, 09h31

bonjour à tous;
tout est dans le titre, il s'agit d'un message d'erreur que j'arrive pas à contourner

donc je vous explique, il s'agit d'un code qui va générer des fichiers avec des nombres aléatoires , 4 variables sont passées en paramètre via argc[ ] et argv[ ], la 1ère est la taille d'un tableau utilisé dans le code, la 2ème servira dans le calcul des bornes des nombres aléatoires générés , les deux dernières portent le nom de deux fichiers parmi les fichiers qui seront générés .mon code fonctionnait bien au début, mais j'avais pas testé avec des grands nombres. maintenant, en faisant appel dans un script (une boucle for) je reçois ce message indiqué ci-haut !!!! j'ai réessayé alors avec le code séparé avec une des valeurs devant être passées dans la boucle (une 1ère instance par exemple que j'ai calculée à la main) et je reçois le même problème. j'ai alors pensé que je devais peut être penser à une allocation dynamique de la mémoire pour les tailles des tableaux ou alors c'est autre chose

voilà le code en totalité, mais la partie chargée de la génération des nombres est la 1ère partie, le reste a l'air de bien fonctionner

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
#include <stdio.h>
 
#include <stdlib.h>
 
#include <time.h>
 
//************************************** Générateur de machines
 
 
 
int main(int argc, char*argv[])
 
{
 
int nb_ligne;
 
int  nb=atoi(argv[1]);
 
int  max=100000;
 
int  copt=atoi(argv[2]);
 
int deb[nb],fin[nb];
 
int init[nb][max] ;
 
int somme[max];
 
int i,j,prov,test;
 
FILE* f_m = NULL , *fd=NULL, *fm=NULL;
 
 
 
f_m = fopen("machine1.txt", "w");
 
test=0;
 
 
 
do{
 
for (i=0;i<nb;i++)
 
{for (j=0;j<max;j++)
 
{init[i][j]=1;
 
/*fprintf(f_m,"%d  ",init[i][j]);}
 
fprintf(f_m,"\n");*/}}
 
 
 
 
 
 
 
for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
 
{
 
 
 
	srand ( time(NULL) );		  
  	deb[nb_ligne]=(int)(rand() % ((copt/2)+1) +( copt/2)) + 1;
 
 
 
}
 
 
 
		  for (i=0;i<nb_ligne;i++)
 
		  {for (j=i+1;j<nb_ligne;j++)
 
		  {if (deb[j]>deb[i])
 
		  {prov=deb[i];
 
		  deb[i]=deb[j];
 
		  deb[j]=prov;}
 
		  }
 
		  }
 
 
 
        for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
 
{
 
 
 
		 srand ( time(NULL) );
 
		fin[nb_ligne]=(int)(rand() % ((copt/2)+1) + copt)+1;
 
 
 
 
 
}
 
 
 
for (i=0;i<nb;i++)
 
{for (j=deb[i];j<fin[i];j++)
 
{init[i][j]=0;}
 
}
 
 
 
for (i=0;i<max;i++)
 
{somme[i]=0;
 
for (j=0;j<nb;j++)
 
{somme [i]=somme[i]+init[j][i];}
 
 
 
if (somme[i]==0)
 
{test=0;
 
break;}
 
else
 
test=1;
 
 
 
}  }
 
while (test==0);
 
/****************affichage de machine1.txt*******************/
 
	for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
 
	fprintf(f_m,"\n%d %d\n",0,deb[nb_ligne]);
 
	for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
 
	fprintf(f_m,"\n%d  %d\n",fin[nb_ligne],max);
 
/****************affichage de machine*******************/
 
fm = fopen(argv[3], "w");
 
for (i=0; i<nb; i=i+1)
 
{
 
fprintf(fm,"%d\t0\t%d\n%d\t%d\t%d\n%d\t100002\t100003\n",i+1,deb[i],i+1,fin[i]+1,max,i+1);
 
}
 
 
 
/********************affichage de perf********************/
 
 
 
fd = fopen(argv[4], "w");
 
for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
 
{
 
    fprintf(fd, "%d\t  1",nb_ligne+1);
 
    fprintf(fd, "\n");
 
}
 
 
 
return(0);
 
}//fin main

j'attendrais vos réponses impatiemment s'il vous plaît

**6-MarViN** · 03/11/2011, 09h46

Bon déja pour commencer, tu fais EXPLOSER ta stack :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int nb_ligne;
 
int  nb=atoi(argv[1]);
 
int  max=100000;
 
int  copt=atoi(argv[2]);
 
int deb[nb],fin[nb];
 
int init[nb][max] ;
 
int somme[max]

Si tu rentre des grands nombre dans agrv[1], imagine la taille de tes tableaux. Ils sont énormes. Pourquoi as-tu besoin de tant de stockage?

Si j'ai bien compris, tu veux crée un fichier rempli de nombre aléatoire? A priori tu n'as pas besoin de les stocker tu peut directement les écrire dans un fichier.

**Bousk** · 03/11/2011, 09h52

Code :

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

1
2
3
4
5
int deb[nb],fin[nb];
 
int init[nb][max] ;
 
int somme[max];

C'est illégal comme déclaration ça
Voir des cours sur les tableaux dynamiques et l'allocation mémoire

**ben_tiba_asma** · 03/11/2011, 10h04

bonjour
en fait il s'agit d'un problème d'ordonnancement (si tu vois ce que c'est) , ce code (parmi d'autres) sera appelé ultérieurement dans un script (une boucle for) , et la valeur de nb sera passée en paramètre parce qu'elle dépend des valeurs générées par les codes précédents , nb c'est le nombre de machines, le fichier machine aura cette allure

Code :

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

fprintf(fm,"%d\t0\t%d\n%d\t%d\t%d\n%d\t100002\t100003\n",i+1,deb[i],i+1,fin[i]+1,max,i+1);

par exple la premiere machine et ses disponibilités
1 0 45
1 60 100000
1 100002 100003

**ben_tiba_asma** · 03/11/2011, 10h06

en plus j'aurais besoin de les stocker pas de les ecrires directement parce que je dois faire un test apres sur ces nombres il doivent répondre à certaines contraintes
oui je me suis doutée du fait d'utiliser quelque chose comme malloc mais j'ai une contrainte de temps qui me bloque

j'aurais pas le temps de revoir comment faire c'est pour ça d'ailleurs que j'ai posté le problème sur le forum
merci d'avance

**jeroman** · 03/11/2011, 11h08

Ton code est illisible. L'indentation laisse à désirer. En outre, pourquoi sauter X lignes entre chaque ligne de code ?

**ben_tiba_asma** · 03/11/2011, 11h17

le revoilà en plus clair

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char*argv[])
{
int nb_ligne;
int  nb=atoi(argv[1]);
int  max=100000;
int  copt=atoi(argv[2]);
int deb[nb],fin[nb];
int init[nb][max] ;
int somme[max];
int i,j,prov,test;
FILE* f_m = NULL , *fd=NULL, *fm=NULL;
f_m = fopen("machine1.txt", "w");
test=0;
do{
for (i=0;i<nb;i++)
{for (j=0;j<max;j++)
{init[i][j]=1;}}
 for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
 {srand ( time(NULL) );		  
  deb[nb_ligne]=(int)(rand() % ((copt/2)+1) +( copt/2)) + 1;
 }
 	  for (i=0;i<nb_ligne;i++)
 	  {for (j=i+1;j<nb_ligne;j++)
 		  {if (deb[j]>deb[i])
 		  {prov=deb[i];
 		  deb[i]=deb[j];
 		  deb[j]=prov;}
 		  }
 		  }
         for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
 {	 srand ( time(NULL) );
	fin[nb_ligne]=(int)(rand() % ((copt/2)+1) + copt)+1;
}
for (i=0;i<nb;i++) 
{for (j=deb[i];j<fin[i];j++)
 {init[i][j]=0;}
 }
for (i=0;i<max;i++)
 {somme[i]=0;
for (j=0;j<nb;j++) 
{somme [i]=somme[i]+init[j][i];}
 if (somme[i]==0)
{test=0;
break;}
else
test=1;
}  }
while (test==0);
 
/****************affichage de machine1.txt*******************/
 
	for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
	fprintf(f_m,"\n%d %d\n",0,deb[nb_ligne]);
	for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
	fprintf(f_m,"\n%d  %d\n",fin[nb_ligne],max);
/****************affichage de machine*******************/
fm = fopen(argv[3], "w");
for (i=0; i<nb; i=i+1)
{fprintf(fm,"%d\t0\t%d\n%d\t%d\t%d\n%d\t100002\t100003\n",i+1,deb[i],i+1,fin[i]+1,max,i+1);
 }
 /********************affichage de perf********************/
 fd = fopen(argv[4], "w");
 for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
 {    fprintf(fd, "%d\t  1",nb_ligne+1);
     fprintf(fd, "\n");
 }
 return(0);
 }//fin main

**6-MarViN** · 03/11/2011, 11h50

En fait c'est encore pire.

Bon petit nettaoyage parce que je suis gentil :

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
int main(int argc, char*argv[])
{
  int nb_ligne;
  int  nb = atoi(argv[1]);
  int  max = 100000;
  int  copt = atoi(argv[2]);
  int deb[nb], fin[nb];
  int init[nb][max] ;
  int somme[max];
  int i, j, prov,test;
  FILE* f_m = NULL , *fd = NULL, *fm = NULL;
 
  f_m = fopen("machine1.txt", "w");
  test=0;
  do
    {
      for (i=0;i<nb;i++)
        {
          for (j=0;j<max;j++)
            {
              init[i][j]=1;
            }
        }
      for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
        {
          srand ( time(NULL) );
          deb[nb_ligne]=(int)(rand() % ((copt / 2) + 1) + (copt / 2)) + 1;
        }
      for (i = 0; i < nb_ligne;i++)
        {
          for (j = i + 1; j < nb_ligne; j++)
            {
              if (deb[j] > deb[i])
                {
                  prov = deb[i];
                  deb[i] = deb[j];
                  deb[j] = prov;
                }
            }
        }
      for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
        {
          srand ( time(NULL) );
          fin[nb_ligne]=(int)(rand() % ((copt / 2) + 1) + copt) + 1;
        }
      for (i = 0; i < nb; i++)
        { 
          for (j = deb[i]; j < fin[i]; j++)
            {
              init[i][j] = 0;
            }
        }
      for (i = 0; i < max; i++)
        {
          somme[i] = 0;
          for (j = 0; j < nb; j++)
            {
              somme [i] = somme[i] + init[j][i];
            }
          if (somme[i] == 0)
            {
              test = 0;
              break;
            }
          else
            test = 1;
        }
    } while (test == 0);
 
  /****************affichage de machine1.txt*******************/
 
  for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
    fprintf(f_m,"\n%d %d\n",0,deb[nb_ligne]);
  for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
    fprintf(f_m,"\n%d  %d\n",fin[nb_ligne],max);
  /****************affichage de machine*******************/
  fm = fopen(argv[3], "w");
  for (i=0; i<nb; i=i+1)
    {
      fprintf(fm,"%d\t0\t%d\n%d\t%d\t%d\n%d\t100002\t100003\n",i + 1, deb[i], i + 1,fin[i] + 1, max, i + 1);
    }
  /********************affichage de perf********************/
  fd = fopen(argv[4], "w");
  for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne)
    {
      fprintf(fd, "%d\t  1",nb_ligne+1);
      fprintf(fd, "\n");
    }
  return(0);
}//fin main

**ben_tiba_asma** · 03/11/2011, 11h57

merci c'est très gentil de ta part :-)
et pour les rectifications je fais quoi

**6-MarViN** · 03/11/2011, 12h04

Comme il a été dit précédemment, penche toi du coté de l'allocation dynamique. Parce que test déclarations de tableaux statiques sont illégales.

**ben_tiba_asma** · 03/11/2011, 12h05

oui justement je sais qu'il faut faire un petit ménage de ce coté mais je ne sais pas comment m'y prendre c'est ça le problème

**Bousk** · 03/11/2011, 12h10

Il y a ce cours qui indique tout ça

**ben_tiba_asma** · 03/11/2011, 12h38

merci ;-)

**ben_tiba_asma** · 03/11/2011, 15h25

malheureusement mon problème n'est pas résolu même après rectification , voilà le nouveau code

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
//************************************** Générateur de machines 
int main(int argc, char*argv[]) 
{ 
	int nb_ligne; //nombre des lignes du fichier machine
	int  const nb=atoi(argv[1]); //nombre de machines qui sera passé en paramètre 
	long int  max=100000;//la borne max de l'intervalle d’exécution
	int  const copt=atoi(argv[2]); //variable passé en paramètre pour le calcul des indisponibilités
	int deb[nb];
        int fin[nb]; //tableau des fin et début d'indisponibilité de chaque machine  
	int i,j,prov,test;
	long int**init;
	long int**somme;
	init=(long int**)malloc(nb*sizeof(long int*));
 
           if (init==NULL)
		printf("Echec d'allocation memoire!!!!!!!!");
       	for (i=0;i<nb;i++)
		{
                    init[i]=(long int*)malloc(max*sizeof(long int));
		    if (init[i]==NULL)
			{
			for(j=0;j<i;j++)
			   {
			     printf("Echec d'allocation memoire!!!!!!!!");
			    }
			 }
		  }
	somme=(long int**)malloc(max*sizeof(long int*));
// tester si le système a alloué de la mémoire
	if (somme==NULL)
            {
		printf ("allocation gaché \n");
             }
 
        FILE* f_m = NULL , *fd=NULL, *fm=NULL; 
	f_m = fopen("machine1.txt", "w"); 
	test=0; 
 
	do
            { 
		for (i=0;i<nb;i++) //boucle pour initialiser la matrice init à 1
			{
                            for (j=0;j<max;j++) 
				{
                                  init[i][j]=1; 
				  } 
                         } 
		for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
		    { 
		          srand ( time(NULL) );          
		          deb[nb_ligne]=(int)(rand() % ((copt/2)+1) +( copt/2)) + 1;  //générer un nombre aléatoire compris entre copt/2 et copt, j'ai forcé ce nombre à int pour l'arrondir 
 		     } 
                 for (i=0;i<nb_ligne;i++) //tri des début indisponibilité 
       		       {
                            for (j=i+1;j<nb_ligne;j++) 
          		         { 
                                       if (deb[j]>deb[i]) 
          			            {
                                              prov=deb[i]; 
          			              deb[i]=deb[j]; 
          			              deb[j]=prov;
                                             } 
         		          } 
        	         } 
                 for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
	          	{ 
                              srand ( time(NULL) ); 
        	              fin[nb_ligne]=(int)(rand() % ((copt/2)+1) + copt)+1; //génération des fin d'indisponibilité pour chaque machine
		        } 
 	         for (i=0;i<nb;i++) //boucle pour vérifier qu'à chaque instant il y a au moins une machine disponible, pour le faire la somme des colonnes doit être différente de 0
		         {
                           for (j=deb[i];j<fin[i];j++) 
		              {
                                  init[i][j]=0;
                              }
              		} 
	        for (i=0;i<max;i++) 
	            {
                          somme[i]=0; 
	                  for (j=0;j<nb;j++)
                        	{ 
                                  somme [i]=somme[i]+init[j][i];
                                }
                       	if (somme[i]==0) 
		             {
                                 test=0; 
	                        	break;
                             } 
	                else 
                        	test=1; 
              	  }
   } while (test==0); 
 
/****************affichage de machine1.txt*******************/ 
 	   for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 		   fprintf(f_m,"\n%d %d\n",0,deb[nb_ligne]); 
 
 	   for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
 		   fprintf(f_m,"\n%d  %ld\n",fin[nb_ligne],max); 
 
/****************affichage de machine*******************/ 
	fm = fopen(argv[3], "w"); 
		for (i=0; i<nb; i=i+1) 
		{ 
			fprintf(fm,"%d\t0\t%d\n%d\t%d\t%ld\n%d\t100002\t100003\n",i+1,deb[i],i+1,fin[i]+1,max,i+1); 
		} 
 /********************affichage de perf********************/ 
	fd = fopen(argv[4], "w"); 
		for (nb_ligne = 0; nb_ligne < nb; ++nb_ligne) 
		{ 
    			fprintf(fd, "%d\t  1",nb_ligne+1); 
			fprintf(fd, "\n"); 
		}
free(init);
free(somme);
 			return(0); 
}//fin main()

l'appel au code par

Code :

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

./generateur_machine 26 1461 machine  perf

entre en boucle infinie et ne répond plus

je ne sais pas comment faire

quelqu'un aurait une idée svp

**Bousk** · 03/11/2011, 15h46

Je suis désolé mais ton code est si mal indenté que je n'ôse pas le lire et ne parvient pas à le suivre.
Un minimum d'effort d'écriture pourrait aider à vouloir regarder le problème et aider.

La seule chose encore mauvaise au début est

Code :

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

int deb[nb],fin[nb];

qui n'est pas plus légal qu'auparavant.

Le reste m'a un peu donné le tourni, j'ai arrêté à la première accolade

**ben_tiba_asma** · 03/11/2011, 15h54

d'accord je vais mettre des commentaires sur mon code , entre temps pourrais-tu stp me dire comment la corriger cette déclaration
voilà c'est bien commenté

**Pouet_forever** · 04/11/2011, 18h19

Envoyé par Bousk

La seule chose encore mauvaise au début est

Code :

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

int deb[nb],fin[nb];

qui n'est pas plus légal qu'auparavant.

Je ne vois pas en quoi c'est mauvais, c'est parfaitement légal en C99. La seule chose qu'on pourrait lui reprocher est de ne pas tester les valeurs de nb et aussi les paramètres de argc/v. Le retour des fonctions, l'appel de srand dans les boucles, une indentation hideuse, un code obscur, des allocations de mémoire non libérées, des fonctions manquantes, des rand erronés et puis tout ce que j'ai pu oublier.

**Bousk** · 04/11/2011, 23h46

Voilà ce que me dit le compilateur de VS2010 avec ce code, à propos de ces tableaux

1>d:\projets\c++\sandbox\main.cpp(11): error C2057: expected constant expression
1>d:\projets\c++\sandbox\main.cpp(11): error C2466: cannot allocate an array of constant size 0
1>d:\projets\c++\sandbox\main.cpp(11): error C2133: 'deb' : unknown size
1>d:\projets\c++\sandbox\main.cpp(12): error C2057: expected constant expression
1>d:\projets\c++\sandbox\main.cpp(12): error C2466: cannot allocate an array of constant size 0
1>d:\projets\c++\sandbox\main.cpp(12): error C2133: 'fin' : unknown size

nb est une variable (malgré son attribut const - regarde son assignation de valeur), il semble donc qu'on veuille créer des tableaux de nb cases
nb est inconnu à la compilation, il s'agit donc de tableaux dynamiques
la déclaration de tableau dynamique en C passe par un pointeur et nécessite un malloc
donc cette déclaration est mauvaise

on pourrait utiliser nb si sa valeur était connue à la compilation

**Pouet_forever** · 05/11/2011, 01h38

Envoyé par Pouet_forever

c'est parfaitement légal en C99.

A ma connaissance, le compilateur de visual ne supporte pas le C99, je t'invite à en utiliser un qui supporte cette norme, de plus tu compiles en C++ un code C.

nb est une variable : oui
nb est inconnu à la compilation : oui
il s'agit donc de tableaux dynamiques : non, c'est une déclaration sur la pile, ce qui peut poser des soucis si la valeur est grande (stack overflow)
la déclaration de tableau dynamique en C passe par un pointeur et nécessite un malloc : oui, cependant il n'en est pas question ici, cf réponse du dessus
donc cette déclaration est mauvaise : je me répète, cette déclaration est parfaitement correcte

On appelle d'ailleurs cette forme le VLA (Variable-Length Arrays) qui permet justement de déclarer un tableau avec une taille connue à l'exécution et non à la compilation. Je t'invite à te renseigner sur ce point.

**Bousk** · 05/11/2011, 12h49

Au temps pour moi, merci pour ces précisions, je regarderai cette particularité.
Quant au fait que je compilais en cpp, je n'y avais pas prêté attention

.

Edit:
Marrant, j'en avais absolument jamais entendu parler, pourtant ça a l'air sympa.
Bien que j'avoue que pas familier, j'aurais du mal à intégrer cette notation dans mes scripts, lui préférant (peut-être à tord) le malloc.
Puis tu précises qu'il faut un tableau limité en taille, dans ce cas où le tableau contient 26 entrées, ça devrait passer, mais si l'on veut ensuite utiliser 2500 entrées, que se passerait-il ? Réécriture du code en malloc pour s'assurer du fonctionnement ?

Erreur de segmentation (core dumped)

C

Discussions similaires

Partager

Partager