Discussion :

[theshark85]

Je lis dans un fichier, ligne par ligne. Pas de probleme pour ça.
Ensuite j'insere ces donne dans une structure.


STRUCT **test;
int nbtest;

pour cela j'alloue test= STRUCT** malloc (sizeof(STRUCT))

puis par la suite je vai realloue la memoire avec un realloc à nbtest+1 pour faire grandir mon tableau test, puis un malloc sur test[nbtest].

Mon probleme etant que tout ce passe bien jusqu'a la 70 000 eme ligne. Et que j'en ais encore beaucoup de ligne à lire.

Là il me met une erreur d'adresse mémoire, le probleme venant du malloc.

Je voudrais savoir, si quelqu'un sait pourquoi une erreur memoire se produit alors que le schema execute est toujour le meme. Une boucle.

Je ne peux pas mettre le code source pour des raisons professionnels car cela implique de mettre tout le code pour comprendre. Désolé.

[ep31]

Un dépassement de mémoire très certainement.
Mais comme tu déclares un pointeur de pointeur vers ta structure, pourquoi ne pas faire un malloc (sizeof(STRUCT*)) ?
Le pointeur prendra moins de place que ta structure.

[Emmanuel Delahaye]

Je lis dans un fichier, ligne par ligne. Pas de probleme pour ça.
Ensuite j'insere ces donne dans une structure.


STRUCT **test;
int nbtest;

pour cela j'alloue test= STRUCT** malloc (sizeof(STRUCT))

Ce code n'a aucun sens. Le type des éléments est STRUCT* et non STRUCT. de plus, tu n'en alloues qu'un... Je recommande l'écriture canonique

Code :

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

T * p = malloc (sizeof *p * n);

Ce qui se traduit ici par

Code :

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

 STRUCT **test = malloc (sizeof *test * nbtest);

Maintenant, on a un superbe trableau de nbtest pointeurs sur STRUCT non initialisés.

puis par la suite je vai realloue la memoire avec un realloc à nbtest+1 pour faire grandir mon tableau test, puis un malloc sur test[nbtest].

Ah ? Ben c'est mal parti avec un STRUCT ** ! Il fallait un STRUCT * :

Code :

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

 STRUCT *test = malloc (sizeof *test * nbtest);

Comme tu peux le voir, maintenance minimale ! (Suppression d'un '*').

Mon probleme etant que tout ce passe bien jusqu'a la 70 000 eme ligne. Et que j'en ais encore beaucoup de ligne à lire.

Ca se passe mal dès la première ligne... le comportement est indéfini.

Que fais -tu pour tester la validité de la reallocation ?

http://emmanuel-delahaye.developpez....es.htm#realloc

Et puis, je te conseille de réduire le nombre de realloc() en jouant sur une croissance exponentielle (par doublage). C'est beaucoup plus performant.

[theshark85]

En relisant je me suis aperçut que j'avais oublié une étoile.
Et j'alloue bien ainsi : test= STRUCT** malloc (sizeof(STRUCT*))

Sinon pour le realloc, pourquoi en exponentielle, le doublage a partir d'un moment sera trop important genre quand j'arriverais à la 60 000 000 ligne de fichier je vais pas reallouer 120 000 000!!!!

Et si j'ai un STRUCT **test, c'est obligatoire pour mes traitements.

Pour tester ma reallocation, lecture des adresses.

[NicolasG]

Sinon pour le realloc, pourquoi en exponentielle, le doublage a partir d'un moment sera trop important genre quand j'arriverais à la 60 000 000 ligne de fichier je vais pas reallouer 120 000 000!!!!

C'est une technique standard.
Il y a des variantes, on peut agrandir la capacité de 10% plutôt que la doubler.

En tout cas, réallouer 1 item de plus à chaque fois, c'est ce qu'on peut faire de pire pour les performances.

[deck_bsd]

si tu veut faire un double pointeur pour un tableau de structure a 2 dimension,

alloue comme ceci :

test= (STRUCT**) malloc (sizeof(STRUCT*)*n);

n étant le nombre d'élément dans ton tableau. La tu aura un tableau de n pointeur ver des structure mais qui pointe sur rien du tout, tu doit allouer ensuite pour chaque élément dans un boucle de 0 a n-1 fois :

test[i] = (STRUCT*)malloc(sizeof(STRUCT));

Si c'est un tableau simple que tu veut faire :
test = (STRUCT*)malloc(sizeof(STRUCT)*n); suffit

voila.


++

[Skyounet]

si tu veut faire un double pointeur pour un tableau de structure a 2 dimension,

alloue comme ceci :

test= (STRUCT**) malloc (sizeof(STRUCT*)*n);

n étant le nombre d'élément dans ton tableau. La tu aura un tableau de n pointeur ver des structure mais qui pointe sur rien du tout, tu doit allouer ensuite pour chaque élément dans un boucle de 0 a n-1 fois :

test[i] = (STRUCT*)malloc(sizeof(STRUCT));

Si c'est un tableau simple que tu veut faire :
test = (STRUCT*)malloc(sizeof(STRUCT)*n); suffit

voila.


++

Le cast est inutile en C

Code :

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

1
2
 
char *test = malloc(50);

Il peut d'ailleurs cacher l'oubli d'inclusion de stdlib.h

[Emmanuel Delahaye]

Code :

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

1
2
3
test= (STRUCT**) malloc (sizeof(STRUCT*)*n);
 
test[i] = (STRUCT*)malloc(sizeof(STRUCT));

Une façon compliquée d'écrire

Code :

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

1
2
3
4
5
6
 
#include <stdlib.h>
 
   STRUCT **test= malloc (sizeof *test * n);
 
   test[i] = malloc (sizeof *test[i]);

Ne pas oublier de tester si l'allocation a réussi et de libérer quand on n'utilise plus.