Thread: ifstream file I/O and strings or structs

Hello,
I am looking for an efficient C++ technique for writing a data structure to a file and retrieving it later. To write the file, I've been doing the awkward thing of copying all my integer variables of the displayPacket class into a string class and writing it out to an ostream class with <<. For the input, I am using ifstream, but the compiler won't accept any data types besides the most basic (integer, etc).

Any suggestions?
Frank

Code:

	if(strcmp( (char *)myString, "save")==0)
	{
		ofstream myFile("filename.dat" );

		myFile<< displayPacket.params;
		myFile<< displayPacket.payload;

		myFile.close();
	}


	if(strcmp( (char *)myString, "open")==0)
	{
		ifstream myFile("filename.dat" );

		myFile >> displayPacket.params; /*compile error: the stream does not like the string class*/
		myFile >> displayPacket.payload; /*compile error: the stream does not like the string class*/

	       myFile >> i;	/*Works for integer i*/

		myFile.close;

Post some types with that lot, like how you declared various things.

> strcmp( (char *)myString, "save")==0
If you need a cast to make strcmp work, then you've done the wrong thing.
If myString is a std::string type, then myString == "save" will do just fine.

Code:

if(strcmp( (char *)myString, "open")==0)

If you have to cast myString to get that to compile, you have a problem. BTW, strcmp is in <cstring>.

This isn't HTML, it's BBCode. [code] instead of <code>, and [/code] instead of </code>.

In other words, how to input a data structure from an ifstream.

You need to read in each member of the structure individually. A function is good for this (or a member function if the structure is in fact a class).

Also, should I just work with fstream instrad of ifstream?

No, since you'll never need to use output on the stream.

>Now, if I would like to not use at all any pass by references as a prevention for all my programs.
Eh? Can you explain this in more detail?

>where my displayPacket is my own packet class and the params is a string class
Don't do that. Ever. You can't use istream::read or ostream::write on a non-trivial class. Those member functions pun the argument into an array of unsigned char and write it directly to a binary oriented file. However, non-trivial (ie. non-POD) classes can't portably be punned into an array of unsigned char. So at best trying to do it is non-portable, and at worst it's undefined behavior.

What you want to do is provide a serialize and unserialize member function in your packet class that can turn the packets into strings which can then be safely written:

Code:

#include <cstdio>
#include <cstring>
#include <fstream>
#include <iostream>

class Packet {
public:
    enum { PACK_SIZE = 10 };

    Packet(): thing_ ( 0 ) {}
    Packet ( int init ): thing_ ( init ) {}

    const char *Pack()
    {
        std::memset ( packed, '\0', PACK_SIZE );
        std::sprintf ( packed, "%d", thing_ );

        return packed;
    }

    const Packet& Unpack ( const char *p )
    {
        std::sscanf ( p, "%d", &thing_ );

        return *this;
    }

    friend std::ostream& operator<< ( std::ostream& out, const Packet& packet )
    {
        return out<< packet.thing_;
    }
private:
    int thing_;
    char packed[PACK_SIZE];
};

int main()
{
    std::ofstream out ( "test.dat", std::ios::binary );

    if ( out ) {
        for ( int i = 0; i < 10; i++ )
            out.write ( Packet ( i ).Pack(), Packet::PACK_SIZE );

        out.close();
    }

    std::ifstream in ( "test.dat", std::ios::binary );

    if ( in ) {
        Packet packet;
        char buf[Packet::PACK_SIZE];

        while ( in.read ( buf, Packet::PACK_SIZE ) )
            std::cout<< packet.Unpack ( buf ) <<'\n';
    }
}

>Isn't there a way to do myFile >> packet?
Yes, just overload the operator>> for your class, much like I've overloaded operator<< in the code above.

Originally Posted by Prelude

>where my displayPacket is my own packet class and the params is a string class
Don't do that. Ever. You can't use istream::read or ostream::write on a non-trivial class. Those member functions pun the argument into an array of unsigned char and write it directly to a binary oriented file. However, non-trivial (ie. non-POD) classes can't portably be punned into an array of unsigned char. So at best trying to do it is non-portable, and at worst it's undefined behavior.

Well, I do know that you can only use it on very limited classes (things that I would normally use structs for) but I do think it has a very useful purpose, when reading and writing binary records, where you know the size and contents of each field is fixed.

But writing an object to a file that has pointers etc inside it is a bad idea, because when the object is restored those pointers will be pointing in vacuo.

Originally Posted by dwks

But writing an object to a file that has pointers etc inside it is a bad idea, because when the object is restored those pointers will be pointing in vacuo.

Oh, absolutely.

>where you know the size and contents of each field is fixed
As long as the type has binary compatibility with C, you're fine. In other words, just about any useful class doesn't meet the requirements. Off the top of my head, an object of non-POD type cannot have:

1) Any of the big three beyond the defaults (constructor, destructor, assignment operator)
2) Private or protected members
3) Reference members
4) Non-POD members
5) Virtual functions
6) Base classes

This has more to do than just the risk of shallow copying pointers.