写入二进制文件时如何跳过结构[c ++]

Question

I have a structure :

struct Ticket
{
    bool IsReserved; // Is the seat resereved (true)
    time_t SoldOn; //When has the ticket been bought
    double Price; // Price of the ticket
    Ticket() {  IsReserved = 0; Price = 0; SoldOn = 0; }
};

I have already saved it as many times as I needed in a binary file and I read it correctly. My question is when how can I modify only 1 structure when the user wants to buy a ticket. For example when he wants to buy the 5th seat he should go to the 5th structure and change only that data. Here is how I try to do it.

std::cout<<"\nPlease enter how many tickets would you like to purchase : \n";
do
{   
    if(number<0 || number > freeSeats)
        std::cerr<<"Invalid input.try again: \n";
    std::cin>>number;

}while(number<0 || number > freeSeats);

int *t = new int[number];

for(int i = 0; i<number; i++)
{
    int seat = 0;

    do
    {

        std::cout<<"Please enter seat "<<i<<" : ";
        std::cin>>seat;

        file.clear();
        file.seekg(0,std::ios::beg);
        for(int i =1; i <= seat; i++)
        {
            serializeTickets(file,ticket);
        }
        if(ticket.IsReserved == 1)
            std::cout<<"The ticket has already been reserved\n";
    }while(ticket.IsReserved == 1);

    t[i] = seat;
}

file.close();

schedule.serializeTargetLine(choice);
std::ofstream myFile(ticketsFileName,std::ios::binary || std::ios::out);

for(int i = 0; i<number; i++)
{
    time_t timer(0);
    std::time(&timer);

    myFile.seekp(+(t[i] - 1)*sizeof(Ticket),std::ios::beg);

    ticket.IsReserved=1;
    ticket.Price = atof(schedule.getPrice().c_str());
    ticket.SoldOn = timer;

    myFile.write(reinterpret_cast<char*> (&ticket),sizeof(Ticket));
}

delete[] t;
myFile.close();

Answer 1

When writing the file, I would probably use the following before writing struct data to a file.

#pragma pack(1)

After that, it's just a matter of using sizeof(ticket) * seat as the seek offset from the beginning of the file.

file.seekg((sizeof(ticket) * seat), std::ios::beg);

Answer 2

If you're compiling with GCC, I encourage you to add -Wall to your compiler flags to get the maximum compiler assistance.

The problem appears to be that you are not opening the file for writing:

std::ofstream myFile(ticketsFileName,std::ios::binary || std::ios::out);

when you probably mean't

std::ios::binary | std::ios::out

or (std::ios::binary | std::ios::out)

If you turn on full compiler warnings, it would tell you that you have a boolean operation where you probably mean't to have a logical.

and, yes, you probably should use pragma pack around the structure . See http://msdn.microsoft.com/en-us/library/ms253935(v=vs.80).aspx and https://stackoverflow.com/a/9852860/257645

Note, unless you are targetting older compilers, you can do this as:

#pragma pack(push, 1)
struct ... {
    ...
};
#pragma pack(pop)

(Short version: This tells the compiler to use an in-memory representation of the structure that may be less run-time performant but will create a less environment-dependent footprint for storage like this)

Answer 3

This looks like it might be a job for a real database, which will have all these fiddly details already figured out for you (but which will of course have other fiddly details).

That said, your code looks at first glance like it should work (aside from the | vs || issue pointed out by kfsone). If you'll allow me to nitpick a bit:

• std::vector should be preferred over array-new, as it encapsulates the most error-prone pieces.
• Blitting the Ticket struct directly to/from a fiie is technically a violation of the Standard, since it has a constructor.
• You might want to consider using a std::fstream opened for both reading and writing instead of opening the same file twice.
• Many things can go wrong while reading and writing files. Your code should handle those things gracefully. For instance,
  • read() and write() are allowed to read/write fewer bytes than you specify
  • if a seek goes past the end of the file, it may fail.