Modification valeur impossible class template
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:
Code:
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;
} |
Il m'affiche:
Citation:
4007160
2
4
6
8
10
10
10
10
La 1ère valeur devrait être de 0!
Ma fonction qui sert à ajouter un élément:
Code:
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++;
} |
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.
La fonction allocate() à bien remplit son rôle pourtant:
Code:
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;
} |
Voiçi la définition complète de ma classe:
Code:
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*/ |
Donc si quelqu'un voit quelque chose je le remercie d'avance ;)
