Problema com Priority_queue - escrevendo memória após heap
-
18-09-2019 - |
Pergunta
Estou tentando usar priority_queue e o programa falha constantemente com a corrupção da mensagem de erro detectada.
Aqui estão os trechos:
class CQueue { ...
priority_queue<Message, deque<Message>, less<deque<Message>::value_type> > m_messages;
...};
A mensagem de classe tem sobrecarregado operadores> e
Aqui eu preencho a fila:
CQueue & operator+=(Message &rhv)
{
m_messages.push(rhv); //This is where program fails
return *this;
}
E no programa principal:
string str;
CQueue pq;
for(int i = 0; i < 12; ++i)
{
cin >> str;
Message p(str.c_str(), rand()%12); //Create message with random priority
pq += p; //add it to queue
}
Não tenho ideia do que parece ser o problema. Isso acontece quando eu pressiono cerca de 8 itens e falha na linha
push_heap(c.begin(), c.end(), comp);
em <Queue>
:(
Aqui está a definição de classe de mensagem - é muito simples:
#pragma once
#include <iostream>
#include <cstring>
#include <utility>
using namespace std;
class Poruka
{
private:
char *m_tekst;
int m_prioritet;
public:
Poruka():m_tekst(NULL), m_prioritet(-1){}
Poruka(const char* tekst, const int prioritet)
{
if(NULL != tekst)
{
// try{
m_tekst = new char[strlen(tekst) + 1];
//}
//catch(bad_alloc&)
// {
// throw;
// }
strcpy(m_tekst, tekst);
}
else
{
// try
// {
m_tekst = new char[1];
// }
// catch(bad_alloc&)
// {
// throw;
// }
m_tekst[0] = '\0';
}
m_prioritet = prioritet;
}
Poruka(const Poruka &p)
{
if(p.m_tekst != NULL)
{
//try
//{
m_tekst = new char[strlen(p.m_tekst) + 1];
//}
//catch(bad_alloc&)
//{
// throw;
//}
strcpy(m_tekst, p.m_tekst);
}
else
{
m_tekst = NULL;
}
m_prioritet = p.m_prioritet;
}
~Poruka()
{
delete [] m_tekst;
}
Poruka& operator=(const Poruka& rhv)
{
if(&rhv != this)
{
if(m_tekst != NULL)
delete [] m_tekst;
// try
//{
m_tekst = new char[strlen(rhv.m_tekst + 1)];
//}
//catch(bad_alloc&)
//{
// throw;
//}
strcpy(m_tekst, rhv.m_tekst);
m_prioritet = rhv.m_prioritet;
}
return *this;
}
friend ostream& operator<<(ostream& it, const Poruka &p)
{
it << '[' << p.m_tekst << ']' << p.m_prioritet;
return it;
}
//Relacioni operatori
friend inline bool operator<(const Poruka& p1, const Poruka& p2)
{
return p1.m_prioritet < p2.m_prioritet;
}
friend inline bool operator>(const Poruka& p1, const Poruka& p2)
{
return p2 < p1;
}
friend inline bool operator>=(const Poruka& p1, const Poruka& p2)
{
return !(p1 < p2);
}
friend inline bool operator<=(const Poruka& p1, const Poruka& p2)
{
return !(p1 > p2);
}
friend inline bool operator==(const Poruka& p1, const Poruka& p2)
{
return (!(p1 < p2) && !(p2 < p1));
}
friend inline bool operator!=(const Poruka& p1, const Poruka& p2)
{
return (p1 < p2) || (p2 < p1);
}
};
Poruka - mensagem
Solução
Eu acho que o problema é que o seu Message
Os objetos estão mantendo as indicações para as cordas C RAW que estão sendo desalocadas. Nestas linhas:
cin >> str;
Message p(str.c_str(), rand()%12);
Em cada iteração do loop, você está lendo em um novo valor para str
, que invalidam quaisquer ponteiros antigos devolvidos por seu c_str()
Método, portanto, suas mensagens mais antigas estão apontando para dados inválidos. Você deve mudar seu Message
objeto para que ele armazena sua string como um std::string
em vez de um char*
. Isso copiará corretamente a string para o Message
objeto.
Alternativamente, se você não pode mudar o Message
classe, você terá que copiar explicitamente a string, por exemplo, usando strdup()
ou malloc()
/new[]
+strcpy()
, e então você deve se lembrar de desalocar as cópias de string em algum ponto posterior.
Outras dicas
Não consigo falhar.
Mas não há informações suficientes para compilar esta linha:
push_heap(c.begin(), c.end(), comp);
Mas os únicos problemas que vejo são:
1) Você tem um construtor padrão que pode criar um poruka com um nome nulo:
Poruka::Poruka():m_tekst(NULL), m_prioritet(-1){}
2) Não é um problema porque você testa a maioria dos lugares, mas no operador de tarefas você perde um teste:
Poruka::Poruka& operator=(const Poruka& rhv)
{
....
// There was no test for 'rhv.m_tekst' being NULL here.
//
m_tekst = new char[strlen(rhv.m_tekst + 1)];
strcpy(m_tekst, rhv.m_tekst);
Notas:
- Você pode tornar seu código muito mais simples usando a classe STD :: String.
- Se você ainda deseja usar char*, se você Gurantee, nunca será nulo, o código é mais simples
- Também há um padrão mais simples para definir o construtor de cópia padrão e o operador de atribuição. É referido como cópia/swap idium.
- Você não precisa definir todos esses operadores relacionais. Há um conjunto de modelos que funcionam automaticamente na ver http://www.sgi.com/tech/stl/operators.html. Você só precisa definir operador <e operador ==
Aqui está um exemplo do cópia/swap idium
class X
{
X(X const& copy)
{
// Do the work of copying the object
m_tekst = new char[strlen(copy.m_tekst) + 1];
...
m_prioritet = copy.m_prioritet;
}
X& operator=(X const& copy)
{
// I like the explicit copy as it is easier to read
// than the implicit copy used by some people (not mentioning names litb)
//
X tmp(copy); // Use the copy constructor to do the work
swap(tmp);
}
void swap(X& rhs) throws ()
{
std::swap(this->m_tekst, rhs.m_tekst);
std::swap(this->prioritet, rhs.prioritet);
}