So the above section was definitely a mouthful, but it's a very useful thing to know for a class like CS360 (Systems Programming... the crown jewel of the Computer Science major here. You can thank me later).
Let's say that we have a more complex file such as this one with 16 bytes:
File Hex (data3.bin)
FF 22 48 01 43 61 74 01
F0 45 22 02 43 61 74 00
Okay you have no idea what this data is for yet. Let's say we had this struct:
Code (C++)
struct cat_group {
unsigned int num; //Number of cats
char letter[3]; //Letters
char colour; //0 - White, 1 - Black, >=2 - Other
};
...Yes I'm a cat person. Don't judge. Anyways, the size of this struct can be found by adding up the sizes of all of the data types.
Code (C++)
struct cat_group {
unsigned int num; //4
char letter[3]; //1 x 3
char colour; //1
};
//4 + (1 * 3) + 1 = 8
//
We can also just cheat and use
cout << sizeof(cat) << endl;. We will see that it ends up being
8.
Do note though that the size of a struct
must be in multiples of 4.
So if we added another char into it, then the size would become
12 even though it's only allocating 9 bytes.
Read bytes directly into struct
Now let's have some fun. We can load those bytes
directly into the struct with pointers. Let's look at it.
Code (C++)
#include <iostream>
#include <fstream>
using namespace std;
struct cat_group {
unsigned int num; //Number of cats
char letter[3]; //Letters
char colour; //0 - White, 1 - Black, >=2 - Other
};
int main() {
/*
NOTE: our binary file has the following bytes:
0x1A, 0x00, 0x00, 0x00, 0x43, 0x61, 0x74, 0x01
0xF0, 0x45, 0x22, 0x02, 0x43, 0x61, 0x74, 0x00
*/
//Declare our instances of "cat_group" as "group1" and "group2"
cat_group group1, group2;
//Open up our file and read in the bytes... directly into "group1" and "group2".
ifstream fp;
fp.open("data3.bin", ios::binary);
fp.read(reinterpret_cast<char*>(&group1), 8); //Read the first 8 bytes into group1
fp.read(reinterpret_cast<char*>(&group2), 8); //Read the next 8 bytes into group1
fp.close();
//Print out data to verify.
cout << "Group 1 Information" << endl;
cout << "Num : " << group1.num << endl;
cout << "Letters: " << group1.letter[0] << group1.letter[1] << group1.letter[2] << endl;
cout << "Colour : " << (int)group1.colour << endl << endl;
cout << "Group 2 Information" << endl;
cout << "Num : " << group2.num << endl;
cout << "Letters: " << group2.letter[0] << group2.letter[1] << group2.letter[2] << endl;
cout << "Colour : " << (int)group2.colour << endl;
}
Sure enough, the output is:
Output
Group 1 Information
Num : 21504767
Letters: Cat
Colour : 1
Group 2 Information
Num : 35800560
Letters: Cat
Colour : 0
That's a
lot of kitties! Millions of them.
The breakdown
The memory was outlined above. Here it is again, with colour coding:
File Hex (data3.bin)
FF 22 48 01 43 61 74 01
F0 45 22 02 43 61 74 00
Let's look at how the memory of the struct is laid out... colour-coded too:
Code (C++)
struct cat_group {
unsigned int num; //(4 bytes) Number of cats
char letter[3]; //(1 x 3 bytes) Letters
char colour; //(1 byte ) 0 - White, 1 - Black, >=2 - Other
};
We made 2 instances of the "cat_group" struct named "group1" and "group2".
Those are in memory somewhere, and they have an address.
Let's assume (just because we can) that their addresses are 0x42467BC0 and 0x42467BC8 respectively.
So when we call
cat_group group1, group2;, the memory looks like this:
Address Bytes
42467BC0 00 00 00 00 00 00 00 00
42467BC8 00 00 00 00 00 00 00 00
Note: In a realistic matter, the data isn't guaranteed to be all 0's. The kernel just assigns it an address which may have garbage data from previous use at that address. For now though, we will assume they are 0's.
Notice a pattern?
The format of the struct matches the file information we are reading in "exactly".
This is a common trick in C and C++ where we make structs in a very specific way and then just read in everything into the struct as if it was raw bytes.
Hint: This is also why I was telling you to make your Pixel struct's order as "blue", "green", "red". Order matters.
Now, remember what weapons we have.
We can use
reinterpret_cast on a pointer to the struct (
cat_group*) to make it appear as a
char* array.
What's next? Let's just
read all of the bytes directly into the struct's data using its address.
fp.read(reinterpret_cast<char*>(&group1), 8);
Address Bytes
42467BC0 FF 22 48 01 43 61 74 01 <- This has been written to
42467BC8 00 00 00 00 00 00 00 00
At this point in the code, we can try printing out "group1.num", and the value we get will be 21504767, which is 0x014822FF in hex. (Notice it's flipped of
FF 22 48 01?)
Let's execute the second read command.
fp.read(reinterpret_cast<char*>(&group2), 8);
Address Bytes
42467BC0 FF 22 48 01 43 61 74 01
42467BC8 F0 45 22 02 43 61 74 00 <- This has been written to
Now the data has been read in to the second struct as well. Close the file, and print out the information. You'll see it's the output listed above.
