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);
	}
}

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.