Bonjour à tous

je débute en C++, j'ai un programme à faire ou je vais rechercher un nombre indéterminé de données depuis un fichier. Il faut donc que j'utilise l'allocation dynamique.
Pour cela je crée un tableau d'objets dont je fixe la taille à 100 au départ, et si je n'ai pas assez de place, je double sa taille (je me sers d'un autre tableau tampon pour garder les données pendant que j'agrandis l'autre tableau).

En fait je suis obligé de faire tous ça parceque je n'ai pas le droit d'utiliser la STL.

Donc tout ça marche très bien, sauf que à la fin quand je quitte le programme je veux libérer les espaces alloués en faisant delete[], et c'est là que généralement le programme plante. je ne sais pas d'où ça vient, peut-être de l'allocation et réallocation des tableaux que je ne fais pas correctement?


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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
// datastructure.cc
// definition of the interface
 
#include <cstdlib>
#include <iostream>
#include "datastructure2.hh"
 
// the standard namespace for convenience
using namespace std;
 
// Constructor of the class
Datastructure2::Datastructure2() : i(0)
{
    taille_tableau=100;
    database=new Result[taille_tableau];
 
}
 
// destructor
Datastructure2::~Datastructure2()
{
    removeAll();
}
 
 
 
int Datastructure2::size()
{
    return i;
}
 
 
// Add a new element
bool Datastructure2::add(Result* new_r, int index)
{
   //s'il n'y a plus assez de place dans le tableau, je double sa taille
    if(!(taille_tableau>i))
    {
 
        tampon = new Result[taille_tableau];
 
        for(int j=0;j<taille_tableau;j++)
        {
            tampon[j].name = database[j].name;
            tampon[j].totalresult = database[j].totalresult;
            tampon[j].results = database[j].results;
 
        }
 
        taille_tableau*=2;
 
        database=new Result[taille_tableau];
 
        for(int j=0;j<taille_tableau/2;j++)
        {
            database[j].name = tampon[j].name;
            database[j].totalresult = tampon[j].totalresult;
            database[j].results = tampon[j].results;
        }
    }
 
    if(i == (index-1))
    {
        database[i].name = new_r->name;
        database[i].totalresult = new_r->totalresult;
        database[i].results = new_r->results;
 
    }
    else
    {
        for(int z=i;z>index-1;z--)
        {
            database[z].name = database[z-1].name;
            database[z].totalresult = database[z-1].totalresult;
            database[z].results = database[z-1].results;
 
        }
        database[index-1].name = new_r->name;
        database[index-1].totalresult = new_r->totalresult;
        database[index-1].results = new_r->results;
    }
    i++;
 
    return true;
}
 
Result& Datastructure2::operator[]( int index )
{
    return database[index-1];
}
 
// removes the element at the index
void Datastructure2::remove( int index )
{
    for(int z=index-1;z<i;z++)
    {
        database[z].name = database[z+1].name;
        database[z].totalresult = database[z+1].totalresult;
        database[z].results = database[z+1].results;
    }
 
    i--;
}
 
// deletes all elements from the data structure by using delete
// cette fonction est appelée depuis le main quand le programme est fini
void Datastructure2::removeAll( )
{
    delete [] tampon;
    delete [] database;
}