Trust your compiler: Modern C++

I’ve seen some terrible horrid nonsense from them and even the best compilers don’t use a third of the opcodes our modern CPUs boast of. Nobody understands the big compilers any more either, they’re all too huge. And soon AI will be “improving” hem too.

You want to see a beautiful compiler? Look at Plan 9’s compiler suite. A man could understand and even build on that.

Re: Trust your compiler: Modern C++

#5

Post by mike_hock » Sun, Jul 05, 2026, 1:17 PM UTC

> Virtual vs static polymorphism

> std::visit over std::variant is lowered to a switch over the active alternative.

> In this case, layout is probably doing more work than the dispatch mechanism itself.

Very likely because last time I checked visit lowers to a virtual call.

Re: Trust your compiler: Modern C++

#6

Post by CoastalCoder » Sun, Jul 05, 2026, 1:28 PM UTC

kzrdude wrote: post #3

Trust the compiler - sure - but we can't change the whole program by using -ffast-math, unfortunately, so that particular one is out.

I really dislike the complexity of modern C++ language specs, but does it obscure much detail about FP ops?

TL;DR:

A vast majority of the programmers I've worked with don't understand the nuances of FP in general, nor the various extents of IEEE-754 support in different programming languages.

So for important numerical programming, I think clarity regarding the FP operations being performed can be crucial. I'm just unclear if modern C++ is a significant factor for that.

Re: Trust your compiler: Modern C++

#7

Post by pjmlp » Sun, Jul 05, 2026, 1:28 PM UTC

sylware wrote: post #2

[flagged]

Quite funny comment on the vibe coding age.

Re: Trust your compiler: Modern C++

#8

Post by Panzerschrek » Sun, Jul 05, 2026, 1:44 PM UTC

> exceptions are slow

There are proposals to introduce better exceptions into C++. Like this: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p07....

But until it's not in the standard, people should use std::expceted instead.

Re: Trust your compiler: Modern C++

#9

Post by Joker_vD » Sun, Jul 05, 2026, 1:52 PM UTC

Every time I see "use ranges and algorithms!" examples, I am baffled that apparently, I am supposed to find

    inline double algorithm_call(std::span xs) noexcept {
        return std::accumulate(
            xs.begin(),
            xs.end(),
            0.0,
            [](double acc, double volts) {
                auto mv  = calibrated_mv(volts);
                auto err = residual(mv);
                return weighted_square(err) + acc;
        });
    }

more readable, concise, and easier on my eyes than

    inline double raw_loop(std::span xs) noexcept {
        double sum = 0.0;

        for (double volts : xs) {
            auto mv  = calibrated_mv(volts);
            auto err = residual(mv);
            sum += weighted_square(err);
        }

        return sum;
    }

Sure, there are some algorithms in that I'm rather not reimplement myself, but this one is not it.

Re: Trust your compiler: Modern C++

#10

Post by rzzzt » Sun, Jul 05, 2026, 2:07 PM UTC

Joker_vD wrote: post #9

Every time I see "use ranges and algorithms!" examples, I am baffled that apparently, I am supposed to find inline double algorithm_call(std::span xs) noexcept { return std::accumulate( xs.begin(), xs.end(), 0.0, [](double acc, double volts) { auto mv = calibrated_mv(volts); auto err = residual(mv); return weighted_square(err) + acc; }); } more readable, concise, and easier on my eyes than inline double raw_loop(std:…

The first form is easier to send to 32 beefy cores or 1024 small CPUs or a Beowulf cluster or a GPU or people sitting in a room.