Discussion :

[Lynix]

Salut,

J'ai un probl�me avec un gestionnaire de m�moire que je tire de celui de Laurent Gomila trouv� sur cette page

Il fonctionne parfaitement lorsque j'utilise seulement un new, mais d�s que je met un delete il semble tourner en boucle sur la surcharge de l'op�rateur delete

Voici tous les fichiers du projet sous codeblocks :
http://www.megaupload.com/?d=EVK7304V

Rencontrez-vous le m�me probl�me? Et surtout, savez-vous comment le corriger?

J'ai demand� au cr�ateur qui m'a r�pondu qu'il n'avait jamais eu ce probl�me, donc je me demande ce que j'ai dans le code qui fait planter tout �a.

Merci d'avance

[3DArchi]

Salut,
Le mieux est encore que tu reproduises le bug sur un exemple tr�s simplifi� et que tu nous montres le code qui pose probl�me.

[Lynix]

Le bug est reproduit dans le pack, il y a plusieurs fichiers pour le projet.

Mais voila un exemple :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include "Debug/On.h"
 
using namespace std;
 
int main()
{
    int* test = new int;
    return 0;
}
 
#include "Debug/Off.h"

Fonctionne sans probl�me

Mais d�s que j'ose utiliser un delete :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <iostream>
#include "Debug/On.h"
 
using namespace std;
 
int main()
{
    int* test = new int;
    delete test;
    return 0;
}
 
#include "Debug/Off.h"

L'application se lance, et se ferme (se fait fermer il semblerait).

D'apr�s le d�bugger, le code tourne en boucle sur la surcharge de delete.

Voici le fichier qui surcharge les m�thodes new et delete (Debug/On.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
#ifdef _DEBUG
 
#ifndef DEBUGNEW_H
#define DEBUGNEW_H
 
#include "MemoryManager.h"
 
inline void* operator new(std::size_t Size, const char* File, int Line)
{
    return MemoryManager::Instance().Allocate(Size, File, Line, false);
}
 
inline void* operator new[](std::size_t Size, const char* File, int Line)
{
    return MemoryManager::Instance().Allocate(Size, File, Line, true);
}
 
inline void operator delete(void* Ptr)
{
    MemoryManager::Instance().Free(Ptr, false);
}
 
inline void operator delete(void* Ptr, const char* File, int Line)
{
    MemoryManager::Instance().NextDelete(File, Line);
    MemoryManager::Instance().Free(Ptr, false);
}
 
inline void operator delete[](void* Ptr)
{
    MemoryManager::Instance().Free(Ptr, true);
}
 
inline void operator delete[](void* Ptr, const char* File, int Line)
{
    MemoryManager::Instance().NextDelete(File, Line);
    MemoryManager::Instance().Free(Ptr, true);
}
 
#endif // DEBUGNEW_H
 
#ifndef new
    #define new    new(__FILE__, __LINE__)
    #define delete MemoryManager::Instance().NextDelete(__FILE__, __LINE__), delete
#endif
 
#endif

Les autres fichiers sont dans le pack :
MemoryManager.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
#ifndef MEMORYMANAGER_H_INCLUDED
#define MEMORYMANAGER_H_INCLUDED
 
#include <iostream>
#include <iomanip>
#include <map>
#include <stack>
#include <string>
 
class MemoryManager
{
    public:
        static MemoryManager& Instance();
        void* Allocate(std::size_t Size, std::string File, int Line, bool Array);
        void Free(void* Ptr, bool Array);
        void NextDelete(std::string File, int Line);
 
    private:
        MemoryManager();
        ~MemoryManager();
        void ReportLeaks();
 
        struct TBlock
        {
            std::size_t Size;
            std::string File;
            int         Line;
            bool        Array;
        };
        typedef std::map<void*, TBlock> TBlockMap;
 
        TBlockMap          m_Blocks;
        std::stack<TBlock> m_DeleteStack;
 
};
 
#endif // MEMORYMANAGER_H_INCLUDED

MemoryManager.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
#include "MemoryManager.h"
 
MemoryManager::MemoryManager()
{
    std::cout << "  ========================================" << std::endl;
    std::cout << "             Memory leak tracker          " << std::endl;
    std::cout << "  ========================================" << std::endl << std::endl;
}
 
MemoryManager::~MemoryManager()
{
    if (m_Blocks.empty())
    {
        std::cout << std::endl;
        std::cout << "  ========================================" << std::endl;
        std::cout << "     No leak detected, congratulations !  " << std::endl;
        std::cout << "  ========================================" << std::endl;
    }
    else
    {
        std::cout << std::endl;
        std::cout << "  ========================================" << std::endl;
        std::cout << "   Oops... Some leaks have been detected  " << std::endl;
        std::cout << "  ========================================" << std::endl;
        std::cout << std::endl;
 
        ReportLeaks();
    }
}
 
MemoryManager& MemoryManager::Instance()
{
    static MemoryManager Inst;
 
    return Inst;
}
 
void MemoryManager::ReportLeaks()
{
    std::size_t TotalSize = 0;
    for (TBlockMap::iterator i = m_Blocks.begin(); i != m_Blocks.end(); ++i)
    {
        TotalSize += i->second.Size;
 
        std::cout << "-> 0x" << i->first
               << " | "   << std::setw(7) << std::setfill(' ') << static_cast<int>(i->second.Size) << " octets"
               << " | "   << i->second.File << " (" << i->second.Line << ")" << std::endl;
 
        free(i->first);
    }
 
    std::cout << std::endl << std::endl << "-- "
           << static_cast<int>(m_Blocks.size()) << " blocs non-libéré(s), "
           << static_cast<int>(TotalSize)       << " octets --"
           << std::endl;
}
 
void* MemoryManager::Allocate(std::size_t Size, std::string File, int Line, bool Array)
{
    void* Ptr = malloc(Size);
 
    TBlock NewBlock;
    NewBlock.Size  = Size;
    NewBlock.File  = File;
    NewBlock.Line  = Line;
    NewBlock.Array = Array;
    m_Blocks[Ptr]  = NewBlock;
 
    return Ptr;
}
 
void MemoryManager::Free(void* Ptr, bool Array)
{
    TBlockMap::iterator It = m_Blocks.find(Ptr);
 
    if (It == m_Blocks.end())
    {
        free(Ptr);
        return;
    }
 
    if (It->second.Array != Array)
    {
        std::cout << "BadDelete error !" << std::endl;
        std::cout << It->second.File << ":" << It->second.Line << std::endl;
        std::cout << (int) !Array << std::endl;
        return;
    }
 
    m_Blocks.erase(It);
    m_DeleteStack.pop();
 
    free(Ptr);
}
 
void MemoryManager::NextDelete(std::string File, int Line)
{
    TBlock Delete;
    Delete.File = File;
    Delete.Line = Line;
 
    m_DeleteStack.push(Delete);
}

[3DArchi]

As-tu mis un point d'arr�t � ton destructeur ?
As-tu mis un point d'arr�t � delete et regarder ce qu'il se passe en mode pas � pas ?

[Lynix]

La seule chose que j'ai pu tirer du debug c'est que l'instruction

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

MemoryManager::Instance().Free(Ptr, false);

est execut�e en boucle

(Cette ligne vient de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
inline void operator delete(void* Ptr)
{
    MemoryManager::Instance().Free(Ptr, false);
}

Aussi, la ligne :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

static MemoryManager Inst;

semble �tre execut�e en boucle, mais pas le return Inst;

Je n'ai jamais vu �a :/

[3DArchi]

-> Rebuild All : t'as essay� ...