upvote

points

by 1122337 hours ago |
comments
upvoteby jandrewrogers5 hours ago|
next
[-]
Writing clear, concise, and efficient code in C++ has never been simpler or easier. The improvements in C++ over the last 15 years have been qualitative.

So many complex, esoteric, and difficult to maintain incantations that used to be required for efficient code generation are no longer necessary.

reply
upvoteby 1122333 hours ago|
parent|
[-]
How do you process read-only mmaped data in C++, in accordance with the language rules? As an example.
reply
upvoteby senderista2 hours ago|
parent|
[-]
I think there are lots of Unix APIs that are impossible to use without UB, e.g. SCM_RIGHTS (maybe io_uring as well?).
reply
upvoteby jll296 hours ago|
prev|
next
[-]
I think it has become EASIER: for instance, since C++23 Rust-like move semantics can be used, which provides the compiler with extra information that can be leveraged for the generation of better code.

Or take constexpr - it permits to move computations to compile time that are complex and in older versions either had to be done at runtime, or an ugly workaround had to be used (e.g. assigning a mysterious literal pre-computed in another run or by hand).

reply
upvoteby creata5 hours ago|
parent|
[-]
> C++23 Rust-like move semantics can be used

What C++23 feature allows that?

reply
upvoteby aw16211074 hours ago|
parent|
next
[-]
The closest thing I can think of is trivial relocation [0] which matches the bitwise copy + no destructor on moved-from bits of Rust's moves, but that was only added to the draft for C++26 and was removed late in the process anyways [1].

[0]: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p27...

[1]: https://herbsutter.com/2025/11/10/trip-report-november-2025-...

reply
upvoteby cherryteastain5 hours ago|
parent|
prev|
[-]
Maybe this one?

https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p22...

reply
upvoteby aw16211074 hours ago|
parent|
[-]
I think that's basically clarifying the conditions under which C++11-style moves can be performed.
reply
upvoteby fooblaster6 hours ago|
prev|
[-]
How? you can write exactly the same low level code today.
reply
upvoteby beached_whale6 hours ago|
parent|
next
[-]
My thought too.

There are so many things that are expressible in C++ now that could not be without writing much more code or using per-compilation tools back then. The ability to run code at compile time that is not run at runtime is huge, #embed lets us make other tools output available without linker scripts or compiler specific tools that.

Also, most of the code from the past still works(from 10 years ago definitely works)

reply
upvoteby AlotOfReading6 hours ago|
parent|
prev|
next
[-]
Shot in the dark, but maybe the OP is referring to the fact that these code conventions are explicitly discouraged by the C++ core guidelines. The SoA example falls afoul of the rule requiring T* to be used only for singular object pointers, for example.
reply
upvoteby cjbgkagh6 hours ago|
parent|
[-]
Not a regular C++ programmer but wouldn’t you use std::span here instead? Sure it’ll carry a few redundant lengths but it makes using functions that take spans easier. When I do write C++ it’s usually for speed so I’m often working at the intrinsics level, though AI has gotten good enough at it that I now generally delegate this work to an agent.
reply
upvoteby jandrewrogers5 hours ago|
parent|
[-]
Depending on the specific code, the compiler may even eliminate the redundant lengths.
reply
upvoteby 1122333 hours ago|
parent|
prev|
[-]
eh, yes-ish, but only thanks to compiler writers. at one point committee went all-out enforcing their lifetime model, making bit_cast not an option. If your code accesses same data using different types, you are spelunking ruins with snake pits and lava. more and more stuff needs magic support code in std::, making no-lib code less and less possible (it used to be that with no-rtti and no-exceptions, you could use all c++ features and only needed cxa_at_exit, operator delete, and few other little things. NOT ANY MORE).

On one hand, you have consteval and stuff, letting you FINALLY initialize data at compile time (hey, 20 years late but still!)

on other hand, it is done in most non-debuggable way possible. try setting breakpoint or adding print to constexpr function that causes your requires clause to fail...

so no, newer C++ the language is not possible to use for low level work. The dialects that compiler makers support are. We will see for how long

reply