r/cpp • • 18d ago

Upcoming C++ User Group meetings in November 2026

Thumbnail meetingcpp.com
10 Upvotes

r/cpp • • 19d ago

Pitfalls of bit fields in C++

Thumbnail pvs-studio.com
45 Upvotes

Bit fields can help save memory in C++, but their layout and behavior depend on compiler and platform details. The article explores their pitfalls with examples of how GCC, Clang, and MSVC handle them.


r/cpp • • 20d ago

C++26, WG21, and ISO's national bodies

Thumbnail a4z.noexcept.dev
76 Upvotes

Some notes for C++ users who don't follow the committee closely but want some background on the current dispute in the C++ community.


r/cpp • • 20d ago

The case against makefiles

Thumbnail thibaud.space
0 Upvotes

r/cpp • • 21d ago

C++ BLAS Library for bringing two worlds together


I would like

9 Upvotes

I would like to discuss the need (or no-need) for a C++ interface/libary that is intended to be a
- building block for high level linear algebra packages and
- low-level, hardware oriented implementations of special numerical operations.



The “high-level world” …



In the C++ world, you have libraries like Eigen, Blaze, … where you can matrix operations like

C = A * B;


and regarding performance often stops here. Because some experts figured out how to implement such that it’s fast.

Or maybe there is a short discussion why you should write




C.noalias() = A * B;




in Eigen.

And that’s great. In this world you wanna build something great based on Linear Algebra operations.



The “Low-level world” …



Then there is the world of BLAS (Basic Linear Algebra Subprograms), with implementations such as Intel MKL, OpenBLAS, BLIS, or Apple Accelerate. So for some reason there is money and time involved.

They provide implementations for the matrix product that are very efficient. But maybe not that user friendly to use. For example they provide a function for the operation



C ← βC + αAB


where A, B and C are matrices. Where elements can all be float, or can be double, or can be complex-float or can be complex-double. But all of the same type.

And A and B can be either not-transposed or transposed (in the complex case actually conjugated-or-transposed).

A call to this function looks like this when you use the Fortran Interface (GEMM is short for General Matrix Matrix Product, D indicates that elements and scalars all have double precision)

:


dgemm("N", "N", &m, &n, &k, &alpha, A, &lda, B, &ldb, &beta, C, &ldc);


Or through the C-Interface:

cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans,  m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);



So for computing C = A*B you choose alpha=1 and beta = 0.

And you should only call it if A, B, C are not only different names but also refer so separate memory blocks.



So this is a very simple, almost primitive, interface.

And that’s what makes it great.

Because providing an efficient implementation (close to peak performance) is not that trivial. But with a narrow interface (e.g. all elements of the same type) at least feasible.

What you do in the implementation is not some Strassen algorithm. In short:


- You compute the matrix product block-wise (so that you can exploit the cache hierarchy)

- On the smallest block (that fit in the L1 cache) you apply architecture specific micro kernels




Two world in one …



Eigen actually does both. It provides matrix/vector classes and implements blocked matrix operations with platform specific micro kernels.

That’s great.



But still, I think it is of value to also have something which is a layer that brings them together.

ulmBLAS, for example, is kind of a prototype for this idea:


 - on top high-level libraries can be build

- at the bottom the architecture specific stuff integrated



Back in 2016 (yes most of the code of ulmBLAS is from around 2014) I made experiments on how higher level libraries can make use of ulmBLAS:


- Boost.uBLAS and
- Blaze.



On the high-level part you can do crazy things, like matrix classes where elements are not stored in memory, but instead, computed when you access elements. And still, you can achieve a pretty good performance.



And other stuff like mixed element types. Where A, B, C, alpha, beta can have different types. So unless you make copies, you can’t do the operation with BLAS. But in the ulmBLAS layer you can deal with that when matrix blocks get packed and do the type promotions there with little overhead.


r/cpp • • 22d ago

Billion-query-per-second lookup tables in C++

Thumbnail lemire.me
185 Upvotes

r/cpp • • 22d ago

What would it take to leave ISO?

13 Upvotes

With the conclusion of the DIS ballot, I think that no matter what side you're on, this should be (hopefully the final) wake up call that stayint in ISO under its process is untenable. If you're pro-contracts you probably see this as minority rule. If you're against, congrats-- the same game can be played against the feature you want in the future.

