I suspect you're getting to "can't see the wood for the trees" mode. This often happens when you stare at a bug for too long. So for now, completely forget about your code and I'll quickly go through some basics which you probably know but are beginning to get confused about because you've been bashing your head against them so long.
struct SomeStruct{ int memberVariable1; char memberVariable2[15];};This is the definition for a struct. All it does is tell the compiler what that structure looks like. In this case you're telling the compiler: "I have a structure called SomeStruct which I'll be using later. SomeStruct objects consist of an integer and an array of 15 characters".
The size of SomeStruct is the amount of space (in bytes) the compiler would allocate for a single instance of SomeStruct. In this case the size of SomeStruct is 20 bytes. That's 4 for the int, 15 for the character array and an extra 1 to pad it to a multiple of 4 because that's how computers work best.
SomeStruct aStruct;This is the definition for an instance of SomeStruct. Here the compiler actually allocates memory for a SomeStruct. In this case you're telling the compiler: "You know that SomeStruct structure I told you about earlier? Well, I want one of them now called aStruct".
Since the size of SomeStruct is the amount of space (in bytes) the compiler would allocate for a single instance of SomeStruct it follows that the sizeof aStruct (an instance of SomeStruct) is exactly the same.
SomeStruct someStructs[10];This is the definition for an array of SomeStructs. Here the compiler must allocate memory for 10 SomeStructs. In this case you're telling the compiler: "You know that SomeStruct structure I told you about earlier? Well, I want ten of them now in a row".
This is roughtly equivalent to doing:
SomeStruct aStruct1;SomeStruct aStruct2;SomeStruct aStruct3;...SomeStruct aStruct10;Since someStructs contains 10 SomeStruct objects is follows that the size of someStructs is 10 times the size of SomeStruct, so the size of someStructs in this case is 200 bytes.
Now lets apply this to your teachers example:
struct student{char name[25];int grade;}; // definition of the class - takes up no memory, just tells the compiler what a student object will look likeint main(){student s; // definition for a student object. Here the compiler allocates memory for the object - probably 32 bytes with paddingofstream fout;fout.open("test.dat", ios::binary);// code to enter names and grades accordingly;fout.write((char*)&s, sizeof(student)); // write the student object to the file. We have only one student object, which is 32 bytes in size, so we want to write 32 bytes to the file. sizeof(student) gives that 32 bytes. It is exactly the size of the object we are writing. sizeof(s) would also work here since the size of a class is the same as the size of a single instance of that class// more code}Enigma
