C++ Writing Object to Binary File

Question

Problem:

Error: The "&" operator can only be applied to a variable or other l-value.

What I've tried:

dynamic_cast<char*>(e)
reinterpret_cast<char*>(e)
static_cast<char*>(e)
(char*) e

What I'm trying to do:

Write the array e.data (private) to a binary file.

Notes:

e.getSize() returns number of elements in array
e[] returns Employee object.

Code:

fstream fout;
fout.open(filename.c_str(), ios::out|ios::binary);
if(fout.good())
{
    for(int i=0;i<e.getSize();i++)
    {
        fout.write((char*)&e[i], sizeof(e[i]));
    }
}
fout.close();

Employee.h

class Employee {
    friend std::ostream& operator<<(std::ostream&, const Employee &);
    private:
        int id;
        char name[50];
        char address[100];
        char phone[20];
        char department[100];
        int salary;
    public:
        Employee();
        ~Employee();
        Employee(int,char[],char[],char[],char[],int);
        bool operator==(Employee&);
};

I'm lost at what to do, from what I remember fout.write((char*)&e[i], sizeof(e[i])); is how to write to binary files.

Edit: e is declared like so: MYLIB::Bucket<Employee> e;

template <class T>
class Bucket {
    private:
        T* bkt;
        int size;
        int capacity;
        static const int stepsize = 10;

    public:
        Bucket();
        ~Bucket();

        void push_back(const T&);
        T operator[](int);
        int getSize();
        int getCapacity();
};

Edit 2: fout.write(reinterpret_cast<char*>(e[i]), sizeof(e[i])); gives me line 122: Error: Using reinterpret_cast to convert from ? to char* not allowed. (Line 122 is the line just quoted)

Edit 3:

tempemp = e[i];
fout.write((char*)(&tempemp), sizeof(e[i]));

~~Compiles but gives a segmentation fault, I'll investigate why.~~ Compiles, the segmentation fault looks unrelated.

Somewhat related: I would advise against writing a binary file based on a platform-specific packing of a structure like that. — WhozCraig, Nov 01 '13 at 08:32
Added declaration of e. The choice of binary file is not my own, it's part of an exercise. — John Smith, Nov 01 '13 at 08:35
Isn't T operator[](int); returning a temporary object that has to be assigned to something before it has an address? T& operator[](int); might be better — David Sykes, Nov 01 '13 at 08:39
I don't suppose those Bucket objects are *ever* copied around (even implicitly in ways you may not think about, such as a by-val parameter to a function, etc.) ?? If so, you have a basic nightmare ala-RuleOfThree violation in your code. — WhozCraig, Nov 01 '13 at 08:49
@JohnSmith I've a reasonable suspicion you're about to find out the hard way. Hit up Wiki with [`"C++ Rule of Three"`](http://en.wikipedia.org/wiki/Rule_of_three_(C++_programming)). — WhozCraig, Nov 01 '13 at 08:57
https://en.wikipedia.org/wiki/Rule_of_three_(C%2B%2B_programming) I think the point is that if you need the == operator you should also have a copy constructor — David Sykes, Nov 01 '13 at 08:57

score 4 · Answer 1 · answered Nov 01 '13 at 08:54

 MYLIB::Bucket<Employee> e;

this seems to be a container. e[i] gives you an Employee by value. you need to get this object's address using &e[i] but you can'd do that since it's an r-value so you need to copy it to a non r-value:

Employee copye = e[i];
fout.write((char*)&copye, sizeof(e[i]));

Should work.

On a side note, this all looks like terrible code and I don't envy whoever needs to maintain or read it. A few points:

you should not be using the binary format of the in-memory object as your serialization format. Use a proper serialization format like protobuf or xml or json
Why pull your own strange containers when you can use std::vector std::list ? re-inventing the wheel is always bad
returning an element by value from a container creates copies which degrade performance.

score 2 · Accepted Answer · edited May 23 '17 at 12:03

2

I think that

T operator[](int);

is returning a temporary object that must be bound to something before an address can be taken

const Employee& emp = e[i];
fout.write((char*)&emp, sizeof(emp));

might work, assuming this answer is correct that taking a reference extends the life of a temporary object

An alternative might be to return a reference to the object, which would remove the creation of temporary objects

const T& operator[](int);

edited May 23 '17 at 12:03

Community

1
1

answered Nov 01 '13 at 08:52

David Sykes

48,469
17
71
80

Error: Initializing Employee& requires an lvalue. – John Smith Nov 01 '13 at 08:56
I'll give the second idea a go. – John Smith Nov 01 '13 at 08:56

C++ Writing Object to Binary File

2 Answers2