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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : 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
 
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