Question Allocation Mémoire Conditionnelle

Version imprimable

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:

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;
           }
     }
 
};

27/10/2014, 10h40
Médinoc

La première question, c'est quand tu libères la mémoire...
27/10/2014, 10h52
JasBeckC

Citation:

Envoyé par Médinoc

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

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

Merci
27/10/2014, 11h04
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).

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:

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!!

27/10/2014, 15h58
Médinoc

Es-tu sûr d'avoir compris le principe de la liste chaînée (linked list en anglais)?
27/10/2014, 16h25
JasBeckC

Euhh, je pense que oui, pourquoi?
27/10/2014, 17h03
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.
27/10/2014, 18h17
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
27/10/2014, 18h35
Bousk
Dans ce cas ça ne s'apelle plus une liste mais un tableau. :weird:

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:

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

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:

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:

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:

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:

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;
}

Code:

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;
    }
}

27/10/2014, 20h56
JasBeckC

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