Problème de realloc de pointeur passé en paramètre de fonction

Version imprimable

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:

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 :

Citation:

*** 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 :)

19/03/2009, 19h12
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:

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); ... }
19/03/2009, 19h29
cedric83400
Citation:
Envoyé par 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:

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*));
19/03/2009, 20h28
crocodilex

Peux-tu isoler le bout de code qui pose problème et nous le montrer ?
19/03/2009, 20h56
matafan

Citation:

Envoyé par cedric83400

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 **.
19/03/2009, 21h07
cedric83400

Citation:

Envoyé par crocodilex

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 :)

Citation:

Envoyé par matafan

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!

Citation:

Envoyé par matafan

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:

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)); }

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

Code:

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;
}

Citation:
Envoyé par diogene
Personnellement sur ce (pratiquement ton) code, je n'ai pas de problèmes
Code:

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:

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.

Citation:

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

Non par (*X)[i]

Code:

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;
}

Code:

*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:

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;
}

Citation:
Envoyé par Médinoc
Code:

*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:

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 +

20/03/2009, 19h56
diogene

Citation:

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]
21/03/2009, 21h49
cedric83400

Citation:

Envoyé par diogene

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... :-)

@+