fmt

> One thing I was surprised not to see mentioned here is multiple inheritance. There's nuance to banning that since implementating multiple interfaces is technically multiple inheritance in C++. So I think I'd agree with you but with an exception for pure-virtual classes. > Also, while iostream is a bit of a mess, having it be strongly typed means that it's, in my opinion, well worth using over cstdio. Orthodox C++ would ban this but you can have both printf-style with type safety with https://github.com/fmtlib/fmt Which inspired C++20's std::format: https://en.cppreference.com/w/cpp/utility/format Which is also banned by Orthodox C++

Are you saying the compiler itself does the checking? That is a pity. Compiler magic for a checking a fixed specific format system (I don't know about D, but that's what you're describing in C printf) is significantly worse the compile-time checking being written in the language itself. What if you, as library author (not compiler writer!), think of a much better formatting system? Or something that's maybe not better in general, but better for an unusual situation you're deploying in? Or you want to write something that's different to a formatting system but uses similar tricks? If you don't have language facilities to do this yourself then you're stuffed. As well the original post showing it's possible in Rust, this is also possible in C++. For example, the C++ fmt [1] library allows compile-time time checking of the number of slots in

Unfortunately performance claims appear to be bogus. 1. ospan, performance claims seem to be based on, doesn't do any bound checks, so you can easily get buffer overflow. 2. fast_io generates a whopping 50kB of static data just to format an integer. So if these benchmark results are correct (I was not able to verify because the author hasn't provided the benchmark source): > format_int 7867424 ns 7866027 ns 89 items_per_second=127.129M/s > fast_io_ospan_res 6871917 ns 6870708 ns 102 items_per_second=145.545M/s fast_io gives 15% perf improvement by replacing a safe format_int API from https://github.com/fmtlib/fmt with a similar but unsafe one + 50kB of extra data. Adding safety will likely bring perf down which the last line seems to confirm: > fast_io_concat 7967591 ns 7966162

> Neither will C++, as far as I know, or do you mean that the compiler will validate the formatting of the string literal. With iostreams there are no format strings so there is nothing to validate. Libraries such as https://github.com/fmtlib/fmt are allow to do compile-time parsing of the string though.