The ongoing discussion about the future of C++ is characterized by two closely connected themes: complexity and safety. Both concepts are frequently oversimplified in public discourse, often reduced solely to memory management. Yet safety encompasses far more: functional correctness, deterministic and high-performance execution, efficient use of resources, architectural stability, type consistency, robust concurrency models, and an explicit sense of ecological responsibility. Taken together, these aspects determine whether software can operate sustainably, reliably, and responsibly.

Introduction

C++ is not too complex. Its depth is a direct consequence of its universal ambition: the language is designed to be used across vastly different domains, from embedded systems to high-performance computing architectures. Many languages are simpler in specialized scenarios, but C++ is not a niche tool; it is a universal one. This versatility naturally introduces complexity, demands experience, and in return enables exceptional efficiency and expressive power.

In this context, the Profiles proposed for C++26 are particularly significant. Bjarne Stroustrup has repeatedly emphasized that Profiles are a crucial step toward structuring C++’s complexity in a selective and controlled manner, without abandoning the fundamental principles of the language. Profiles define graded safety levels, support different usage contexts, and uphold a core value Stroustrup continually stresses: “Never break the code.”
C++26 will also introduce Contracts and a revised model for memory initialization, both of which will strongly influence safety and correctness. This makes early investment by compiler vendors essential. The same applies to the Embarcadero ecosystem, which traditionally operates more isolated and showed significant delays in adopting C++20 and C++23. Although the current C++Builder finally provides support for C++23, a noticeable gap remains compared to vendors that adopted new standards much earlier. It is therefore all the more important to invest consistently in C++26 now to avoid repeating these delays.

These considerations highlight why the original article from March 2023 is even more relevant today. The discussion at the time emerged from a livestream in which I presented an architecture built on a multiparadigm approach combining virtual (partial) inheritance, variadic templates, and concepts. The debate that followed later resulted in talks at ADC++ 2023 and the Tech Stream Conference 2023. This updated edition connects those insights with current developments.

---

Is C++ Too Complex?

I have frequently read comparisons of other languages and technologies with C++. They all share a common pattern: developers and journalists compare their language to C++ — not the other way around. Unsurprisingly, they tend to find in C++ precisely the features they already know from their own language. Sometimes they highlight examples where C++ supposedly cannot do something, and from that they conclude their language must be equally powerful or efficient. In doing so, they often overlook that C++23—and soon C++26—unifies multiple paradigms and provides capabilities that extend far beyond traditional object-oriented or functional programming models.

Such comparisons may be correct in narrow specialized cases and may even appear simpler. But C++ is not a specialized language. It is a universal language designed to address a wide range of problem domains—from event-driven systems and ultra-low-latency architectures to numerically intensive simulations. This universality naturally introduces complexity, while enabling solutions far beyond what many other languages can deliver.

It is often claimed that other languages produce programs just as fast. Genuine comparisons, however, are rare. With the exception of highly specialized scenarios, only few languages come close to C++ in terms of performance, efficiency, and sustainable resource usage. These dimensions also carry ecological implications that have received far too little attention in public debates.

Are These Comparisons Even Accurate?

Goethe once wrote that everyone hears only what they understand. This principle applies equally to technical comparisons. Since many people evaluate only a small portion of C++, they form distorted impressions. The reactions of experienced C++ developers then often seem incomprehensible to them. As with many kinds of misinformation, the simpler narrative tends to prevail. Yet a broader use of modern C++ features and better education could save substantial amounts of energy.

In March 2023, my livestream focused on virtual partial inheritance, the so-called diamond problem, and the alleged difficulties associated with it. The key insight is that C++ is a multiparadigm language. Multiple inheritance is not a flaw but a deliberate and powerful tool. Combined with templates, concepts, metaprogramming, and variadic templates, it becomes an extremely capable mechanism for structuring large-scale architectures. The interplay of these paradigms enables flexible, modular systems composed of independent building blocks.

We once called this pattern Ping-Pong Implementation, because the structure resembles a back-and-forth interaction between classes, creating modular components that behave like a box of LEGO bricks. While many developers follow current hypes, C++ offers alternative high-efficiency solutions that often go unnoticed. One viewer remarked ironically at the time that according to today’s common logic, the demonstrated architecture must be a monolith simply because it was not built using stateless design and Docker.

It was remarkable that even long-time C++ developers in the audience expressed surprise. Statements such as “So there is no diamond problem?” revealed how deeply rooted some misconceptions remain. Many of these myths do not stem from shortcomings in the language, but from missing knowledge about modern C++ techniques.

Education, Average Solutions, and Convenience

One might assume that C++ is too complex. But that is not why other languages are often preferred. Instead, education tends to focus on average solutions, often centering on Java, C#, or Python. Many rules and patterns from those languages are unsuitable or unnecessary in C++. C++ developers frequently adopt them out of convenience or lack of differentiation.

Reactions in the livestream such as “I’ve never read that anywhere” or “I’ve never heard of that” clearly highlight these knowledge gaps. Studies indicate that systems written in Java or C# could save between fifteen and thirty percent in energy consumption, while Python-based systems could save fifty percent or more. Security and energy efficiency are not opposing goals—they reinforce each other.

Comparisons With C++ Must Be Complete

Anyone wishing to compare languages must compare against all of C++, not just the subset they understand. Otherwise, the situation resembles the legend of Indigenous Americans who allegedly could not see Columbus’s ships until a shaman interpreted the changes in the waves. Without context, much remains invisible.

---

Conclusion

C++ is not a language one can learn casually or judge superficially. Its strength does not lie in simplicity but in depth, and that depth is its true value. To understand C++, one must accept that universal tools require nuanced perspectives and that modern software development demands far more than choosing the easiest option. Safety, correctness, performance, and efficiency are not contradictions; they represent a shared objective that we as engineers must uphold. In a world increasingly aware of ecological responsibility, we can no longer ignore the cost of inefficient software.

The modern features of C++23 and the direction of C++26 show that the language evolves without abandoning its core principles. Profiles, Contracts, improved initialization guarantees, and stronger compile-time validation are not restrictions—they are steps toward clearer structure, improved maintainability, and more sustainable architecture. At the same time, they remind us that we must continually refine and expand our understanding of these tools.

If we evaluate C++ only through simplified comparisons with other languages, we fail to see its intended purpose. C++ remains a universal language whose multiparadigm capabilities enable solutions far beyond the reach of many specialized tools. It demands responsibility, yet it provides the precision and efficiency increasingly required in a data-driven world.

Ultimately, it is not the language that determines the quality of our systems, but our understanding of what it empowers us to create. C++ has offered these possibilities for decades. It is up to us to use them, teach them, and move them forward.

---

Why not download a free trial of C++Builder today and see why we think it’s the fastest, easiest, and most efficient way to create modern apps?