Discussion :

[cedric83400]

Bonjour à tous,

Je fais face à une erreur lorsque je tente de reallouer l'espace mémoire d'un pointeur passé en paramètre d'une fonction.

Voici mon pseudo code qui modifie juste la taille de ma variable X:

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
int main (void)
{
     double *X;
     X	= (double*)calloc(10,sizeof(double));
 
//   pour i=0 jusqu'à 10 X[i] = i ;
 
     fonction(X);
}
 
fonction( double *X)
{
     int newDim = 15;
     X = realloc(X, newDim*sizeof(double));
}

A la compilation je n'ai pas de problème, mais lorsque je lance le programme j'ai cette erreur :

*** glibc detected *** ./myProg: realloc(): invalid next size: 0x000000000462a670 ***
======= Backtrace: =========
/lib64/libc.so.6[0x3dfcc7421b]
/lib64/libc.so.6(realloc+0x1d0)[0x3dfcc751a0]

[...]

Merci pour votre aide

[matafan]

Si tu veux modifier un pointeur passé en paramètre à une fonction, il faut passer l'adresse du pointeur, pas directement le pointeur. Bref ça doit ressembler à ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void
fonction(double **x)
{
    *x = realloc(*x, 15 * sizeof(double));
}
 
int
main()
{
    ...
    fonction(&x);
    ...
}

[cedric83400]

Si tu veux modifier un pointeur passé en paramètre à une fonction, il faut passer l'adresse du pointeur, pas directement le pointeur. Bref ça doit ressembler à ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void
fonction(double **x)
{
    *x = realloc(*x, 15 * sizeof(double));
}
 
int
main()
{
    ...
    fonction(&x);
    ...
}

Merci pour ton aide, j'ai essayé comme tu m'as dit mais j'ai toujours le même bug.

J'ai déclaré mon X en double ** dans la fonction main et j'ai initialisé comme ça :

X = (double**)calloc(10,sizeof(double*));

[crocodilex]

Peux-tu isoler le bout de code qui pose problème et nous le montrer ?

[matafan]

Merci pour ton aide, j'ai essayé comme tu m'as dit mais j'ai toujours le même bug.

J'ai déclaré mon X en double ** dans la fonction main et j'ai initialisé comme ça :

X = (double**)calloc(10,sizeof(double*));

Il faut que X reste un double * dans main. Par contre tu passes &x en argument à function(), donc dans function() c'est un double **.

[cedric83400]

Peux-tu isoler le bout de code qui pose problème et nous le montrer ?

Alors là maintenant je ne l'ai pas sur moi mais je le récupererai demain. (mais mon code est vraiment identique à mon pseudo-code)

C'est la ligne avec le realloc qui fait planter tout...

Merci pour ton intérêt

Il faut que X reste un double * dans main. Par contre tu passes &x en argument à function(), donc dans function() c'est un double **.

Ok très bien j'essaie ça demain et je te tiens au courant Merci pour vos aides très rapides!

[cedric83400]

Il faut que X reste un double * dans main. Par contre tu passes &x en argument à function(), donc dans function() c'est un double **.

J'ai essayé ce que tu m'as dit mais j'ai toujours le même problème, je te montre mon 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
 
void addFirstFeatures([...], double **X, [..]);
 
void main(void)
{
 
double *X;
X	= (double*)calloc(13,sizeof(double));
 
addFirstFeatures([...], &X, [..]);
}
 
void addFirstFeatures([...], double **X, [...]) 
{
int count = 3;
*X = realloc(*X, (13+6*count)*sizeof(double));
}

[diogene]

Personnellement sur ce (pratiquement ton) code, je n'ai pas de problèmes

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void addFirstFeatures( double **X)
{
  int count = 3;
  *X = realloc(*X, (13+6*count)*sizeof(double));
}
int main(void)
{
  int i;
  double *X;
  X = calloc(13,sizeof(double));
  addFirstFeatures(&X);
  for(i=0; i<13+3*6;i++) X[i] = i;
  return 0;
}

[cedric83400]

Personnellement sur ce (pratiquement ton) code, je n'ai pas de problèmes

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void addFirstFeatures( double **X)
{
  int count = 3;
  *X = realloc(*X, (13+6*count)*sizeof(double));
}
int main(void)
{
  int i;
  double *X;
  X = calloc(13,sizeof(double));
  addFirstFeatures(&X);
  for(i=0; i<13+3*6;i++) X[i] = i;
  return 0;
}

Je te remercie pour ta réponse. J'ai testé ton code dans un source à part et effectivement il fonctionne sans problème avec gcc.

