Helpers for reading binary file formats in C++.

read-binary-types.cpp

#include <fstream>
#include <iostream>
#include <array>

// creates a new instance of the type
// and reads data into it. Good for single
// value types.
template<typename T>
T STLParser::readBinary(std::ifstream& ifs) {
	T out;
	ifs.read(
		reinterpret_cast<char*>(&out),
		sizeof(T)
	);
	return out;
}

// reads a series of binary values
// into an array with a given type.
// Should be size and type safe.
template<typename T, size_t size>
void readBinaryArray(
	std::ifstream& ifs,
	std::array<T,size>& data
) {
	ifs.read(
		reinterpret_cast<char*>(&data),
		sizeof(T) * size
	);
}

int main() {
	std::string fileName = "sphere.stl";
	
	std::ifstream file { fileName, std::ios::binary };
	if(!file.is_open()) {
		std::cerr << "Could not open file." << std::endl;
		return 1;
	}
	
	// Skipping header (80 bytes)
	for(int i = 0; i < 80; i++) {
		file.get();
	}
	
	auto triangleCount = readBinary<uint32_t>(file);
	
	std::array<float, 12> points;
	
	for(uint32_t i = 0; i < triangleCount; i++) {
		// reads 12 floats into `points`
		readBinaryArray(file, points);
		// skip the attribute data
		readBinary<uint16_t>(file);
	}
}

I have to preface by saying it’s been a while since I’ve looked at this snippet which I do not put forth as a good or recommended way of doing things, just one that’s worked for me for an STL format parser I made for fun. Notwithstanding that, the need to reinterpret is there by virtue of the ifstream::read method, which operates on char_type*. I do not see an issue as I read from arbitrary binary — “type safety” must begin somewhere along the deserialization line, and I begin it after that read command dumps data into a typed object while disregarding it’s type. If the incoming binary is bad, the object will not reflect a correct value.

Ok, sounds good. I've looked into it and this can be implementation specific behaviour if the file that you read isn't from the same implementation. ie: floats don't have to be 4 bytes wide for some reason. Otherwise I've tried to find a way to break this but there isn't. This actually is one of the rare times where using reinterpret_cast isn't UB.

I guess if I was to implement this I'd do the reading and parsing in different functions. It'd be slower but it'd allow for some type checking. Another possible way of doing this is using ::sscanf but then it's not really type safe either. The simplest way is probably std::ifstream::operator>>() but then you'd need a temporary and it'd most likely be slower (before optimization, who knows if the compiler would see through it)

Anyway… Thanks for answering

Hey it’s no problem. To be clear the intent of this code is to parse binary STL files which follow a consistent, well defined encoding - it’s not to deserialize data serialized by this or other C++ implementations. I would not recommend this code for such a broad purpose, but instead a more robust serialization library, perhaps protobufs or bson.