Bonjour à tous,
 
Je galère sur un problème de gestion de mémoire et je n'arrive pas à trouver la solution.
 
J'ai une classe Array_1D, qui remplit grosso modo le rôle de la classe standard Vector.
Dans cette classe qui est un template, j'ai donc un pointeur vers le bloc mémoire contenant l'ensemble des données :
 

 
Pour rajouter des éléments dans cette classe de stockage, j'ai une fonction extend_array, prenant en paramètre le nombre d'élément à ajouter :

 
Le problème vient du delete[].  Il fait planter mon appli. Si je le mets en commentaire ça fonctionne, mais bien évidemment j'ai de grosses fuites mémoire.
Je ne comprends pas d'où vient le problème, auriez-vous une idée ?
 
Je vous remercie par avance !!

1/ Pourquoi ne pas utiliser vector?
2/ Les constructeurs de copie qui ne sont pas executes, ca peut expliquer beaucoup
3/ Un probleme de crash avec un delete, c'est souvent une corruption et celle-ci peut avoir sa cause a peut pres n'importe quand avant.

Il est vrai que j'aurai pu utiliser vector, mais pour plusieurs raisons j'ai préféré codé ma propre classe.
 
Pourrais-tu expliciter la notion de constructeur de copy dans le cas qui m'intéresse ? Tu parles de l'instruction memcpy ?

Si je remplace memcpy par une boucle qui copie les éléments 1 par 1, ça fonctionne :
 

 
Je ne comprends pas pourquoi cela fonctionne mieux, d'autant plus que l'utiliser de memcpy permet d'optimiser  les performances, et c'est ce que je recherche...

*memcpy copie des tas d octets
*buffer[i] = array[i] appelle le constructeur type( const type& ) ...  du coup c est ce que tu dois faire. Si tu veux de meilleures perfs ensuite tu peux envisager de specialiser ton template pour certains types ou le memcpy ne pose pas probleme
*utilise vector

Par plusieurs tu veux parler du fait que ta classe sera bugguée, moins performante, moins générique et moins interoperabel que std::vector ? ou bien du fait que tu n'as que ça à faire de ton temps de reinventer l'eau froide ? ou bien ta boite est un de ces dinosaures qui crois la STL est mal faite ?

 
std::copy fait deja cette optimisation

 
parce-que je programme pour mon loisir, que j'aime programmer même des trucs qui ont déjà été fait, et que j'aime bien me casser les dents sur un problème, car une fois résolu j'ai appris des choses :-).

sauf que la c'est contre-productif mais c'est pas grave ...

 
Pourquoi être toujours négatif ? Ma question ne portait pas sur la pertinence de ma classe, mais sur un point technique précis d'une méthode. Je ne cherche pas à être productif dans mes loisirs, je cherche à me faire plaisir, c'est le but de tout loisir.

Le probleme que je vois -- encore plus que de perdre ton temps a reinventer la roue -- c'est que tu sautes les etapes.  Ecrire des templates mais ne pas comprendre directement quel est le fond du probleme quand on t'indique que tu n'utilises pas les constructeurs de copie, indique pour moi que tu ne maitrises pas encore les bases.  Ecrire des templates -- reinventant la roue ou non -- est premature.

Toujours est-il que je ne comprends pas pourquoi le memcpy pose problème, puisqu'à partir du moment où mon array est alloué avec un new[], la mémoire est forcément contigue, et de ce fait le delete[] ferait son office correctement...

non. Si tu fais un tableau d'objet, ca copie doit copier les objets en appelant leur constructeur de copie qui peuvent avoir des effets de bords. Si tu copie des objets bits à bits, tu t'expose à de sacrée deconvenue.
 
Exemple, fait un array<array> et tu verras :€

D'accord, c'est plus clair maintenant. Merci pour ces explications, et dommage que l'optimisation que le memcpy m'aurait apportée ne fonctionne pas .

elle fonctionnera si tu utilises std::copy ... car elle se charge de faire ça
 
Et sidenote, tu te fout des perfs quant que t'as pas bencher

Hum, je dirai qu'en plus, c'est pas du C que tu fais, mais du C++. Un tableau alloué par new "contient" des information caché (bon c'est pas vraiment lui qui les as), qui fait que tu n'as pas a faire de Delete[n] mais juste un Delete[]. Je pense que dans ton cas il cherche désespérément à desalloué le tout premier tableau que tu as fais...  
 
En plus tu as déplacé des éléments sans leur signifié qu'ils étaient déplacer...
 
Mais je suis vraiment pas sur de ça. Regarde un coup le désassemble ou les logs...

non delete[] est la forme correcte pr la desallocation d'un tableau alloué par new ...
et y a qu'en russie stalinienne ou on desassemble son code pour chercher des erreurs ...

Erf, et on bazarde pas des données en écrasant un tableau dynamique comme ça ?

euh non, lis la doc de delete[]