Salut

J'ais une nouvelle question concernant la memoire, et plus particulièrement les fonctions realloc et free.
Pour un projet en cours, je dois faire un tableau de structure dynamique, d'autant de case que de sprite a afficher. Le nombre de sprite est déterminé par le nombre de ligne dans un fichier texte externe, donc je réalloue autant de fois que nécessaire.
J'ais lu sur un site qu'il fallait d'abord réallouer sur un tableau temporaire, puis, si l'allocation n'a pas échoué, copier la variable temporaire sur le tableau initial.
Mais j'ais un probleme au moment de libérer le tableau temporaire. En fait quand je le libère, la premiere variable de la structure de la premiere case du tableau intial change de valeur.
Après test, j'ais vu que je pouvais encore accéder au tableau temporaire meme après l'avoir libéré, et qu'il se passait exactement la meme chose sur ce tableau temporaire.
Donc j'ais commencé a réfléchir, et j'en suis arrivé a la conclusion que les 2 tableaux étant des pointeurs, ils devaient pointer sur la meme zone de mémoire, donc en libérant le tableau temporaire, je libère aussi le tableau initial.
Je ne suis pas sur du tout de ma conclusion, c'est pourquoi je poste ici, et si ma conclusion est juste, j'aimerais savoir l'utilité de ce tableau temporaire qui fou un peu le bordel dans tout ca.

Donc quelqu'un pourrait-il m'éclairer?

Merci d'avance

/* ceci est un truc simple pour ajouter un élément dans un tableau dynamique */

// Hligne est un tableau dynamique

int * temp = malloc(sizeof(int)*nb_ligne); /* nb_ligne c'est le nombre de case dans le tableau que tu veux au total,le nombre de case dans le tableau après l'opération */

for (int i =0; i< nb_ligne-1;i++)
temp[i] = Hligne[i]; /* ici on met les précédentes lignes déjà alloué dans le tableau temporaire */
temp[nb_ligne-1] = image->h; /* remplace image->w par l'objet voulu */
free(Hligne); /* ici on détruit le tableau de base*/

Hligne = new int[nb_ligne];/* ici on le réalloue avec une case de plus que précédemment */
Hligne = temp;

En gros ça donne un truc dans le genre pour ajouter un élément dans un tableau dynamique^^ tu utilises ce truc le nombre de fois que t'as de lignes ( avec une boucle ^^(dont le i serait nb_ligne^^)), cette opération marche de la même manière peu importe le type utilisé, que ce soit un int*, ou une classe quelconque * ^^ .

Oui je pensais faire un truc dans le genre, ou alors ouvrir le fichier une premiere fois pour compter le nombre de ligne, ensuite créer le tableau une fois pour toute avec malloc, et ensuite réouvrir le fichier une deuxième fois pour remplir le tableau en fonction des info contenue dans les lignes.

Je ne sais pas trop quelle methode est la mieux au niveau temps de calcul donc si là aussi quelqu'un pouvait m'aider

Merci en tout cas

La méthode consistant a réallouer un nouveau tableau, puis si ça réussi à recopier l'ancien, demande d'utiliser malloc et non pas realloc.

realloc va vraiment réallouer le tableau. C'est-à-dire que s'il y a assez de place après, il ne le bouge pas et réserve juste la place qu'il faut, et s'il n'y a pas assez de place alors il en alloue un nouveau et recopie lui même les anciennes données.

Dans ce cas là, tu vérifie que realloc ne renvoie pas NULL pour savoir s'il a réussi (sinon, l'ancien tableau n'est pas touché), mais de toute manière, que peut tu faire d'autre dans ce cas là que de planter lamentablement (et en plus, ça ne se produira pas).

Par contre, c'est une très mauvaise méthode de procéder car tu passe ton temps (possiblement) à recopier ton tableau ce qui fait d'immense perte de temps.