J'ai ensuite intégré ta fonction dans mon programme et là, même erreur... J'ai donc enlevé toutes les autres fonctions et déclarations (elles ont toutes aucun rapport avec X) , et là ça fonctionne... Je continue mes recherches, je te tiens au courant, merci


----


Ok j'ai trouvé l'erreur... c'était pendant l'initialisation de mon vecteur X, j'avais initialisé un élément en trop... (soit 14...-_-' )

Un GRAND MERCI pour vos aides


Autre petite question,

Est ce que qu'il est possible de faire :

Code :

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

1
2
 
for(i=0; i<13+3*6;i++) X[i] = i;

dans la fonction addFirstFeatures juste après le realloc ? J'ai essayé de remplacer X[i] par *X[i] mais ça ne fonctionne pas. Cela fonctionne uniquement pour mes 13 premiers éléments, après j'ai une erreur de segmentation.

[diogene]

J'ai essayé de remplacer X[i] par *X[i]

Non par (*X)[i]

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
void addFirstFeatures( double **X)
{
  int i;
  int count = 3;
  *X = realloc(*X, (13+6*count)*sizeof(double));
   for(i=0; i<13+6*count;i++) (*X)[i] = i;
}
int main(void)
{
  int i;
  double *X;
  X = calloc(13,sizeof(double));
  addFirstFeatures(&X);
  for(i=0; i<13+3*6;i++) printf("%f\n",X[i]);
  return 0;
}

[Médinoc]

Code :

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

  *X = realloc(*X, (13+6*count)*sizeof(double));

Mauvais usage de realloc() : Le pointeur est perdu en cas d'échec de la réallocation.

Code C :

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
int realloc_double(double **pp, size_t cElems)
{
	size_t cb = cElems * sizeof **pp;
	double * tmp = realloc(*pp, cb);
	if(tmp == NULL)
		return -1;
 
	*pp = tmp;
	return 0;
}
 
void addFirstFeatures( double **X)
{
	int i;
	int count = 3;
	if(realloc_double(X, 13+6*count) < 0)
		return;
 
	for(i=0 ; i<13+6*count ; i++)
		(*X)[i] = i;
}

[cedric83400]

Code :

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

  *X = realloc(*X, (13+6*count)*sizeof(double));

Mauvais usage de realloc() : Le pointeur est perdu en cas d'échec de la réallocation.

Code C :

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
int realloc_double(double **pp, size_t cElems)
{
	size_t cb = cElems * sizeof **pp;
	double * tmp = realloc(*pp, cb);
	if(tmp == NULL)
		return -1;
 
	*pp = tmp;
	return 0;
}
 
void addFirstFeatures( double **X)
{
	int i;
	int count = 3;
	if(realloc_double(X, 13+6*count) < 0)
		return;
 
	for(i=0 ; i<13+6*count ; i++)
		(*X)[i] = i;
}

La realloc s'est bien passé mais en fait c'est mon pointeur qui était mal écrit... au lieu d'écrire *(X)[j] , j'avais écrit *X[j]... voilà je vous remercie tous encore. A +

[diogene]

La realloc s'est bien passé mais en fait c'est mon pointeur qui était mal écrit... au lieu d'écrire *(X)[j] , j'avais écrit *X[j]...

Il n'empèche que Médinoc a parfaitement raison : le realloc DOIT être employé de la manière qu'il explique. De la même façon que malloc (ou calloc) doit être suivi d'un test sur la valeur obtenue, realloc, bien utilisé, doit tester la valeur de retour pour savoir si la réallocation s'est bien passée et, si ce n'est pas le cas, garder l'ancien pointeur pour accéder (ne serait-ce que pour libérer la mémoire) à ce qui avait été alloué précédemment.

Ce n'est pas *(X)[j] mais (*X)[j]

[cedric83400]

Il n'empèche que Médinoc a parfaitement raison : le realloc DOIT être employé de la manière qu'il explique. De la même façon que malloc (ou calloc) doit être suivi d'un test sur la valeur obtenue, realloc, bien utilisé, doit tester la valeur de retour pour savoir si la réallocation s'est bien passée et, si ce n'est pas le cas, garder l'ancien pointeur pour accéder (ne serait-ce que pour libérer la mémoire) à ce qui avait été alloué précédemment.

Ce n'est pas *(X)[j] mais (*X)[j]

Oui oui j'ai bien inclu le test dans mon code final ;-) Merci pour vos conseils et bien entendu *(X) était une faute de frappe... :-)

@+