What is the best/most elegant way to write a struct contiguously to a file in C++?

I'm trying to write image data to a BMP file. I found this website which proposes the following struct for the file header:

typedef struct {             // Total: 54 bytes
  uint16_t  type;             // Magic identifier: 0x4d42
  uint32_t  size;             // File size in bytes
  uint16_t  reserved1;        // Not used
  uint16_t  reserved2;        // Not used
  uint32_t  offset;           // Offset to image data in bytes from beginning of file (54 bytes)
  uint32_t  dib_header_size;  // DIB Header size in bytes (40 bytes)
  int32_t   width_px;         // Width of the image
  int32_t   height_px;        // Height of image
  uint16_t  num_planes;       // Number of color planes
  uint16_t  bits_per_pixel;   // Bits per pixel
  uint32_t  compression;      // Compression type
  uint32_t  image_size_bytes; // Image size in bytes
  int32_t   x_resolution_ppm; // Pixels per meter
  int32_t   y_resolution_ppm; // Pixels per meter
  uint32_t  num_colors;       // Number of colors  
  uint32_t  important_colors; // Important colors 
} BMPHeader;

I know that C/C++ does not guarantee that the data from a struct will be stored contiguously, So simply writing the header struct to the file like so:

BMPHeader header(width, height, bytespp, fileSize);
int num_read = fwrite(&header, BMP_HEADER_SIZE, 1, fp);

or so:

BMPHeader* header = new BMPHeader(width, height, bytespp, fileSize);
int num_read = fwrite(header, BMP_HEADER_SIZE, 1, fp);

using the following constructor (this is probably unnecessary information, but including it incase it might be useful):

BMPHeader(
		unsigned int width, unsigned int height, unsigned short bytespp, unsigned int fileSize) : 
		type(MAGIC_VALUE), size(fileSize),
		reserved1(RESERVED), reserved2(RESERVED), offset(BMP_HEADER_SIZE), 
		dib_header_size(40), width_px(width), height_px(height), num_planes(NUM_PLANE),
		bits_per_pixel(bytespp*BITS_PER_BYTE), compression(COMPRESSION),
		image_size_bytes(width * height * bytespp), x_resolution_ppm(0x00),
		y_resolution_ppm(0x00), num_colors(0x00), important_colors(IMPORTANT_COLORS)
	{
	}

won't work since there is no guarantee that the variables will be stored in the order that they are written, nor is there a guarantee that there won't be padding between the variables.

Regardless, I tried it anyways and, unsurprisingly, it didn't work.

My question is this: Is there any way to write the data to a file in a more elegant way than having to individually write each member variable to the file in the order that I want?

I tried instantiating the struct both onto the heap as a BMPHeader*, as well as on the stack.

I also tried using a union like so:

struct BMPHeader
{
	union
	{
		struct
		{
			unsigned short type;							// Magic identifier: 0x4d42
			unsigned int size;							// File size in bytes
			unsigned short reserved1;				// Not used
			unsigned short reserved2;				// Not used
			unsigned int offset;						// Offset to image data in bytes from beginning of file (54 bytes)
			unsigned int dib_header_size;	// DIB Header size in bytes (40 bytes)
			unsigned int width_px;					// Width of the image
			unsigned int height_px;				// Height of image
			unsigned short num_planes;				// Number of color planes
			unsigned short bits_per_pixel;		// Bits per pixel
			unsigned int compression;			// Compression type
			unsigned int image_size_bytes; // Image size in bytes
			unsigned int x_resolution_ppm; // Pixels per meter
			unsigned int y_resolution_ppm; // Pixels per meter
			unsigned int num_colors;				// Number of colors
			unsigned int important_colors; // Important colors
		};
		unsigned char raw[54];
	};

to see if I could write the array to the file, but I ran into the same issue.

Microsoft kept using this structure for years and a single write to a file works with the standard settings of struct types in Visual Studio.

But there is a nasty trap:

#pragma pack(push,2)
	typedef struct tagBITMAPFILEHEADER
	{
		WORD bfType;
		DWORD bfSize;
		WORD bfReserved1;
		WORD bfReserved2;
		DWORD bfOffBits;
	} BITMAPFILEHEADER;
#pragma pack(pop)

must be enforced to guarantee that the fields bfType and bfReserved1/2 are stored on two bytes.

By contrast, the BITMAPINFOHEADER (and later variants) does not use this setting.

As Yksisarvinen and n. m. will see y'all on Reddit mentioned in the comments above, I didn't include the pragma pack directive.

Here is the change that fixed it:

#pragma pack(push, 1)
struct BMPHeader
{
	uint16_t type;							// Magic identifier: 0x4d42
	uint32_t size;							// File size in bytes
	uint16_t reserved1;				// Not used
	uint16_t reserved2;				// Not used
	uint32_t offset;						// Offset to image data in bytes from beginning of file (54 bytes)
	uint32_t dib_header_size;	// DIB Header size in bytes (40 bytes)
	uint32_t width_px;					// Width of the image
	uint32_t height_px;				// Height of image
	uint16_t num_planes;				// Number of color planes
	uint16_t bits_per_pixel;		// Bits per pixel
	uint32_t compression;			// Compression type
	uint32_t image_size_bytes; // Image size in bytes
	uint32_t x_resolution_ppm; // Pixels per meter
	uint32_t y_resolution_ppm; // Pixels per meter
	uint32_t num_colors;				// Number of colors
	uint32_t important_colors; // Important colors

	BMPHeader(
		unsigned int width, unsigned int height, unsigned short bytespp, unsigned int fileSize) : 
		type(MAGIC_VALUE), size(fileSize),
		reserved1(RESERVED), reserved2(RESERVED), offset(BMP_HEADER_SIZE), 
		dib_header_size(40), width_px(width), height_px(height), num_planes(NUM_PLANE),
		bits_per_pixel(bytespp*BITS_PER_BYTE), compression(COMPRESSION),
		image_size_bytes(width * height * bytespp), x_resolution_ppm(0x00),
		y_resolution_ppm(0x00), num_colors(0x00), important_colors(IMPORTANT_COLORS)
	{
	}
};
#pragma pack(pop)

Thanks all!

IMHO, the most elegant method is to copy the methods into a buffer. This allows you to controls the spacing (if any) and also Endianness:

struct BMPHeader
{ // Total: 54 bytes
  uint16_t  type;             // Magic identifier: 0x4d42
  uint32_t  size;             // File size in bytes
  uint16_t  reserved1;        // Not used
  uint16_t  reserved2;        // Not used
  uint32_t  offset;           // Offset to image data in bytes from beginning of file (54 bytes)
  uint32_t  dib_header_size;  // DIB Header size in bytes (40 bytes)
  //...
  void write_to_buffer(uint8_t *& p_buffer) const;
};

void BMPHeader::write_to_buffer(uint8_t *& p_buffer) const
{
    *p_buffer = (uint8_t *) &type;
    p_buffer += sizeof(type);

    *p_buffer = (uint8_t *) &size;
    p_buffer += sizeof(size);
    //...
}

You can then use it with block writing:

uint8_t  buffer[54];
BMPHeader header;
//...
char * p_buffer = &buffer[0];
header.write_to_buffer(p_buffer);
destination_file.write(buffer, sizeof(buffer));

Similarly, write a method to read the members from a buffer. The read works really nice for non-POD members, such as strings.

An accompanying method size_in_buffer() would return the accumulative size that each member would occupy in the buffer. This is great when allocating a dynamic array (buffer) to hold the data.

The efficiency is based on the rational that writing to memory is faster than writing to a file. Also, block writing to a file is faster and more efficient than many small writes for each member separately. A stream is most efficient when it is kept running.

Also, search the internet for "C++ serialization".

Note: This version does not require any compiler directives and should work on all platforms that support files.