Il est beaucoup plus efficace d'allouer d'abord la mémoire pour 10 lignes, par exemples, et si ça ne suffit pas pour 10 nouvelles lignes, puis pour 20 lignes, pour 40, etc. En doublant la taille de ton tableau à chaque fois, si tu ne peut pas connaitre dès le début la mémoire dont tu auras besoin.

Par contre, oublie directement le code de final-heart, c'est du n'importe quoi ("l'allocation" de Hligne à la fin particulièrement).

mon code c'est pas du n'importe quoi, c'est juste que je l'ai mal recopié xD j'ai recopier un truc en trop :p

j'avais un prog avec un truc du genre, mais j'ai recopié depuis la mauvaise version, voilà ce que je voulais dire^^

en attendant, c'est quand même n'importe quoi.

utiliser new et malloc en même temps... c'est pas top je pense. (meme si ca au final ca fait la meme chose ici).
De plus en C++ tu as le vector... qui est un tableau dynamique tout pret

Ensuite effectivement alloué a chaque insertion... si tu as 10000entrées ouch!
Comme le dit dnob700 tu part d'une certaine taille (genre 8, 10...), et tu multiplie par 2 chaque fois que dépasse et voila. (tu perds de la mémoire, certes, mais rien ne t'empèche de remètre ton tableau dans avec une jolie allocation à la bonne taille une fois que tu as finis de parser ton fichier).

désolé, mon code à la base ct du c++, j'ai essayé de le reconvertir mais j'ai oublié plein de trucs :p

ce n'est pas tant ça le problème que l'allocation à la fin qui est inutile. Il ne faut qu'une seule allocation au début de ton code et aucune à la fin.

Salut,
Si je résume ton problème, tu veux remplir ton tableau selon ce que tu trouve dans ton fichier. Y a pas à débattre pendant des heures il me semble, soit ton fichier est fixe et dans ce cas tu le lis une fois pour toute et tu remplis ton tableau. Si ce fichier est dynamique, là et seulement là tu as besoin d'un tableau dynamique. Si tu veux celui-ci réellement dynamique, c'est à dire louer de l'espace au fur et à mesure sans connaître la taille du tout a priori, pour moi la seule solution est la liste chaînée.
Un élément nouveau = un maillon ajouté à la chaîne.
Donc oublie le recopie incessante de tableau qui passé une certaine taille c pire que tout, et oublie aussi les tableau trop grand qui (même si c un moindre mal dans ce qu'on t'a dis) est quand même inutile et surtout ça entraîne des vérif, des recopies et tout ce qui va avec.
De toute façon c'est toujours pareil, on peut trouver 36 solutions pour un pbm, du bidouillage quoi, mais passé une certaine taille, tout cela devient obselète et on en voit les limites. Programmons intelligemment donc, c'est là clé ;)

sauf que là, proposer une liste chaînée est peut-être utile selon la manière dont les données sont utilisées, mais s'il a besoin d'un accès aléatoire à son tableau, ce qui aura été gagné à la création (peut-être, mais allouer les cases de la listes chaînées une à une n'est pas optimal non plus, une allocation coûte cher) sera perdu à l'utilisation.

dans un tableau dynamique tu perds au plus 2 fois la taille de tes données... donc c'est valable que si toutes tes données sont clairement définis. Pas utilisé des int pour stocker des petites valeurs, etc etc, je veux dire ca sert a rien d'optimiser la taille de ton tableau si tes données sont 4 fois trop grande.
Je me souviens de camarades de fac qui cherchaient toujours a utiliser la structure de données la plus efficace en espace mémoire, pour coder des booleen dans des int

Si la gestion mémoire est critique, alors oui faut pas s'y prendre avec un tableau dynamique, mais la je doute que ca soit le cas...

liste != tableau dynamique!! Et les listes chainée c'est moins simple a manipuler qu'un tableau.

de toute manière on peut (en C, pas en C++ malheureusement) "rendre" de la mémoire depuis un tableau. Donc on peut toujours à la fin re-dimensionner le tableau pour ne rien gâcher (il n'y a même pas besoin de recopier son contenu).