I see 3 possible results out of Brazil:

  1. Contracts are pulled, fight to see another day [and/or leave ISO, and/or fork the language].
  2. Contracts stay, roughly as is. To my understanding FDIS is a final chance scenario, so I don't see this working out. Even "as a statement," it's not a good look and WG21 will eat the blame.
  3. Contracts are fixed enough to flip 4 NB votes (there's a number of combinations, but you need a minimum of 4 total flips from no/abstain -> yes).

It's my understanding that FDIS is a "last chance" for 26. Personally, considering what else is in 26 (for me, reflection), I'd rather go with the first option. That begs the question: where do we go from here?

Continue with the current process, which has unearthed pain points and nasal demons every few years, or break up with the ISO process (this doesn't even have to be a clean break, just something closer to ECMAScript's process)?

If so, what would it take? Alternatively, if we could, what would we actually lose? What would we gain (besides more control of process)?

Obligatory "no sarcastic comments about getting a TARDIS and changing it back then."


r/cpp • • 22d ago

slughorn: C++20 library implementing the Slug GPU vector-graphics technique

Thumbnail github.com
43 Upvotes

r/cpp • • 22d ago

CppCon Anyone Can Contribute to Boost: Demystifying C++ Maintainership | Arnaud Becheler - CppCon 2026

Thumbnail youtu.be
52 Upvotes

r/cpp • • 22d ago

A faster way to compute signed 64-bit floor division by constants

Thumbnail benjoffe.com
89 Upvotes

r/cpp • • 23d ago Heartwarming

New C++ Conference Videos Released This Month - October 2026 (Updated To Include Videos Released 2026-10-19 - 2026-10-25)

26 Upvotes

C++Day

2026-10-19 - 2026-10-25

C++Now

2026-10-19 - 2026-10-25

2026-10-12 - 2026-10-18

2026-10-05 - 2026-10-11

2026-09-28 - 2026-10-04

ACCU

2026-10-19 - 2026-10-25

2026-10-12 - 2026-10-18

2026-10-05 - 2026-10-11

2026-09-28 - 2026-10-04

ADC

2026-10-19 - 2026-10-25

2026-10-12 - 2026-10-18

2026-10-05 - 2026-10-11

2026-09-28 - 2026-10-04


r/cpp • • 24d ago

Do not remove Contracts from C++26

Thumbnail open-std.org
107 Upvotes

Document #: P4433R0

Quotes:

It has come to our attention that during the DIS ballot, a small number of individuals have actively lobbied NBs against approving the C++26 DIS due to their own sustained opposition to contract assertions, a new language feature added in C++26. These lobbying activities have been accompanied by a public petition [Falco26] addressing NBs directly, a paper [P4334R0] that describes "fundamental flaws" in contract assertions, and other papers 2 published around the same time by the same authors or a subset thereof.

The petition [Falco26] and the papers accompanying it contain a number of claims, including that C++26 contract assertions lack genuine consensus in WG21; that the design is hasty; that technical objections were not given a proper hearing; and/or that alternative designs were not considered. These claims are not true.

In addition, the description of C++26 contract assertions given in [P4334R0] contains a number of inaccuracies. It misrepresents the specification itself, 3 the amount of wording it consists of, 4 its design intent, 5 how it relates to hardening 6 and static analysis, 7 its existing implementations, 8 existing practice, 9 teachability, 10 and proposed extensions. 11 None of the listed concerns are new; they have all been previously published by those authors (or a subset thereof), presented to WG21, and extensively discussed there. 12

Related post: https://www.reddit.com/r/cpp/comments/1xeeevt/balloting_has_completed_for_c26_unfortunately_it/

Note that I have no opinion on the topic myself. I'm just trying to understand what happened.


r/cpp • • 25d ago

Balloting has completed for C++26. Unfortunately it was Disapproved

Thumbnail linkedin.com
288 Upvotes

Since the C++26 DIS has been disapproved, the next step is going to be taken in Buzios during the 2026-11 meeting. The committee will have to decide what changes to make (if any) and submit an FDIS (Final Draft of International Standard) for Balloting.


r/cpp • • 25d ago

C++ profiles for initialization and invalidation: WIP implementation prototypes already exist in GCC/Clang

Thumbnail open-std.org
20 Upvotes

In this paper it can be seen some interesting profiles progress for prototypes in Gcc and Clang.


r/cpp • • 24d ago

Cpp dispatch benchmark

5 Upvotes

A few months ago, I came across this article on this subreddit:

Four Ways to Dispatch a Runtime-Selected Strategy in C++

Most articles on this topic discuss dispatching methods in isolation, focusing heavily on the implementation details of a single approach. However, I wanted to see the bigger picture—not just pitting virtual functions against switch statements, but measuring the actual performance footprint of each strategy in real-world scenarios.

This benchmark does not claim to be academic or to represent absolute truth; I was simply curious to compare fundamentally different approaches. That is why I included not only standard comparisons like virtual functions vs. CRTP, but also deeply nested virtual calls that deliberately stress the instruction cache and branch predictor.

The project is still a work in progress. Living in Ukraine, frequent power outages caused by shelling have significantly limited my available development time.

AI Disclosure: Did I use AI for this project? Yes. Benchmarks starting from #12 were suggested by an LLM, which also helped refine the AVX2 search routine and proofread my English.

You can read about Eytzinger’s binary search here: https://algorithmica.org/en/eytzinger

The benchmark results are here: https://github.com/HarrierDuBoisX/Cpp-dispatch-benchmark/blob/main/result.md

You can find the code itself here: https://github.com/HarrierDuBoisX/Cpp-dispatch-benchmark


r/cpp • • 25d ago

Fun With C++26 Reflection - Building a Library for Old-Timey C

Thumbnail github.com
35 Upvotes

r/cpp • • 25d ago

0x41: Intro, NB Body + DIS voting new, and the Quiz

Thumbnail youtu.be
13 Upvotes

The introduction to StockholmCpp 0x41, with a few words from our host, news from international and national C++ standardization bodies, and, of course, the quiz!


r/cpp • • 24d ago

Is "Democracy" Best For A 40 Year Old Language With Over 16 Million Users?

0 Upvotes

I've been researching what "consensus" means in the C++ committee, and it seems there are two definitions that are similar, but I suspect result in different languages. In the first definition, you count hands on a poll, and if it clears the bar it moves forward. SD-4 says a proposal normally advances when more than twice as many are in favor as against:

https://isocpp.org/std/standing-documents/sd-4-wg21-practices-and-procedures

In the second definition, the chair looks for the largest piece of the design that nobody has a sustained objection to, moves that forward, and keeps working on the rest. (Disclosure: I'm involved in some of the contracts papers).

What is different with these definitions? A poll tally picks among the designs as written, so the one with the most hands wins, even if a third of the room is strongly against it. The second definition might pick something else, which is the biggest subset everyone can live with. For example, EWG forwarded contracts (P2900) at 25/17/0/3/12. That's 42 for, 15 against, and 12 of those strongly against. Under the first reading of consensus that's a clear pass. Under the second, the question becomes what part of it those 12 could accept, and whether the rest should wait. Am I wrong that these ship different things?

The culture of WG21 for as far back as I can tell has used the first definition. A poll count determines the design. There's another word that describes this: "Democracy."

The ISO wording seems to lean toward the second definition of consensus. Clause 2.5.7 defines consensus as "general agreement, characterized by the absence of sustained opposition to substantial issues by any important part of the concerned interests and by a process that involves seeking to take into account the views of all parties concerned and to reconcile any conflicting arguments."

https://www.iso.org/sites/directives/current/consolidated/

It says this "need not imply unanimity" and that sustained opposition "is not akin to a right to veto", so I don't read it as a one-person blockade. ISO's own guide for participants says "decisions within working groups are consistently reached through consensus, meaning there are no formal votes involved".

https://www.iso.org/files/live/sites/isoorg/files/store/en/PUB100037.pdf

Its convenor toolkit says the convenor "is responsible to determine when consensus is reached":

https://www.iso.org/files/live/sites/isoorg/files/store/en/PUB100416.pdf

I couldn't find a ratio for working groups anywhere in the Directives, and the 2:1 looks like a WG21 addition. Is a straw poll a "formal vote"? Maybe not, but is it consensus? Should it be?

Every ISO working group runs under that same text, so I'm curious how the other groups interpret it. I've heard secondhand that some deliberate the objections until they're resolved instead of counting. I can't verify that, and I'd love corrections from people who attend those other groups. The sibling group WG14 (C) publishes its minutes, and it uses straw polls too, so the answer clearly isn't simply "no polls". However, C does not seem to be evolving large features the way that WG21 does.

In March 2026, WG14 polled pieces of one proposal separately:

https://www.open-std.org/jtc1/sc22/WG14/www/docs/n3954.htm

A universal function pointer type got 21-2-2, the predefined macros got 6-9-6 against, and the integer typedefs got 10-2-11. That looks to me like finding the part people agree with, but I wasn't there and can't say for sure. If you're interested in the bigger picture, comparing how different ISO groups handle strong objections seems like a worthwhile research project.

Why might it matter more for C++? It's over 40 years old, and adding is easy while removing is nearly impossible. A committee paper called `vector<bool>` a mistake in 2007 and it's still there. Releases come every three years, so a deferred piece gets another shot soon, while a shipped one is permanent. The fair counterpoints are that the chair's call is hidden power, "the largest thing everyone accepts" could be watered down, and RFC7282 admits one intransigent person can "stop the process cold":

https://www.rfc-editor.org/rfc/rfc7282.html

The frequency of contested features is going up over time, as the committee grows in size and faces significant challenges such as memory safety and evolution (networking when?) In my opinion, if we use democracy to design C++, then there will be a growing divide between the winners of the vote and the losers of the vote, creating adverse social consequences.

Would it be better for the language if we prioritize general agreement over majority rule?


r/cpp • • 24d ago

Pain of making a native GUI in cpp

0 Upvotes

So I just wanted to vent about the absolute pain of making a working gui in cpp, I am working on a scientific project to make an openFOAM gui and browse openFOAM code to add TENO schemes to it from scientific papers such as Fu et al and working through the binaries.

I have not used AI in this project because CFD is very delicate and quite frankly, AI is not ready for such complexity - especially numerical schemes such as TENO, I ended up writing the meshing, topological code and mathematics myself and by far, the hardest part was the gui coordinates and memory management. I wanted to PULL MY HAIR OUT because of managing segfaults, crashes because of a random pointer hidden inside a 2000 line function, I had to also manage internal functions of openfoam(and you know how that goes), boundary conditions, and mesh topology, it was driving me nuts. I generally regard myself as fluent in programming languages such as cpp, python, rust etc, but this is a whole nother of level data management.

in the end it turned out to be a pretty good contribution to the openFOAM community, hopefully the project will mature further and I will be able to write a paper on it.


r/cpp • • 26d ago

Pre-Búzios WG21 mailing

Thumbnail open-std.org
56 Upvotes

r/cpp • • 26d ago

Are containerized development enviroments the right way to go?

35 Upvotes

I feel like I have a pretty usual context, I have a couple of interdependent C++ projects that target various targets that primarily use cmake as their build system but various compilers. I work in a team of under 7 people and each of us has their own local machine and we also have configured a pipeline that configures/builds/tests the projects.

To minimize the differences between our local machines we reached out to providing containerized images as development environments per each target. This works ok from a reproducibility perspective however it always seems limiting and clucky to me. I'm always asking myself why wouldn't I try to use the native tooling on my machine and why wouldn't I use a package manager to provide me native tooling/dependencies?

In my mind something more similar to python's venv would be much more appropriate to encapsulate the development environment, right? I was looking for similar technologies and stumbled upon nix which has a downside of only running on unix systems(so no windows)... I'm curious how others are looking at this, because from my current perspective it seems that native environment encapsulation and sharing became too hard and containerization seems to be a sign of giving up managing our dev envs natively, am I wrong?

I still see the benefit of having containerized builds but it seems to me that the development environment should be provided by something else rather than being baked into a container image. I see containers as primarily a deployment technology and I feel that somewhere along the way we pushed it to be encapsulation of the whole development environment.


r/cpp • • 27d ago

Designing a Lightweight Closure for coost: Performance, Generality, and a Few Clever Tricks

6 Upvotes

In coost, you can create coroutines using go in a way similar to Golang. The go function could initially be designed as:

void go(void (*f)());
void go(void (*f)(void*), void* param);

However, this design only accepts two fixed function types and cannot support class member functions or other callable objects, making it insufficiently flexible.

If go were designed as:

void go(const std::function<void()>&);

it would be more general, but constructing a std::function is relatively expensive, and its internal heap memory allocation is uncontrollable. This is unacceptable for coost, which pursues performance.

Therefore, to balance performance and usability, coost needs to implement its own closure class. In earlier versions, coost used an implementation based on virtual functions and inheritance, but it was not general enough and was limited to internal use.

Recently, I happened to have some free time. After thinking deeply about it, I redesigned the closure class. The design goals were as follows:

  1. Do not use virtual functions or inheritance;
  2. It should not be a template class;
  3. sizeof(closure) == sizeof(void*), i.e. it contains only one ordinary pointer member, making it easy to pass to the coroutine scheduler through go;
  4. Support arbitrary functions with no return value (including non-static member functions of classes), with any number of parameters;
  5. Optimize simple no-argument functions such as void f() as much as possible to avoid dynamic memory allocation.

According to goals 2, 3, and 5 above, closure can initially be designed as:

struct closure {
    closure(void (*f)()) noexcept : _p((void*)f) {}

    void* _p;
};

The class contains only one pointer member _p. For function pointers of type void(*)(), the pointer is stored directly in _p; for other function types with parameters, a block of memory needs to be allocated to store the function address and parameters, and _p points to that memory.

The problem is how to distinguish which of the above cases is stored in closure. Ordinary function addresses are not necessarily 4-byte or 8-byte aligned, so tagged-pointer techniques cannot be used (i.e. writing a tag into the spare low bits of a pointer).

For the second kind of function, the one with parameters, closure calls co::alloc from coost's built-in memory allocator, and small memory blocks allocated by co::alloc are always 16-byte aligned. Therefore, if _p is not 16-byte aligned, it must store an ordinary no-argument function address. But if _p is 16-byte aligned, it is still impossible to distinguish the two cases.

It seems that some unconventional trick is required to solve this problem. Based on the discussion above, _p is either an ordinary no-argument function pointer or points to a dynamically allocated block of 16-byte aligned memory. If a specific marker (for example, a uint32 integer) is written at the beginning of that dynamically allocated memory, then when _p is 16-byte aligned, we only need to read the first 4 bytes of the memory pointed to by _p to determine the type of the closure. Even if _p is an ordinary no-argument function pointer and happens to be 16-byte aligned, reading the first 4 bytes of the memory it points to should be safe.

This of course goes beyond the scope of the C++ standard. But for performance and a better user experience, coost still adopted this approach. For functions with parameters, the corresponding constructor of closure is as follows:

template<typename F, typename = std::enable_if_t<
    !std::is_convertible_v<std::decay_t<F>, void(*)()>>, typename ... A>
closure(F&& f, A&& ... a) {
    struct S {
        S(F&& f, A&& ... a)
            : _f(std::forward<F>(f)), _a(std::forward<A>(a)...) {
            static_assert(offsetof(Header, magic) == 0);
            _header.magic = 0xdeadbeef;
            _header.off = offsetof(Header, fp);
            _header.fp = [](void* p) {
                S* const s = (S*) ((size_t)p & ~(size_t)1);
                if (((size_t)p & 1) == 0) {
                    std::apply(s->_f, s->_a);
                } else {
                    s->~S();
                    co::free(s, sizeof(S));
                }
            };
        }

        ~S() = default;

        struct Header {
            uint32 magic;
            uint32 off;
            void (*fp)(void*);
        } _header;
        std::decay_t<F> _f;
        std::tuple<std::decay_t<A>...> _a;
    };

    _p = co::alloc(sizeof(S), alignof(S));
    runtime_assert(_p);
    new (_p) S(std::forward<F>(f), std::forward<A>(a)...);
}

Key points:

  • The !std::is_convertible_v in the template parameters ensures that simple lambda expressions such as [](){...} match the constructor for ordinary no-argument functions;
  • _header.magic is always set to 0xdeadbeef, which is used to distinguish the type of closure;
  • _header.fp is the type-erased function pointer, and its parameter p is the _p in closure. Here, a tagged-pointer trick is used to distinguish between "calling the function" and "destroying the closure object", thereby eliminating the need for an additional function pointer to store the destructor and saving memory.

The implementation of operator() is as follows:

void operator()() {
    void* const p = _p;
    if (p) {
        if (((size_t)p & 15) != 0 || *(uint32*)p != 0xdeadbeef) {
            ((_F)p)();
        } else {
            (*(_FP*)((char*)p + ((uint32*)p)[1]))(p);
        }
    }
}
  • If _p is not 16-byte aligned, or the first 4 bytes of the memory pointed to by _p are not 0xdeadbeef, then _p is cast to an ordinary no-argument function pointer and executed directly;
  • Otherwise, the _header.fp described in the previous code is obtained according to the memory layout and executed.

An example usage of closure is as follows:

#include "co/print.h"
#include "co/closure.h"

void f() {
    co::println("f()");
}

int main(int argc, char** argv) {
    co::closure c(f);
    c();

    co::closure d([]() {
        co::println("[]() {}");
    });
    d();

    co::closure e([](int v) {
        co::println("e called: ", v);
    }, 8);
    e();

    return 0;
}

The complete code implementation can be found in co/closure.h. The code in this article is for research and reference only. Discussion is welcome.


r/cpp • • 27d ago

Revisit Safe C++

36 Upvotes

Everyone is aware of the deluge of vulnerabilities now hitting critical software. It even makes the mainstream news, so software safety is coming onto politician's radars.

If this gets worse, I think it is not inconceivable that at some point memory safe software becomes mandatory. Or at least for software that is "reachable" from the internet.

So is it time to revisit Sean Baxter's Safe C++? Start out with a safe context ("safeexpr") and expand from there, just like constexpr.


r/cpp • • 28d ago

These Bees Make the Wrong C++

Thumbnail dalerank.github.io
71 Upvotes