Bonjour,

Dans le but d'améliorer mon niveau en C++ à l'aide des cours et tutoriels C++, j'ai décider de créer une classe template pour une liste doublement chaînée.

Après la mise en place de la base du code (init, insertion en fin, ensertion en debut, libération), j'ai voulu tester la présence de fuites mémoires (vu la présence de pointeur, cette option est grandement possible dans mon cas ).

Voici le code de la classe ci-dessous :

Liste.h
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
template <class TYPE>  class List
{
	public : // Constructor-destructor
 
		List( unsigned long a_ulSize = 0 ) : m_List(NULL)
		{	Init();	}
 
		~List()
		{
			Clear();
 
			if( m_List != NULL)
			{	delete m_List;	m_List = NULL;		}
		}
 
	private : // Attributes
		struct Node
		{
			Node( TYPE Data = (TYPE)NULL ) : Data(Data), Prevnode(NULL), Nextnode(NULL)	{}
			TYPE		Data;
			Node		*Prevnode;
			Node		*Nextnode;
		};	
		struct Reflist
		{
			Reflist() :	Length(0), Tail(NULL), Head(NULL)	{}
			unsigned long	Length;
			Node			*Tail;
			Node			*Head;
		};
 
		Reflist		*m_List;
 
	private : // //Methods
		void Init()
		{	m_List = new Reflist;
 
			if (this->m_List != NULL)
			{	m_List->Length = 0;
				m_List->Tail = m_List->Head = NULL;		
			}
			return;
		}
 
	public : //Methods
		void PushBack( const TYPE &a_Data = (TYPE) NULL )
		{
			if (m_List != NULL) /* si List init */
			{
				Node *p_new = new Node(a_Data);
 
				if (p_new != NULL)
				{	if ( m_List->Length ) /* Liste vide? */
					{	m_List->Tail->Nextnode = p_new; 
						p_new->Prevnode = m_List->Tail; 
						m_List->Tail = p_new;
					}
					else 
					{	m_List->Head = p_new;		m_List->Tail = p_new; 		}
 
					m_List->Length++; 
				}
			}
			return;
		}
 
		void PushFront( const TYPE &a_Data = (TYPE) NULL )
		{
			if (m_List != NULL) /* si List init */
			{
				Node *p_new = new Node(a_Data); 
 
				if (p_new != NULL)
				{	if ( m_List->Length ) /* Liste vide? */
					{	m_List->Head->Prevnode = p_new; 
						p_new->Nextnode = m_List->Head; 
						m_List->Head = p_new;
					}
					else 
					{	m_List->Head = p_new;		m_List->Tail = p_new; 		}
 
					m_List->Length++; 
				}
			}
			return;
		}
 
		void Clear()
		{
			if (m_List != NULL) /* si List init */
			{
				Node *p_new; 
				while(m_List->Head != NULL)
				{	p_new = m_List->Head;
					m_List->Head = p_new->Nextnode;
					delete p_new;	
				}
 
				m_List->Tail = NULL;
				m_List->Length = 0;
			}
		}
 
		void SetSize( const unsigned long &a_ulSize )
		{
			while (m_List->Length < a_ulSize )
				this->PushBack();
 
			return;
		}
 
};

Pour le test, je reste simple :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
int main(int argc, char** argv)
{
	Linkedlist<unsigned int> CWorkingClass;
 
	for(unsigned int i=0 ; i<1000 ; i++)
	{
		CWorkingClass.Resize(1000);
		CWorkingClass.Clear();
	}
 
	return 0;
}
En vérifiant avec le "Gestionnaire des tâches Windows", l'occupation mémoire ne retombe pas à sa valeur initiale.

Deux questions donc pour ceux qui pourraient m'aider:
- D'où peut venir cette fuite mémoire?
- Que fais-je de mal dans mon code? (avez vous des conseils afin d'améliorer l'efficacité ou la clarté de mon code?)

Merci d'avance pour votre aide.