Бинарный файловый ввод/вывод: реализовать операции для работы с массивом структур типа WORKER

ofstream myfile;
myfile.open ("example.bin", ios::out ios::binary);

#include <iostream>
#include <fstream>
 
using namespace std;
 
class fff
{
public:
    fff(int o, int p, int l);
 
private:
    int qwe;
    int rty;
    int uiop;
};
 
fff::fff(int o, int p, int l)
{
    qwe = o;
    rty = p;
    uiop = l;
}
 
bool writetofile(ostream &os, fff &clss)
{
    unsigned char *b = (unsigned char*)&clss;
    unsigned char *e = b + sizeof(clss);
    int s = sizeof(clss); 
 
    for (int i = 0; i < s; ++i, ++b)
    {
        os.put(*b);
    }
    return true;
}
 
 
void main()
{
    setlocale(LC_ALL, "rus");
 
    ofstream myfile;
    myfile.open("example.bin", ios::out | ios::binary);
 
    fff classok(100, 11, 10100000);
 
    writetofile(myfile, classok);
}

#include <iostream>
#include <fstream>
 
using namespace std;
 
class SomeClass
{
public:
    SomeClass();
    SomeClass(int first, char second, double third);
    void print();
private:
    int m_first;
    char m_second;
    double m_third;
};
 
SomeClass::SomeClass(int first, char second, double third)
{
    m_first = first;
    m_second = second;
    m_third = third;
}
 
void SomeClass::print()
{
    cout << endl;
    cout << "m_first = " << m_first << endl;
    cout << "m_second = " << m_second<<endl;
    cout << "m_third = " << m_third << endl;
}
 
SomeClass::SomeClass()
{
    m_first = 0;
    m_second = '0';
    m_third = 0.00;
}
 
void writeToFile(fstream &os, SomeClass &in)
{
    unsigned char *filePointer = (unsigned char*)&in;
 
    int fileSize = sizeof(in); 
 
    for (int i = 0; i < fileSize; ++i, ++filePointer)
        os.put(*filePointer);
}
 
void readFile(fstream &is, SomeClass &out)
{
    unsigned char *b = (unsigned char*)&out;
 
    int s = sizeof(out);
 
    for (int i = 0; i < sizeof(out); ++i)
    {
        char temp;
        is.get(temp);
        *(b + i) = temp;
    }
}
 
void main()
{
    setlocale(LC_ALL, "rus");
 
    fstream myfileForWrite;
    myfileForWrite.open("example.bin", ios::out | ios::binary);
 
    
    SomeClass firstObject(101111, 'm', 100.976);
    firstObject.print();
    writeToFile(myfileForWrite, firstObject);
    myfileForWrite.close();
 
    fstream myfileForRead;
    myfileForRead.open("example.bin", ios::in | ios::binary);
    SomeClass secondObject;
 
    secondObject.print();
 
    readFile(myfileForRead, secondObject);
    secondObject.print();
 
    system("pause>>VOID");
}

// binary.cpp -- binary file I/O
#include <iostream> // not required by most systems
#include <fstream>
#include <iomanip>
#include <cstdlib>  // (or stdlib.h) for exit()
 
inline void eatline() { while (std::cin.get() != '\n') continue; }
struct planet
{
    char name[20];      // name of planet
    double population;  // its population
    double g;           // its acceleration of gravity
};
 
const char * file = "planets.dat";
 
int main()
{
    using namespace std;
    planet pl;
    cout << fixed << right;
 
// show initial contents
    ifstream fin;
    fin.open(file, ios_base::in |ios_base::binary);  // binary file
    //NOTE: some systems don't accept the ios_base::binary mode
    if (fin.is_open())
    {
    cout << "Here are the current contents of the "
        << file << " file:\n";
    while (fin.read((char *) &pl, sizeof pl))
    {
        cout << setw(20) << pl.name << ": "
              << setprecision(0) << setw(12) << pl.population
              << setprecision(2) << setw(6) << pl.g << endl;
    }    
    fin.close();
    }
 
// add new data
    ofstream fout(file, 
             ios_base::out | ios_base::app | ios_base::binary);
    //NOTE: some systems don't accept the ios::binary mode
    if (!fout.is_open())
    {
        cerr << "Can't open " << file << " file for output:\n";
        exit(EXIT_FAILURE);
    }
 
    cout << "Enter planet name (enter a blank line to quit):\n";
    cin.get(pl.name, 20);
    while (pl.name[0] != '\0')
    {
        eatline();
        cout << "Enter planetary population: ";
        cin >> pl.population;
        cout << "Enter planet's acceleration of gravity: ";
        cin >> pl.g;
        eatline();
        fout.write((char *) &pl, sizeof pl);
        cout << "Enter planet name (enter a blank line "
                "to quit):\n";
        cin.get(pl.name, 20);
    }
    fout.close();
 
// show revised file
    fin.clear();    // not required for some implementations, but won't hurt
    fin.open(file, ios_base::in | ios_base::binary);
    if (fin.is_open())
    {
        cout << "Here are the new contents of the "
             << file << " file:\n";
        while (fin.read((char *) &pl, sizeof pl))
        {
            cout << setw(20) << pl.name << ": "
                 << setprecision(0) << setw(12) << pl.population
                 << setprecision(2) << setw(6) << pl.g << endl;
        }
        fin.close();
    }
    cout << "Done.\n";
// keeping output window open
    // cin.clear();
    // eatline();
    // cin.get();
    return 0; 
}

template<typename SomeValueType>
void writeToFile(fstream &os, SomeValueType *in, int objectCount)
{
    unsigned char *ObjectPointer = (unsigned char*)in;
 
    int objectSize = sizeof(*in);
 
    int byteForWrite = objectSize * objectCount;
 
        for (int i = 0; i < byteForWrite; ++i, ++ObjectPointer)
            os.put(*ObjectPointer);
}
 
template<typename SomeValueType>
void readFile(fstream &is, SomeValueType *out, int bufferSize)
{
 
    is.seekg(0, is.end);
    unsigned int FileLength = is.tellg();
    is.seekg(0, is.beg);
 
    int objectSize = sizeof(*out);
 
    if (FileLength % objectSize != 0 || FileLength == 0 || bufferSize < FileLength / objectSize)
        return;
 
    int objectCount = (FileLength / objectSize);
 
    int ByteForRead = objectCount * objectSize;
 
    unsigned char *ObjectPointer = (unsigned char*)out;
 
    for (int i = 0; i < ByteForRead; ++i)
    {
        char temp;
        is.get(temp);
        *(ObjectPointer + i) = temp;
    }
 
    bufferSize = objectCount;
}