Bonjour,
Pour tester les templates je réinvente la roue en créant un conteneur.
Ma classe contient un pointeur (m_elemPointer) sur les éléments qu'elle contient et un entier non signé (m_nbElem) qui indique le nombre d'élements pointés.
J'ajoute des éléments à mon conteneur de cette manière:
Il m'affiche:
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 #include <iostream> #include "container.h" #define MAX_VALUE 6 using namespace std; int main(void) { Container<int> vect; for(size_t i = 0; i < MAX_VALUE; i++) //operateur << ajoute des éléments à la suite vect << 2*i; for(size_t i = 0; i < MAX_VALUE+3; i++) //operateur [] lit le nème élément cout << vect[i] << "\n"; return 0; }
La 1ère valeur devrait être de 0!4007160
2
4
6
8
10
10
10
10
Ma fonction qui sert à ajouter un élément:
En fait c'est la 2ème ligne qui pose problème. Lors du 1er appel de la fonction add() l'affectation n'est pas effective, mais seulement pour le 1er appel. Lors des appels suivants les autres affectations sont bien faites. C'est pour ça que ma 1ère valeur n'est pas de 0.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7 template<class elemType> void Container<elemType>::add(elemType element) { this->allocate(m_nbElem+1); m_elemPointer[m_nbElem] = element;//Affectation non réalisé m_nbElem++; }
La fonction allocate() à bien remplit son rôle pourtant:
Voiçi la définition complète de ma classe:
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 template<class elemType> void Container<elemType>::allocate(size_t size) { elemType * tmp = new elemType[size]; for(size_t i = 0; (i < m_nbElem) && (i < size); i++) tmp[i] = m_elemPointer[i]; if(size > m_nbElem) for(size_t i = m_nbElem; i < size; i++) { elemType null_value; tmp[i] = null_value; } delete [] m_elemPointer; m_elemPointer = tmp; }
Donc si quelqu'un voit quelque chose je le remercie d'avance
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 #ifndef CONTAINER_H #define CONTAINER_H template <class elemType> class Container { public: Container(); ~Container(); //Ajouter element void add(elemType); Container operator<<(elemType); //Lire valeur element elemType at(size_t) const; elemType operator[](size_t) const; //Changer valeur element void change(size_t,elemType); private: //Gestion memoire void allocate(size_t); elemType * m_elemPointer; size_t m_nbElem; }; //Contructeurs Destructeurs ---------------------------------------------------- //------------------------------------------------------------------------------ template<class elemType> Container<elemType>::Container() { m_elemPointer = NULL; m_nbElem = 0; } template<class elemType> Container<elemType>::~Container() { delete [] m_elemPointer; } //Ajout ------------------------------------------------------------------------ //------------------------------------------------------------------------------ template<class elemType> void Container<elemType>::add(elemType element) { this->allocate(m_nbElem+1); m_elemPointer[m_nbElem] = element; m_nbElem++; } template<class elemType> Container<elemType> Container<elemType>::operator<<(elemType element) { this->add(element); return *this; } //Lecture ---------------------------------------------------------------------- //------------------------------------------------------------------------------ template<class elemType> elemType Container<elemType>::at(size_t indice) const { elemType result; if(indice < m_nbElem) result = m_elemPointer[indice]; return result; } template<class elemType> elemType Container<elemType>::operator[](size_t indice) const { return this->at(indice); } //Modification ----------------------------------------------------------------- //------------------------------------------------------------------------------ template<class elemType> void Container<elemType>::change(size_t indice,elemType element) { if(indice < m_nbElem) m_elemPointer[indice] = element; } //Gestion mémoire -------------------------------------------------------------- //------------------------------------------------------------------------------ template<class elemType> void Container<elemType>::allocate(size_t size) { elemType * tmp = new elemType[size]; for(size_t i = 0; (i < m_nbElem) && (i < size); i++) tmp[i] = m_elemPointer[i]; if(size > m_nbElem) for(size_t i = m_nbElem; i < size; i++) { elemType null_value; tmp[i] = null_value; } delete [] m_elemPointer; m_elemPointer = tmp; } #endif /*CONTAINER_H*/![]()
Partager