Discussion :

[JasBeckC]

Bojour à tous,

Je voudrais savoir comment on fait pour libérer la mémoire si l'allocation est faite comme suit (A travers ce code je voulais implémenter une LinkedList).

Merci!!

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
 
 
class List{
public:
     void Method1(){
           if (/*some condition*/){
                  Node* temp1= new Node;
           }
     }
     void Method2(){
           if (/*some condition*/){
                  Node* temp2= new Node;
           }
     }
 
};

[Médinoc]

La première question, c'est quand tu libères la mémoire...

[JasBeckC]

La première question, c'est quand tu libères la mémoire...

Ah oui, c'est à la destruction de l'objet List.

Merci

[Médinoc]

Dans ce cas, tu dois mémoriser le pointeur en tant que variable membre (et l'initialiser à NULL -- ou nullptr si tu compiles en C++11 ou supérieur -- tant qu'il ne pointe pas vers quelque chose).

[JasBeckC]

Pas mal du tout effectivement. Faudrait-il que je crée un tableau de pointeurs et que je stock chaque pointeur crée? J'imagine que ça doit ressembler à ça:

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
 
 
Node* nodePointeurs[]=new Node;
Int compteur=0;
 
If (/* condition */){
Compteur++;
nodePointeur[compteur]=new Node;
 
// il serait où mon temp pour que je l'utilise?
 
}
 
~List(){
For (int i=0; i<compteur;i++){
Delete nodePointeur[compteur];
}
}

Je pense que j'aurais encore besoin d'aide pour ce code :/

Merci!!

[Médinoc]

Es-tu sûr d'avoir compris le principe de la liste chaînée (linked list en anglais)?

[JasBeckC]

Euhh, je pense que oui, pourquoi?

[lautrec1]

Là tu implementes un tableau de pointeurs, pas une liste chaînée.

Un tableau de pointeurs est une séquence de pointeurs qui n'ont a priori aucun rapport entre eux. Ils pointent vers des objets de type défini.
Ex int *Node[N] : N pointeurs vers un entier. Les pointeurs n'ont aucun rapport avec la valeur qui suit.

Une liste chainée est une suite de paires {valeur, pointeurVersElementSuivant}. Les éléments d'une liste chaines sont liés entre eux : l'élément pointeurVersElementSuivant permet d'accéder à l'adresse de la valeur suivante.

[JasBeckC]

Si les pointeurs pointent déjà sur les Noeuds qui succèdent dans la liste, je ne vois pas pourquoi on pourrait pas les stocker dans un tableau de pointeurs?

ça serait quoi le code que tu proposerais à mon problème?

Merci

[Bousk]

Dans ce cas ça ne s'apelle plus une liste mais un tableau.

Structure bateau et simpliste d'une liste chaînée, que l'on doit bien retrouver un demi million de fois sur le net

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
template< class T >
struct Node
{
 T data;
 Node* next;
};

[JasBeckC]

je sais c'est quoi un nœud, c'est ce que j'ai implémenté dans mon code ci-dessous.

Ma question est comment libérer la mémoire que j'alloue conditionnellement à la création d'un nouveau nœud.


ci-dessous mon code:

Node.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
 
#ifndef _NODE_H_
#define _NODE_H_
 
 
class Node{
	int mData;
	Node* nextNode;
 
public:
	Node();
	void setData(int data);
	void setNextNode(Node* node);
	int getData(void);
	Node* getNextNode(void);
	Node* operator =(Node* node);
};
 
#endif

Node.cpp

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
 
#include "Node.h"
#include<iostream>
 
using namespace std;
 
Node::Node(){
	mData=0;
	nextNode==NULL;
};
 
void Node::setData(int data){
	mData=data;
}
 
void Node::setNextNode(Node* node){
	nextNode=node;
}
 
int Node::getData(void){
	return mData;
}
 
Node* Node::getNextNode(void){
	return nextNode;
}
 
Node* Node::operator=(Node* node){
	this->setData(node->getData());
	this->setNextNode(node->getNextNode());
	return this;
}

List.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
 
#ifndef _LIST_H_
#define _LIST_H_
 
#include "Node.h"
 
