Writing a struct to a binary file

Code:

---

#ifndef _FILE_H_

#define _FILE_H_

#include "main.h"
#include <fstream>

using namespace std;

struct MusicRecord
{
        char * Artist;
        char * Album;
        char * Title;
        long size;
        std::basic_string<WCHAR> Path;
};

class FileSystem
{
private:
        ofstream Create;
public:
        FileSystem(void);
        ~FileSystem(void);

        void ALP_InsertRecord( MusicRecord Rec, int Index );
        void ALP_GetRecord( MusicRecord &Rec, int Index );
};

#endif

....


#include "FileSystem.h"

FileSystem::FileSystem(void)
{
}

FileSystem::~FileSystem(void)
{
}

void FileSystem::ALP_InsertRecord(MusicRecord Rec, int Index)
{
        fstream Stream( "playlist.alp", ios::out|ios::binary|ios::app);
        Stream.seekp( ( Index ) * sizeof ( MusicRecord ) );
        Stream.write( (char*) &Rec, sizeof( MusicRecord ) );
        Stream.close();
}

void FileSystem::ALP_GetRecord(MusicRecord &Rec, int Index)
{
        fstream Stream( "playlist.alp", ios::binary|ios::in );
        Stream.seekg( ( Index ) * sizeof( MusicRecord ) );
        Stream.read( (char *) &Rec, sizeof( MusicRecord ) );
        Stream.close();
}

......

        MusicRecord Rec;

        Rec.Album = mp3fi.szAlbum;
        Rec.Artist = mp3fi.szArtist;
        Rec.Path = FilePath;
        Rec.Title = mp3fi.szTitle;

        FileSystem File;
        Rec.size = sizeof(Rec);
        File.ALP_InsertRecord( Rec, ItemCount );

---

It simply isn´t working any ideas?

Neither the char* members, nor the basic_string member can be written that way. Both store their data somewhere other than directly inside the struct (at least that's how basic_string usually does it).

You can use fixed size character arrays if you want, like char Artist[20]. You can also put a little more effort into the insert and get functions and write out the size of each string first, followed by the string data, then read in the size of the string when getting so that you can create the correct amount of memory. If you did that, you should consider using string or wstring for all your needs.

Code:

---

struct MusicRecord
{
        string Artist;
        string Album;
        string Title;
        string Path;
};

...

void FileSystem::ALP_InsertRecord(MusicRecord &Rec, int Index)
{
        ofstream Stream( "playlist.dat", ios::out|ios::binary|ios::app);
        Stream.seekp( ( Index ) * sizeof ( MusicRecord ) );
        Stream.write( (char*) &Rec, sizeof( MusicRecord ) );
        Stream.close();
}

void FileSystem::ALP_GetRecord(MusicRecord &Rec, int Index)
{
        ifstream Stream( "playlist.dat", ios::binary|ios::in );
        Stream.seekg( ( Index ) * sizeof( MusicRecord ) );
        Stream.read( (char *) &Rec, sizeof( MusicRecord ) );
        Stream.close();
}

---

Ok, its now this way.
1)How can i just write the size of the string before it if i am using seekp and seekg?


2)How do i allocate a memory to a string? i tought i could only add the things to it without having the same problem as char*.

3)I think this code is correct but the file "playlist.dat" is full of unknown characters, just the small strings are written to it properly, the big ones are just something weird, so some records are correct and others are like "ÌÌÌ̈†7 ÌÌÌÌÌÌÌÌÌÌÌÌe o".

Thank you

string is the same as basic_string, so what I said about char * and basic_string in the previous post applies to string. You can't do it that way because the string class stores its information outside of its own place in memory.

The trick with writing the size of the string means that seekg and seekp won't work, because the size of each record will depend on the size of the string. If you want to use seekp/seekg, you will have to choose a maximum size for your strings and use that (in which case character arrays would be better).

This is all assuming you need to write the file as records in binary for some reason. In many cases this isn't necessary, you can just write out the records in a specific format in regular text mode. Then, you'd load all records into a data structure and look them up by index in that.

Any example on how i would do without using binary format?

Just use regular stream output. Separate each member with a delimiter. Separate each record by a newline. With string members it is a bit more complicated since the strings themselves might have the delimiter or newlines embedded within them. If that can happen, you could place them in quotes (and double up any quotes inside the string).

Then, when you read it back in, you just read each quoted value one at a time and store it in your record, saving each filled record to a data structure like a vector. I don't have any specific examples, but it is a common technique.

This *might* be overkill, but you could also link to some XML library and write all your class data in XML :)

I think XML is a good choice. Any resource on how to use XML?

I was being satirical. Whatever you want, though. There are a lot of C++ libraries implementing XML parsers and readers you can use for free. The W3C should be a good starting point; however I wouldn't recommend XML for small, simple projects.