How to read a binary file to a class array in C++?

Ok, this post is gonna be big, but I hope I'll address at least all the major issues.

First: You should't write the whole class to a file and expect it to work, this is usually ok with POD types but not with C++ classes.

Second: The read function receives a pointer by value, and then leaks the memory that was allocated.

Now, let's start with the read function:

clientData_SIZE = static_cast<int>(inClients.tellg());

This is cleary going to return zero, because you are at the beginning of the file. You need to seek to the end of the file and only then get the pointer's position (see example at the end of the post).

This code:

inClients.read((char *)(&client_block[i]), sizeof(ClientData));

Don't expect it to work, even if you get right the size of the file and the number of iterations. Classes are not POD types, they have constructors, destructors, methods, possibly a vtable. Stuff that cannot be memcpy'ed.

Now with the write function:

int clientData_SIZE = outClients.tellp();

This is going to be the number of bytes in the file, not the number of clients! If you want the number of clients you should divide by sizeof(ClientData)) but, as I said before, it is not advisable to write the class to the file.

And now comes the concept of serialization: Serialization allows to transfer data from one point to the other as it was a simple copy. You need to write code to support that.

You could implement the functions write(ostream&) and read(istream&) or overload the stream operator:

class ClientData {
    
    // ...
    
    friend ostream& operator<<(ostream &out, const ClientData &c);
    friend istream& operator>>(istream &in,  ClientData &c);
};

// ok this is a hack, but it works as an example
#define CLIENT_DATA_SIZE (32+32+32+4)

ostream& operator<<(ostream& os, const ClientData& cd) {
    os.write(cd.user, sizeof(user));
    os.write(cd.pass, sizeof(pass));
    os.write(cd.mail, sizeof(mail));
    os.write(&cd.id, sizeof(id))
    return os;
}

istream& operator>>(istream &in, ClientData &cd) {
    in.read(cd.user, sizeof(user));
    in.read(cd.pass, sizeof(pass));
    in.read(cd.mail, sizeof(mail));
    in.read(&cd.id, sizeof(id));
    return in;
}

Then the read function should look like this:

// note this changed to pointer to pointer (you can also pass the pointer by reference)
int ClientData::readClientDat(ClientData **client_block)
{
    int clientData_SIZE;

    ifstream inClients;
    inClients.open("D:\\Programming\\Qt\\bookstore instances\\bookstore_system\\data\\clients.dat", ios::binary);
    if (inClients.is_open())
    {
        inClients.seek(0, inClients.end);
        clientData_SIZE = static_cast<int>(inClients.tellg()) / CLIENT_DATA_SIZE;

        // dont forget to relese the pointer (with delete[]) when finished
        client_block = new ClientData [clientData_SIZE];

        for(int i = 0; i <clientData_SIZE; i++)
        {
            clientData_SIZE >> client_block[i];
        }
        inClients.close();
    }
    return clientData_SIZE;
}

And the write function:

void ClientData::insertNewClient(ClientData newUser)
{
    ofstream outClients;
    outClients.open("D:\\Programming\\Qt\\bookstore instances\\bookstore_system\\data\\clients.dat", ios::binary | ios::app);  // write the new client's data in the database.
    int clientData_SIZE = outClients.tellp() / CLIENT_DATA_SIZE;
    newUser.id = (clientData_SIZE) + 1;
    
    outClientes << newUser;

    outClients.close(); //-----------------------------------------closes file.
}

Note that I am no checkings for errors, you may want to check whether read, writes and open return ok.