class List{
	Node* head;
public:
	List();
	void Add(int data);
	void AddAt(int index, int data);
	void Print();
	void DeleteAt(int index); 
	int getEndList();
};
#endif

List.cpp

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
#include "List.h"
 
#include<iostream>
using namespace std;
 
List::List(){
	head=NULL;
}
 
void List::Print(){
	Node* tmp=head;
	if(tmp==NULL){
		cout <<"The List is Empty" << endl;
	}
	if(tmp->getNextNode()==NULL){
		cout <<tmp->getData();
		cout <<"-->NULL" << endl;
	}
	else{
		while(tmp->getNextNode()!=NULL){
			cout<<tmp->getData();
			cout<<"-->";
			tmp=tmp->getNextNode();
		}
		cout <<tmp->getData();
		cout<<"-->NULL" << endl;
	};
 
	delete tmp;
}
 
void List::Add(int data){
	Node* newNode = new Node;
	newNode->setNextNode(NULL);
	newNode->setData(data);
 
	Node*temp = head;
 
	if(temp==NULL){
		head=newNode;
	}
	else{
		while(temp->getNextNode()!=NULL)
		{
			temp=temp->getNextNode();
		}
		temp->setNextNode(newNode);
	}
 
}
 
void List::AddAt(int index, int data){
		int endList(1);
		endList=this->getEndList();
 
		if(index>endList){
			cout<< "Your index is out range" << endl;
		}
 
		Node* newNode=new Node;
		Node* temp=new Node;
 
		newNode->setData(data);
		temp=head;
 
	if (index==1){
		newNode->setNextNode(temp);
		head=newNode;
	}
 
	if (index==2){
		Node* nodeAfter;
		Node* nodeBefore;
 
		nodeBefore=temp;
		nodeAfter=temp->getNextNode();
		nodeBefore->setNextNode(newNode);
		newNode->setNextNode(nodeAfter);
	}
 
	if (index==endList){
		Node* nodeBefore;
 
		for(int j(1); j<index-1;j++){
			temp=temp->getNextNode();
		}
		nodeBefore=temp;
		nodeBefore->setNextNode(newNode);
		newNode->setNextNode(NULL);
	}
	else if (index>2){
		Node* nodeAfter;
		Node* nodeBefore;
 
		for(int j(1); j<index-1;j++){
			temp=temp->getNextNode();
		}
		nodeBefore=temp;
		nodeAfter=temp->getNextNode();
		nodeBefore->setNextNode(newNode);
		newNode->setNextNode(nodeAfter);
	}
 
};
 
void List::DeleteAt(int index){
 
	int endList=this->getEndList();
 
	if (index>endList){
		cout << "Index of Delete Out of Range" << endl;
	}
 
	Node* temp;
	temp=head;
	if (index==1){
		head=temp->getNextNode();
	}
	if (index==2){
		temp=temp->getNextNode();
		temp=temp->getNextNode();
		head->setNextNode(temp);
	}
 
	if (index==endList){
		Node* nodeBefore;
		for(int j(1); j<index-1;j++){
			temp=temp->getNextNode();
		}
		nodeBefore=temp;
		nodeBefore->setNextNode(NULL);
 
	}
	if (index>2){
		Node* nodeBefore;
		Node* nodeAfter;
		for(int j(1); j<index-1;j++){
			temp=temp->getNextNode();
		}
		nodeBefore=temp;
		temp=temp->getNextNode();
		nodeAfter=temp->getNextNode();
		nodeBefore->setNextNode(nodeAfter);
	}
 
}
int List::getEndList(){
 
		int endList(1);
		Node* nodeEndList;
		nodeEndList=head;
		while(nodeEndList->getNextNode()!=NULL){
			nodeEndList=nodeEndList->getNextNode();
			endList++;
		}
		endList++;
		return endList;
}

[lautrec1]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
ListeChainee::~ListeChainee()
{
    Node *temp;
    Node *current = head;
 
    while(current)
    {
    	temp = current;
    	current = current->next;
    	delete temp;
    }
}

[JasBeckC]

Wow super!!!!! c'est exactement ce que je cherchais. Merci beaucoup!!!!