Converting Between Unicode UTF-16 and UTF-8 in Windows C++ Code -- Giovanni Dicanio

By Giovanni Dicanio | Dec 19, 2025 03:12 PM | Tags: None

Very often the need arises in Windows C++ programming to convert text between Unicode UTF-16 (which historically has been the native Unicode encoding used by Windows APIs) and UTF-8 (which is the de facto standard for sending text across the Internet and exchanging text between different platforms).

Converting Between Unicode UTF-16 and UTF-8 in Windows C++ Code

by Giovanni Dicanio

From the article:

A detailed discussion on how to convert C++ strings between Unicode UTF-16 and UTF-8 in C++ code using Windows APIs like WideCharToMultiByte, and STL strings and string views.

 

C++ Standard Evolution Viewer -- Jason Turner

By Blog Staff | Dec 19, 2025 06:58 AM | Tags: None

Explore how the C++ standard evolved across versions with interactive side-by-side diffs

C++ Standard Evolution Viewer

by Jason Turner

From the article:

This site provides an interactive way to explore changes in the C++ standard by viewing side-by-side diffs of individual sections (identified by stable names like [array], [class.copy], [ranges.adaptors]).

Each version transition below focuses on Tier 1 sections (major library components and language features) to provide the most educational value.

Structured iteration -- Andrzej Krzemieński

By Andrzej Krzemienski | Dec 15, 2025 03:44 PM | Tags: None

It is relatively easy to get your for-loops wrong. Luckily, C++ offers more and more bug-proof alternatives.

Structured iteration

by Andrzej Krzemieński

From the article:

These problems do not occur when you use the range-based for-loop.

This C++11 addition, apart from other conveniences, is a safety feature (as in language-safety): it is very hard to use it incorrectly. It is not flexible, or versatile. You have to pass it a range, you have to give a name to an element referenced in each iteration step. There is no "control variable" (like i), so you cannot get the operations on it wrong. A number of bugs are prevented simply by employing a range-based loop.

But what if my iteration is more complicated? What if I need to visit my elements in reverse?

 

Trip report: Meeting C++ 2025 -- Sandor Dargo

By Blog Staff | Dec 9, 2025 03:36 PM | Tags: None

What a year I had! One more conference, one more trip report! I had the chance to go to Meeting C++ and give not just one but two talks!

Trip report: Meeting C++ 2025

by Sandor Dargo

From the article:

I remember that last year I said that Berlin in November is the perfect place to have a conference because you want to be inside that four-star hotel and not outside. This year, the conference was held a week earlier, and the weather was so nice that it was actually tempting to go out and explore.

But people resisted the temptation. The lineup and content were very strong — this year there were more than 50 talks across 5 different tracks. Also, Meeting C++ is a fully hybrid conference, so you can join any talk online as well.

It might sound funny, but I must mention that the food is just great at Meeting C++. It’s probably the conference with the best catering I’ve ever been to — from lunch to coffee breaks, everything was top-notch.

This year, there were no evening programs. I’m not complaining; it’s both a pity and a blessing, and I’m not sure how I feel about it. For example, when I first attended C++ On Sea, there were no evening events, and I really enjoyed discovering Folkestone in the evenings. Over the years, the schedule there got extended, and sometimes I had no time to visit my favorite places. But at least some socializing was guaranteed. One can say that you can do it on your own, but many of us are introverted, and if we’re not forced to socialize, we just won’t. That’s even easier to avoid in a big city like Berlin. I remember that last year I didn’t have time to go out until the end of the conference. It was different this year.

But let’s talk about the talks.

My three favourite talks

Let me share with you the three talks I liked the most. They are listed in chronological order...

C++ Enum Class and Error Codes -- Mathieu Ropert

By Blog Staff | Dec 5, 2025 03:33 PM | Tags: None

C++11 gave us enum class and while it’s great to have scoped enums I don’t find it great for error handling. Let’s talk about why.

C++ Enum Class and Error Codes

by Mathieu Ropert

From the article:

Most of my readers, I hope, have been able to use C++11 for a while now (if not hello, I’m sorry the world has changed to become this weird during your 14 years sleep). With it came a small change that allowed for better scoping of names without resorting to weird quirks: enum class. The idea is simple: owing to C, enum values in C++ belong to the class or namespace they are declared in but if we add the class keyword to the declaration they know become their own scope instead of leaking to their parent.

This was a simple quality of life change in the compiler to address a weakness in the language that folks usually worked around by either adding long prefix to the enum values (C style) or wrapping them within structs or classes (C++98/03 style). And with it came the incentive to migrate C era error code enums to scoped enums. But there’s a catch.

Trip report: Budapest C++ - Breaking & Building C++ -- Sandor Dargo

By Blog Staff | Dec 3, 2025 03:30 PM | Tags: None

