Binary read/write to std::stringstream

Question

I have the following code trying to read/write an unsigned int and a std::wstring to a std::stringstream.

#include <memory>
#include <iostream>
#include <vector>
#include <sstream>

class SerializationException : public std::runtime_error
{
public:
    SerializationException( const char* msg ) : std::runtime_error( msg ) { }
};

class Serialization
{
public:
    static void Write( std::ostream& stream, const std::wstring& item )
    {
        Write(stream, eStdWString);
        Write(stream, item.length());
        stream.write( reinterpret_cast< const char* >( item.c_str() ), item.length() );
    }

    static std::wstring ReadWString( std::istream& stream )
    {
        const unsigned int type = ReadUInt32(stream);
        if ( type != eStdWString )
        {
            throw SerializationException("Expected eStdWString");
        }
        const unsigned int length = ReadUInt32(stream);
        std::vector< wchar_t > tmpBuf( length );
        stream.read( reinterpret_cast< char* > ( tmpBuf.data() ), length );
        return std::wstring( tmpBuf.begin(), tmpBuf.end() );
    }

    static void Write( std::ostream& stream, const unsigned int& item )
    {
        const unsigned int type = eUInt32;
        stream.write( reinterpret_cast< const char* >( &type ), sizeof(type) );
        stream.write( reinterpret_cast< const char* >( &item ), sizeof(item) );
    }

    static unsigned int ReadUInt32( std::istream& stream )
    {
        const unsigned int type = 0;
        stream.read( reinterpret_cast< char* > ( type ), sizeof(type) );
        if ( type != eUInt32 )
        {
            throw SerializationException("Expected eUInt32");
        }
        const unsigned int tmp = 0;
        stream.read( reinterpret_cast< char* > ( tmp ), sizeof(tmp) );
        return tmp;
    }

private:
    enum eTlvBlockTypes
    {
        eStdWString,
        eUInt32
    };
};

int main(int, char**)
{
    std::wstring myStr = L"HelloWorld!";
    int myInt = 0xdeadbeef;

    try
    {
        std::stringstream ss( std::ios_base::out | std::ios_base::in | std::ios_base::binary );
        Serialization::Write( ss, myStr );
        Serialization::Write( ss, myInt );

        myInt = Serialization::ReadUInt32( ss );
        myStr = Serialization::ReadWString( ss );
    }
    catch (const std::runtime_error& ex)
    {
        std::cout << ex.what() << std::endl;
    }
    return 0;
}

However on reading back the stream I get an assertion failed because the stream is NULL, can someone explain why this is, and how to resolve it?

Edit: The assertion failed is the 2nd line of ReadUInt32().

stream.read( reinterpret_cast< char* > ( type ), sizeof(type) );

Answer 1

You need to fix this:

stream.read( reinterpret_cast< char* > ( type ), sizeof(type) );

to this:

stream.read( reinterpret_cast< char* > ( &type ), sizeof(type) );

It shows again that reinterpret_cast is dangerous