From my point of view it seems that the text_iarchive makes some memory allocations during its operation but their references are lost after the deserialization which cause the leak, anyway I'm almost absolutely sure that I'm using this technique badly and there is a simple solution for this
Hi there! :)
I've recently become familiar with boost, therefore I'm quite newbie and
maybe the answer to my question is trivial.
Below there is a demonstrative code fragment from a test client application
where a server app periodically sends serialized objects to the client. The
client reads the socket, re-constructs the serialized object from the stream
using boost::archive::text_iarchive and makes some operation on it. Code is
very simple and it works fine, however the memory is leaking. I think there
is a problem with the usage of text_iarchive because if I comment the
appropriate line out, the leaking stops. Of course the
incomingTransferObject (and everything else in the progbam) are destructed
properly, they does nothing with the leak.
Here comes the code fragment:
char buffer[8192]; // class memeber, it contains data received on the socket
...
void Client::handleReadMessage(const boost::system::error_code& error,
std::size_t bytes_transferred)
{
// blah-blah
...
TransferObject* incomingTransferObject = new TransferObject();
std::istringstream archive_stream(buffer);
boost::archive::text_iarchive archive(archive_stream);
*archive >> incomingTransferObject;*
//...
// do something with the object
//...
delete incomingTransferObject;
tcpSocket->write_some(boost::asio::buffer("1")); // ack to the server
boost::asio::async_read(
*tcpSocket,
boost::asio::buffer(sizeBuffer), boost::asio::transfer_at_least(1),
boost::bind( &Client::handleReadHeader, this,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)
);
}
The TransferObject is a temporary class just to test serializing more
complex objects with stl containers. It looks like this:
class TransferObject
{
friend class boost::serialization::access;
template<typename Archive>
void serialize(Archive & ar, const unsigned int version)
{
ar & strvector;
ar & strmap;
ar & complexSet;
}
private:
vector<string>* strvector;
map