Overriding std::fstream << and >> operators

Hi
I've overriden the << and >> operators to write data in binary format (instead of text). The function seem to work ok but I'd like to know if they are sufficient and whether they be improved upon. So here they are. Tthey are members of a class called BinStream that inherits from std::fstream.

Code:

---

    template <typename T> BinStream& operator << (const T& input)
    {
        T&& temp= std::move(input);
        this->write(reinterpret_cast<char*>(&temp), sizeof(T));
        return *this;
    }

    template <typename T> BinStream& operator >> (T& input)
    {
        this->read(reinterpret_cast<char*>(&input), sizeof(T));
        return *this;
    }

---

Well to be honest I am quite skeptical about your code. You could just use the operator<< and operator>> on the class data in your overloaded operators.

I don't get what you mean actually, could you give an example? Sure it works with class data and it's also handy for writing entire structs from memory to a file.

Well, not a text file.

But anyway, the only other thing you have to worry about when making a binary file is endianness, especially if you're going to share data between machines. This makes code more involved since you may have to rearrange data.

Thanks, yes you are right about the endianness and the fact that it's not appropriate for text files. But no problem, I wrote this specifically for a binary file format which uses little endian(just like my PC. So there was no need to rearrange). Ok since there is nothing to report on syntax I'll assume that part is alright. :)

whiteflags point is that your code is not portable. There are real-world machines that are not little endian. Your file format is therefore machine dependent.

More significantly, the output is also highly compiler dependent, for reasons other than endianness. If your type T is a struct or class, the layout in memory (e.g. padding between members) varies between compilers. If any members of that struct/class are a pointer (or reference), then your code will output the pointer (or reference), not the data pointed at. Similarly, if your type T is a class with virtual member functions. That means, if you write your file, and the code reading it was built with a different compiler, the reading program will malfunction.

If you want to have a useful binary file format, it is a good idea to ensure your file format avoids machine dependence and avoids compiler dependence. You have done neither.

By convention, the streaming operators are used for formatted text I/O anyway. If you want a fstream that supports binary I/O, it is conventional to override or overload read() and write functions().

And don't get me started on using std::move() on a const object.

Quote:

---

Originally Posted by grumpy

And don't get me started on using std::move() on a const object.

---

What is the problem (as long as temp isn't returned) ?
(..though I don't know what the logic behind doing it just for a cast statement is ..)

The problem is the same as casting away constness. It's just wrong and can lead to strange behavior.
write shouldn't modify its argument, so taking const is fine. Otherwise, if you really want an r-value reference, then just declare it so!