Échec de l'assertion de débogage ... _BLOCK_TYPE_IS_VALID (pHead- & gt; nBlockUse)

J'ai eu une très mauvaise fuite de mémoire, je suis en train de corriger, mais de toute façon je ne suis pas en mesure de supprimer des Objets sans le déclenchement de cette assertation.

J'ai cherché une solution par l'intermédiaire de Google et avoir lu les Questions sur stackoverflow à propos de cette Erreur, mais je n'étais pas encore en mesure de trouver la réponse!

Raisons possibles de cette Erreur après mes recherches:
1. la suppression des objets de plus d'un
2. l'ombre de la copie
3. création et suppression d'Objets qui sont chargés à partir d'une dll externe
4. création d'objets sans stocker le pointeur

MAIS:
1. J'ai vérifié le code et n'a pas été en mesure de trouver double suppression
2. Je utiliser un constructeur de copie pour copier des Objets
3. L'Erreur relatet classes sont à construire (avec MS Visual Studio) à une autre lib, mais pas à une dll. ET toutes les classes qui sont liées à ce type d'erreur sont situés dans la même lib.
4. J'ai vérifié le code, et il semble que ce n'est pas le problème

Ce serait génial si quelqu'un est en mesure de repérer l'erreur dans le code ci-dessous, et j'apprécie chaque allusion au fait que les points de moi à la solution du problème.

EDIT:
J'ai oublié de parler de la même suppression de problème dans sendThreadMain de MessageSystem (voir code ci-dessous). Si je supprime le Message là il provoque des erreurs quelque part ailleurs dans le code. Peut-être tort de transmission de données... mais je ne sais pas vraiment.
Ce code est exécuté sur Windows et Linux!

Voici l'erreur relative des parties de code:

Message

class Message 
{
public:
Message (char type, unsigned char id, unsigned short size) 
{
mType = type;
mId = id;
mSize= size;
}
Message(const Message &o)
{
mType = o.mType;
mId = o.mId;
mSize = o.mSize;
}
char getType() const {return mType;};
unsigned char getId() const {return mId;};
unsigned short getSize() const {return mSize;};
protected:
char mType;
unsigned char mId;
unsigned short mSize;
};
class JoinMessage : public Message
{
public:
JoinMessage () : Message ('j', 0, sizeof (JoinMessage))
{
team = TEAM_SPECTATOR;
}
JoinMessage (unsigned char id) : Message ('j', id, sizeof (JoinMessage)){}
JoinMessage (const JoinMessage &o) : Message (o)
{
team = o.team;
setName(o.getName());
}
void setName(std::string newName)
{
if (newName.length() > MAX_PLAYER_NAME_LENGHT)
newName = newName.substr(0, MAX_PLAYER_NAME_LENGHT);
memset(name, 0, MAX_PLAYER_NAME_LENGHT);
for(unsigned int i = 0; i < newName.length(); i++)
name[i] = newName[i];
}
std::string getName() const
{
std::string stringToReturn;
for(unsigned int i = 0; i < MAX_PLAYER_NAME_LENGHT; i++)
{
if (name[i])
stringToReturn.push_back(name[i]);
else
break;
}
return stringToReturn;
}
TeamIdentifier team;
private:
unsigned char name[MAX_PLAYER_NAME_LENGHT];
};
//there are a lot other messages

MessageQueue

MessageQueue::~MessageQueue()
{
boost::mutex::scoped_lock lock (queueMutex);
while(messageQueue.size() > 0)
{
//the crash is non-reproducible
//works 90% of the time
delete messageQueue.front (); //<- Debug Assertion Failed … _BLOCK_TYPE_IS_VALID
messageQueue.pop_front();
}
}
void MessageQueue::enqueMessage (Message* message)
{
{
boost::mutex::scoped_lock lock (queueMutex);
messageQueue.push_back(message);
}
}
Message* MessageQueue::dequeMessage ()
{
boost::mutex::scoped_lock lock (queueMutex);
if (messageQueue.size() == 0) 
return nullptr;
Message* message = messageQueue.front ();
messageQueue.pop_front();
return message;
}

MessageSystem

template <class MessageType>
void broadcast (MessageType &message)
{
MessageType *internMessage = new MessageType(message);
boost::mutex::scoped_lock lock (mRecipientMapMutex);
std::map <boost::asio::ip::udp::endpoint, MessageQueue *>::iterator it;
for (it = mRecipientMap.begin ();
it != mRecipientMap.end ();
it++)
{
it->second->enqueMessage(internMessage);
}
}
template <class MessageType>
void post (MessageType &message, boost::asio::ip::udp::endpoint &recipient)
{
MessageType *internMessage = new MessageType(message);
std::map <boost::asio::ip::udp::endpoint, MessageQueue* >::iterator it;
MessageQueue *messageQueue = NULL;
{
boost::mutex::scoped_lock lock (mRecipientMapMutex);
it = mRecipientMap.find (recipient);
if (it != mRecipientMap.end())
messageQueue = it->second;
if(messageQueue)
messageQueue->enqueMessage (internMessage);
}
}
void MessageSystem::sendThreadMain ()
{
//copy endpoints to vecotr so it can be
//deleted from map while iterating
std::vector<udp::endpoint> endpoints;
{
boost::mutex::scoped_lock lock (mRecipientMapMutex);
std::map <udp::endpoint, MessageQueue *>::iterator mapIt = mRecipientMap.begin ();
while (mapIt != mRecipientMap.end())
{
endpoints.push_back(mapIt->first);
mapIt++;
}
}
std::vector<udp::endpoint>::iterator endpointIt = endpoints.begin();
while (endpointIt != endpoints.end())
{
char sendBuffer[PACKET_SIZE];
int sendBufferPosition = 0;
{
boost::mutex::scoped_lock lock (mRecipientMapMutex);
MessageQueue *messageQueue = mRecipientMap[*endpointIt];
if (messageQueue == nullptr)
{
mRecipientMap.erase(*endpointIt);
endpointIt++;
continue;
}
while (Message *message = messageQueue->dequeMessage ())
{
if (sendBufferPosition + message->getSize() > PACKET_SIZE) 
{
//put message back and send it later
messageQueue->enqueMessage (message);
break;
}
//copy message into buffer
std::memcpy (
&sendBuffer [sendBufferPosition], message, message->getSize());
sendBufferPosition += message->getSize();
//deleting this message causes a crash if 2 or more
//recipients are registered within MessageSystem
//delete message; <- RANDOM CRASH elsewhere in the program
}
}
.... //more code down here that seems not related to the error

source d'informationauteur cwin