Access violation writing location during ifstream read - c++

Question

So I'm making basic CRUD
create work fine
but when the code reach file.read(code)
VS display Read Access Violation
When I try to run each line 1 by 1 in read function there's no error until I reach file.read
I'm not able to figure out the causes
I suspect the problem is in here:
Mahasiswa read(fstream &file, int pos) {
Mahasiswa result;
file.open("data.bin", ios::in | ios::binary);
file.seekp(pos * sizeof(Mahasiswa));
file.read(reinterpret_cast<char*>(&result), sizeof(Mahasiswa));
file.close();
return result;
}
This is the entire code:
#include <fstream>
#include <iostream>
#include <string>
using namespace std;
struct Mahasiswa {
int no;
int pk;
string nim;
string nama;
string jurusan;
};
void create(fstream &file, int no, int pk, string nim, string nama, string jurusan) {
file.open("data.bin", ios::app | ios::out | ios::binary);
Mahasiswa mhs;
mhs.no = no;
mhs.pk = pk;
mhs.nim = nim;
mhs.nama = nama;
mhs.jurusan = jurusan;
file.write(reinterpret_cast<char*>(&mhs), sizeof(Mahasiswa));
file.close();
}
Mahasiswa read(fstream &file, int pos) {
Mahasiswa result;
file.open("data.bin", ios::in | ios::binary);
file.seekp(pos * sizeof(Mahasiswa));
file.read(reinterpret_cast<char*>(&result), sizeof(Mahasiswa));
file.close();
return result;
}
int main()
{
fstream file;
create(file, 1, 12, "0123", "Person", "TIK");
Mahasiswa til = read(file, 0);
cout << til.nama;
}
source code from the YouTuber:
Apparently this code works:
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
struct Mahasiswa {
int NIM;
string nama;
string jurusan;
};
Mahasiswa ambilData(int posisi, fstream& myFile) {
Mahasiswa bufferData;
myFile.seekp((posisi - 1) * sizeof(Mahasiswa));
myFile.read(reinterpret_cast<char*>(&bufferData), sizeof(Mahasiswa));
return bufferData;
}
void menulisData(Mahasiswa& data, fstream& myFile) {
myFile.write(reinterpret_cast<char*>(&data), sizeof(Mahasiswa));
}
void menulisDataByPos(int posisi, Mahasiswa& bufferData, fstream& myFile) {
myFile.seekg((posisi - 1) * sizeof(Mahasiswa));
myFile.write(reinterpret_cast<char*>(&bufferData), sizeof(Mahasiswa));
}
int main() {
fstream myFile;
myFile.open("data.bin", ios::trunc | ios::out | ios::in | ios::binary);
Mahasiswa mahasiswa1, mahasiswa2, mahasiswa3, output;
mahasiswa1.NIM = 123;
mahasiswa1.nama = "ucup";
mahasiswa1.jurusan = "memasak";
mahasiswa2.NIM = 124;
mahasiswa2.nama = "otong";
mahasiswa2.jurusan = "menjahit";
mahasiswa3.NIM = 125;
mahasiswa3.nama = "sandra";
mahasiswa3.jurusan = "mesin";
menulisData(mahasiswa1, myFile);
menulisData(mahasiswa2, myFile);
menulisData(mahasiswa3, myFile);
mahasiswa2.nama = "mario";
menulisDataByPos(2, mahasiswa2, myFile);
output = ambilData(2, myFile);
cout << output.NIM << endl;
cout << output.nama << endl;
cout << output.jurusan << endl;
myFile.close();
cin.get();
return 0;
}

Answer 1

From language lawyer's point of view an UB happens here:
file.write(reinterpret_cast<char*>(&mhs), sizeof(Mahasiswa));
and here:
file.read(reinterpret_cast<char*>(&result), sizeof(Mahasiswa));
What happens here is an equivalent of memcpy. memcpy is an equivalent of shallow copy, but can be used only on so-called "POD" types, which are:
a) trivially constructible - no user-defined default constructor;
b) trivially copyable - no user-defined copy constructor or operator;
c) standard memory layout - no virtual inheritance, virtual members, const non-static members, etc.
std::string isn't a aggregate and isn't a POD, it stores a pointer to separate memory storage where actually string data resides, so it cannot be shallow copied and got special members defined to manage that. As those are members, i.e. subobjects of Mahasiswa, Mahasiswa cannot be copied that way either. Rare case when std::string can be memcpy-ed is when it uses short string optimization, which is hard to predict in portable way.

Answer 2

I finally found an answer to this question.
I just need to close and reopen the stream
Here is the explanation why I do this
https://stackoverflow.com/a/32056770/14882773
though it still has an Access violation error at least it has output as expected
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
struct pelajar {
string NIM;
int num;
};
int main()
{
fstream data;
pelajar lopzx = {"123",1};
data.open("data.bin", ios::binary | ios::in | ios::out);
pelajar man;
data.write(reinterpret_cast<char*>(&lopzx), sizeof(pelajar));
data.close(); //close data
data.open("data.bin", ios::binary | ios::in | ios::out); //re-open data
data.read(reinterpret_cast<char*>(&man), sizeof(pelajar)); //then read
std::cout << man.NIM << man.num;
data.close();
}
But if we change struct NIM to a char array, close, then reopen there will be no error anymore
pelajar {
char NIM[50];
int num;
};
and give it a value like this:
pelajar lopzx = {"123",1};
Note :
Somehow outside of lopzx curly braces
lopzx.NIM = "val"; doesn't work.
and there are probably cons to this method that I'm not aware of.