Double liste chainée pour un memory manager
Bonjour à tous :)
Je développe actuellement un memory manager en C++. J'utilise pour stocker mes allocations une double liste chainée.
Tous marche niquel sauf lorsque j'arrive à la désallocation, l'application plante sur le free de la méthode deallocate.
Voici un bout de code pour vous éclairer :
Code:
1
2
3
4
5
6
7
8
9
10
11
|
struct STBlock
{
void* address;
size_t size; ///< Taille allouée
char* file; ///< Fichier contenant l'allocation
int line; ///< Ligne de l'allocation
bool anArray; ///< Est-ce un objet ou un tableau ?
STBlock* previousBlock;
STBlock* nextBlock;
}; |
mFirst corresponde au premier élément de ma liste chainée et mLast au dernier.
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
|
MemoryManager::STBlock* MemoryManager::mFirst = NULL;
MemoryManager::STBlock* MemoryManager::mLast = NULL;
//-----------------------------------------------------
// Allocate memory space for object(s).
//-----------------------------------------------------
void* MemoryManager::allocate(std::size_t size, char* file, int line, bool anArray)
{
mNumNewCalls++;
assert(size > 0);
// Allocation de la mémoire
void* ptr = malloc(size);
// Save the allocation information.
STBlock* newBlock = (STBlock*)ptr;
newBlock->address = &ptr;
newBlock->size = size;
newBlock->file = file;
newBlock->line = line;
newBlock->anArray = anArray;
pushBackElement(newBlock);
// Keep track of number of allocated blocks and bytes.
mNumBlocks++;
mNumBytes += size;
return ptr;
}
//-----------------------------------------------------
// Free memory space for object(s).
//-----------------------------------------------------
void MemoryManager::deallocate(void* ptr, bool anArray)
{
mNumDeleteCalls++;
if(!ptr)
return;
STBlock* deleteBlock = (STBlock*)ptr;
if(deleteBlock->anArray == anArray)
{
popElement(deleteBlock);
// Libération de la mémoire
free(ptr);
}
}
//-----------------------------------------------------
// Insert a block in the doubly linked list.
//-----------------------------------------------------
void MemoryManager::pushBackElement(STBlock* block)
{
assert(block);
block->previousBlock = mLast;
block->nextBlock = NULL;
if(mLast)
{
mLast->nextBlock = block;
}
else
{
mFirst = block;
}
mLast = block;
}
//-----------------------------------------------------
// Remove a block in the doubly linked list.
//-----------------------------------------------------
void MemoryManager::popElement(STBlock* block)
{
STBlock* myBlock = mFirst;
while(myBlock != block)
myBlock = myBlock->nextBlock;
if(myBlock == block)
{
if((myBlock == mLast) && (mLast == mFirst))
{
return;
}
else if ((myBlock == mLast) && (mLast != mFirst))
{
myBlock->previousBlock->nextBlock = NULL;
mLast = myBlock->previousBlock;
mLast->previousBlock->nextBlock = mLast;
}
else if((myBlock == mFirst) && (mFirst != mLast))
{
mFirst = myBlock->nextBlock;
mFirst->nextBlock->previousBlock = mFirst;
}
else
{
myBlock->previousBlock->nextBlock = myBlock->nextBlock;
myBlock->nextBlock->previousBlock = myBlock->previousBlock;
}
}
} |
Pour vous aidez, lors de l'appel au delete voici ce qu'il me dit dans la fenêtre de déboggage : previousBlock et nextBlock : impossible d'évaluer les expressions de la structure STBlock.
Si quelqu'un à une petite idée :(
Merci d'avance à plus
