You can see how ugly Bjarne's streams are even in this small article, ignore for a moment the strange fact that the Dobbs article uses the wrong operator on the last line.
cout << "number of elements = " << buf.size()
<< ", median = " << median << ", mean = "
>> mean >> '\n';
This is clearly improved by just having string formatting (a feature C manages to have, but here's Rust's)
println!("number of elements = {}, median = {median}, mean = {mean}", buf.size());
It's OK though, twenty years later C++ managed to get as far as
std::cout << std::format("number of elements = {}, median = {}, mean = {}", buf.size(), median, mean) << std::endl;
This is clearly disingenuous. C's string formatting is a completely different thing from that Rust snippet or your snide remark about std::format.
I'd rather use printf than cout, I think iostream is clunky, but printf is definitely a footgun & a fairly common source of bugs itself. So much so that compilers had to add support for specifically recognizing printf() calls & validating the inputs.
Also don't forget C still doesn't have standard placeholders for sized types. Gotta use that derpy PRId64 & friends which makes printf() almost as ugly looking as iostreams.
The C standard could insist they perform print format validation and thus make it safe for string literals. As you note, popular compilers do this today so it would merely be requiring what is in fact common practice.
As published C++ 20 allows a compiler to swallow this nonsense:
if (untested_condition)
result = std::format("Oops {} {} {} {}", only, three, parameters);
... and spit out a program that will only blow up when untested_condition becomes true in production. Fortunately sanity prevailed as I understand it, and the revised document correctly requires that this is a compile time error.
That's again a disingenuous phrasing. The compiler didn't swallow any nonsense. std::format is just a function, there's no direct compiler support for this. The {fmt} library did validation at runtime (which still needs to happen if the string isn't a constant!). The C++ working group then pushed to make it a compile time error in the cases it could be as part of promoting {fmt} into the standard library, which {fmt} did on existing C++20 compilers & that improvement has been folded into the spec.
printf() is likewise just a function. If we're not calling out std::format("{}{}",oops); as nonsense then we'd have no right to complain about printf("%s%d",oops) either. I say it is nonsense because it isn't sense.
Of course we can complain. First, std::format is already improved, so this is moot anyway. But more importantly, std::format always caught the error & threw a well defined exception. printf() does no such thing. It has no validation that your inputs matched the format spec. std::format always had that. So does std::cout & iostreams, for that matter.
