Lmst

#Cpp26

C++26 is bringing std::execution (Senders/Receivers) 🔥

Learn to build async pipelines without manual synchronization in this hands-on online workshop with Mateusz Pusz.

Structured concurrency. Parallelism. Real-world usage.

🗓 May 15
🔗https://cpponline.uk/workshop/mastering-stdexecution-senders-receivers/

#cpp #cplusplus #cpp26

C++Online 2026 SESSION SPOTLIGHT: C++ Contracts - A Meaningfully Viable Product, Part II by Andrei Zissu

https://cpponline.uk/session/2026/cpp-contracts/

#cpp #cplusplus #Cpp26 #contracts

C++Online 2026 SESSION SPOTLIGHT: When One Red Pill Is Not Enough - Compile-Time Optimization Through Dynamic Programming by Andrew Drakeford

https://cpponline.uk/session/2026/when-one-red-pill-is-not-enough/

#cpp #cplusplus #cpp26 #constexpr #algorithms

Static reflection is coming to C++26 🚀 Learn how to use it today to build zero-overhead, reflection-driven OpenGL & ImGui pipelines—and eliminate common graphics bugs.
🗓 Apr 2 or May 25
🔗Find out more and register:https://cpponline.uk/workshop/splice-and-dice/
#cpp #cpp26 #programming #coding

This conversation with @meetingcpp organizer Jens Weller reflects on highlights from Meeting C++ 2025 and the evolving C++ landscape - from Toyota’s open-source real-time work to the gap between C++20/C++26 adoption and continued industry use of C++11/17. #Cpp #Cpp20 #Cpp26 #SoftwareDevelopment #OpenSource

Watch the full interview:
https://www.youtube.com/watch?v=XESMSq1PEpI

CLion 2025.3 Is Here, and It’s Epic: Faster Language Engine, Unique Constexpr Debugger, DAP Support, and Much More
#Clang #CLion #News #Releases #Clionnova #Constexpr #Cpp26 #Dap #Stm32 #Zephyrwest

https://blog.jetbrains.com/clion/2025/12/2025-3-release/

I wrote a #WG21 Kona 2025 trip report:
https://mattkretz.github.io/2025/11/13/WG21-Kona-2025-trip-report.html

#cpp26 #cpp #CPlusPlus #simd

constexpr all the things! Since the evaluation of a constant expression never results in an erroneous behavior (EB, C++26)! (But use constexpr since C++11)

This was mentioned by many at the conference, not to forget: @DanielaKEngert, Mikhail Svetkin, and others.

@meetingcpp #cpp #cpp26 #cpp11 #meetingcpp #dev #undefined_behavior #ub #erroneous_behavior #eb

"[..] Evaluation of a constant expression ([expr.const]) never exhibits behavior explicitly specified as undefined in [intro] through [cpp]. - end note"

@mkretz
"We violently agree" 😸

But P3802 will certainly have to wait until #cpp29 to become a portable C++ feature for apparent procedural reasons: it appeared *after* #cpp26 feature freeze, was never discussed in EWG, nor made it into a plenary vote. AFAICS, the mistake of #cpp0x will not be made again.

Immediate escalating expressions promote constexpr functions to immediate functions. 👍 Now, can I get a partially promoted half-immediate function instead? 😢

#wg21 #cpp26

@mkretz
Just because some implementation *could* implement this kind of behaviour by using something along the lines of __local_ctx and by taking advantage of prospective #cpp26 features doesn't mean *it is*.

The described behaviour was quite controversial after std::source_location made it into #cpp20 . I can remember the discussions happening in the then-monthly EWG online meetings (COVID!) where the necessity of such unfamiliar properties of source_location::current() was seen vital to meet user expectations: the return value of that function depends on the *current compilation context*. I.e. compilers *must* re-evaluate the apparently pure, obviously dependency-free, immeditate (compiletime-only) function *at every occurance* in a TU where it is - possibly silently - invoked!

@DanielaKEngert Ah you're not creative enough. It's implicitly already in. Because there are functions that do this and a compiler vendor is free to implement their own __local_ctx right now. Being able to reflect on target properties is an implementation extension anyway. So any compiler implementing reflection (i.e. #cpp26) is almost there.

@mkretz
Right - exactly!

Alas, it can (and will) - checks docs - *not* be in #cpp26 for apparent reasons.

So if your library wants to use constexpr exceptions internally (in consteval functions) while still being usable for projects that enable `-fno-exceptions` … it seems like you can just wrap your code in:

#pragma GCC push_options
#pragma GCC optimize("exceptions")
// have fun with exceptions
#pragma GCC pop_options

😈 🙈

The real question is whether -fno-exceptions should apply to consteval-only exceptions at all.

#GCC #CPlusPlus #cpp #cpp26

I read https://www.open-std.org/JTC1/SC22/WG21/docs/papers/2025/p3802r0.pdf "Poor Functions" last night. I jumped for joy! 😆 Finally, I had words for what I was thinking all this time. This __local_ctx idea puts into words what I wanted to say with regard to #FunctionMultiVersioning (https://gcc.gnu.org/wiki/FunctionMultiVersioning). I need to be able to reflect on those attributes in order to make SIMD types and functions behave correctly in the context of FMV. __local_ctx producing a std::meta::info sounds like the solution!

#WG21 #cpp26 #GCC

Ever wanted to modify a pack of values and assign to a new pack?
It's possible (1st picture; the `cpp23` functions show constant expression vs. runtime values). It's not insane to hide such horror behind a macro 😧.
With C++26 we can do better (2nd picture). Define a `static_array` helper once and then we can use structured bindings to define new packs. (We could also use that to extract the first/last element from the pack.)
Playground: https://compiler-explorer.com/z/jse1vrfKq

#cpp #cplusplus #cpp26

$template <int... Is> void cpp23() { []<int... Js>() { (std::cout << ... << Js) << '\n'; }.template operator()<(Is * 2 + 1)...>(); } void cpp23(auto... is) { [](auto... js) { (std::cout << ... << js) << '\n'; }((is * 2 + 1)...); }$ $template <auto x0, auto... xs> inline constexpr decltype(x0) static_array[] = {x0, xs...}; template <int... Is> void cpp26() { constexpr auto [...Js] = static_array<(Is * 2 + 1)...>; (std::cout << ... << Js) << '\n'; } void cpp26(auto... is) { auto [...js] = std::array{(is * 2 + 1)...}; (std::cout << ... << js) << '\n'; }$

In my latest blog post, "C++26 reflection at compile-time," you'll learn about a massive improvement in the upcoming C++26 standard.

https://andreasfertig.com/blog/2025/08/cpp26-reflection-at-compile-time/

#cplusplus #cpp #cpp26

Folks who have worked on / tried #cpp26 reflection APIs (I've reviewed so many different versions I can't remember what the final spec looks like):

Is there a way of providing an identifier as a template parameter that can be used for reflection later? The specific thing that I want to do is provide a bare name of an enum that is declared inside another class, but where the template function is able to derive the path to the enum definition and so can do its own lookup with reflection.

Run-time reflexion in C++26... Wow, i was expecting that since 2004. That's one of the reasons we meta-programmed Dynamic Types in CLAM.

#cpp #clam #cpp26

https://www.youtube.com/watch?v=TOKP7k66VBw

#Cpp26

Client Info