The Budapest C++ Meetup was a great reminder of how strong and curious our local community is. Each talk approached the language from a different angle — Jonathan Müller from the perspective of performance, mine from design and type safety, and Marcell Juhász from security — yet all shared the same core message: understand what C++ gives you and use it wisely.

Trip report: Budapest C++ - Breaking & Building C++

by Sandor Dargo

From the article:

More than a hundred people registered, and the room quickly filled up with local developers eager to hear three technical talks. The atmosphere was lively and welcoming — it showed the strength of the C++ community in Budapest. In 2027, even WG21 might come to Hungary!

The evening began with Jonathan Müller’s talk, Cache-Friendly C++, followed by my own session on Strongly Typed Containers. Finally, Marcell Juhász closed the event with an insightful and hands-on presentation on Hacking and Securing C++.

Speeding up C++ functions with a thread_local cache -- Daniel Lemire

By Blog Staff | Dec 1, 2025 03:25 PM | Tags: None

When working with legacy or rigid codebases, performance bottlenecks can emerge from designs you can’t easily change—like interfaces that force inefficient map access by index. This article explores how a simple thread_local cache can dramatically improve performance in such cases, reducing repeated lookups from quadratic to near-constant time.

Speeding up C++ functions with a thread_local cache

by Daniel Lemire

From the article:

In large code bases, we are often stuck with unpleasant designs that are harming our performance. We might be looking for a non-intrusive method to improve the performance. For example, you may not want to change the function signatures.

Let us consider a concrete example. Maybe someone designed the programming interface so that you have to access the values from a map using an index. 

 

Using RAII to remedy defect where not all code paths performed required exit actions -- Raymond Chen

By Blog Staff | Nov 28, 2025 03:22 PM | Tags: None

A missing DismissUI() call on one code path led to a subtle bug—but rather than patching it with more try/catch and return logic, there’s a cleaner C++ solution. This article shows how to use RAII and wil::scope_exit to guarantee cleanup across all code paths, even in asynchronous callbacks.

Using RAII to remedy a defect where not all code paths performed required exit actions

by Raymond Chen

From the article:

A team asked me to review their pull request that fixed a bug that was caused by failing to perform some required action along all code paths. Here’s a simplified sketch:

void MySpecialFeature::OnButtonClick()
{
    try {
        auto file = PickFile();
        if (!file) {
            DismissUI();
            return;
        }

        if (ConfirmAction()) {
            if (m_useAlgorithm1) {
                // StartAlgorithm1 invokes the lambda when finished.
                StartAlgorithm1(file, [self = shared_from_this()] {
                    self->DismissUI();
                });
            } else {
                RunAlgorithm2(file);
                DismissUI();
            }
        } else { // this block was missing
           DismissUI(); 
        } 
    } catch (...) {
        DismissUI();
    }
}

Open wide: Inspecting LLVM 21 with static analysis

By Andrey Karpov | Nov 28, 2025 05:54 AM | Tags: static analysis sast pvs-studio llvm 21 llvm

It has been over a year since the last check of the LLVM project with PVS-Studio, and in that time, two releases have come out. So, it's a good time to get back and analyze the fresh LLVM 21.

Open wide: Inspecting LLVM 21 with static analysis

by Nikita Terentev

From the article:

As we can see, error logging will never be executed, and, moreover, execution will always continue with potentially incorrect behavior. Here's what git blame reports: the code celebrates its tenth anniversary in November. One might think its meaning had changed over time. But no, history confirms that Defs has always been DenseMap, and its count function only returned 0 or 1 back then. If we search for other similar checks, we see that the count result is used as a binary value everywhere.

How to Iterate through std::tuple: C++26 Packs and Expansion Statements -- Bartlomiej Filipek

By Blog Staff | Nov 25, 2025 02:54 PM | Tags: None

In this final part of the tuple-iteration mini-series, we move beyond C++20 and C++23 techniques to explore how C++26 finally brings first-class language support for compile-time iteration. With structured binding packs (P1061) and expansion statements (P1306), what once required clever template tricks can now be written in clean, expressive, modern C++.

C++ Templates: How to Iterate through std::tuple: C++26 Packs and Expansion Statements

by Bartlomiej Filipek

From the article:

In part 1 of this mini-series, we looked at the basics of iterating over a std::tuple using index_sequence and fold expressions. In part 2, we simplified things with std::apply and even created helpers like for_each_tuple and transform_tuple.

So far, we used C++ features up to C++20/23… but now, in C++26, we finally get language-level tools that make tuple iteration straightforward and expressive. In this article, we’ll explore two new techniques:

• Structured bindings can introduce a pack - P1061 - turn a tuple into a pack of variables.
• Expansion statements P1306 - the ultimate “compile-time loop” syntax.