C++Builder 13 Florence: Ein Schritt in die Zukunft der C++-Entwicklung

Heute habe ich den Blogbeitrag von Marco Cantù gelesen, in dem er eine erste Vorschau auf C++Builder 13 mit dem Codename Florence, gewährt. Dieser Beitrag hat meine Neugier geweckt, denn zum ersten Mal seit vielen Jahren deutet sich an, dass Embarcadero seine Entwicklungsumgebung für C++ aus der Vergangenheit befreit und in die Gegenwart moderner C++-Programmierung führt.

Der C++Builder war in der Vergangenheit sehr beliebt, weil er eine einzigartige Stärke besaß: die einfache Integration von Oberflächen, Servertechnologien und Datenbanken in einer Entwicklungsumgebung. Damit hatte er eine Alleinstellung, denn während man bei anderen Compilern meist auf diverse Drittbibliotheken zurückgreifen musste – oder gleich auf Qt setzte, das im kommerziellen Bereich schnell teuer und technologisch anspruchsvoll wurde – konnte man mit C++Builder von Einsteigern bis zu Profis alles abdecken. Doch die fehlende Weiterentwicklung im Bereich moderner C++-Standards hat viele Kunden enttäuscht und letztlich entfremdet. Manche fanden sich in einer technologischen Sackgasse wieder, gefangen in proprietären Erweiterungen, ohne eine klare Perspektive für die Zukunft. Genau deshalb ist es von fundamentaler Bedeutung, dass Embarcadero nun die Zeichen der Zeit erkannt hat und mit Florence versucht, die Lücke zu anderen Compilern wieder zu schließen.

Schon der Name Florence, in Anlehnung an die italienische Stadt Florenz, vermittelt den Eindruck von Aufbruch, Renaissance und Wiederentdeckung. Nach vielen Jahren, in denen C++Builder seinen Anwendern nur eingeschränkten Zugang zu aktuellen Sprachmitteln geboten hat, bringt dieses Release den großen Sprung: Der neue Compiler basiert auf Clang 20 und öffnet damit den Weg in die Welt von C++20 und C++23. Die angekündigte Präsentation im Webinar am 10. September 2025 wird diesen Schritt offiziell machen, und man kann bereits heute sagen, dass dies mehr als ein Versionssprung ist: Es ist der Beginn einer neuen Epoche für Embarcadero und seine Entwicklergemeinschaft.

C++20 als neues Fundament

Modernes C++ beginnt im Jahr 2011 mit der Version C++11. Danach wurde die Entwicklung über die Versionen C++14 und C++17 fortgesetzt, und hat viele atemberaubenden Veränderungen gebracht.Ich möchte hier nur die move Semantik, die RValues Referenzen, variadic templates und viele Erweiterungen für die Metaprogrammierung und funktionale Entwicklung. Dazu kamen threads und task.

Mit C++20 hat die Sprache einen weiteren historischen Einschnitt erfahren, und in einigen Punkten wird die Entwicklung der Vorjahre abgeschlossen. Lange ersehnte Sprachmittel sind Realität geworden und haben die Entwicklungspraxis grundlegend verändert. Concepts erlauben es, Typparameter klar und präzise zu beschreiben, wodurch generische Programmierung sicherer und verständlicher wird. Ranges führen einen völlig neuen Stil ein, der es ermöglicht, Datenflüsse deklarativ und lesbar in Pipelines auszudrücken, und damit einen Paradigmenwechsel im Umgang mit Sequenzen einläutet. Coroutinen wiederum stellen einen Quantensprung für asynchrone und nebenläufige Programmierung dar, indem sie mit den Schlüsselwörtern co_await, co_yield und co_return einen lesbaren und eleganten Kontrollfluss schaffen.

Hinzu kommt std::span, ein unscheinbarer, aber mächtiger Typ, der es erlaubt, Bereiche im Speicher effizient zu adressieren, ohne unnötige Kopien zu erzeugen. Gerade für hardwarenahe Anwendungen, numerische Algorithmen oder allgemeine Bibliotheken ist dies von unschätzbarem Wert. Auch die kontinuierliche Weiterentwicklung von Lambdas und Templates, etwa durch constexpr-Lambdas, hat die Ausdruckskraft generischen Codes erheblich gesteigert. Schließlich brachte C++20 mit std::format ein modernes Werkzeug für typsichere und elegante Ausgaben und mit std::chrono tiefgreifende Neuerungen: Zeitzonen, Kalenderunterstützung, Uhrzeiten und klare Konzepte für die Darstellung des Kalenders und der Uhrzeit. Damit ist eine Grundlage geschaffen, die endlich eine robuste Handhabung von Zeit in globalen Anwendungen erlaubt.

C++23 als Fortführung und Verfeinerung

Auf diesem Fundament baut C++23 auf und bringt die Sprache in noch größere Nähe zu den Bedürfnissen der Praxis. Die Bibliothek wächst um std::mdspan, eine multidimensionale Erweiterung von std::span, die generische Schnittstellen für Arrays und Matrizen eröffnet. Sie ist für numerische Berechnungen, wissenschaftliche Simulationen oder hardwareoptimierte Algorithmen unverzichtbar.

Auch die Ranges-Bibliothek wurde erweitert und gestärkt, ich möchte hier examplarisch nur std::views::chunk, std::views::slide, std::views::zip, std::views::enumerate und std::ranges::to weiter gestärkt, wodurch sich komplexe Iterationen deklarativ formulieren lassen und Ergebnisse direkt in Container wie Vektoren, Maps oder Sets überführt werden können. Coroutinen erfahren eine weitere Verfeinerung, und mit Generatoren hält ein Sprachmittel Einzug, das lazy evaluation und kooperatives Multitasking elegant möglich macht. Hinzu kommt mit deducing this eine Erweiterung der Methodendeklaration, die Member-Funktionen generischer und flexibler macht, weil der this-Parameter nun automatisch deduziert werden kann.

Auch std::chrono wird weiter ausgebaut. Während C++20 die grundlegenden Bausteine für Zeitzonen und Kalender geliefert hat, bringt C++23 die Fähigkeit, diese Typen sauber zu parsen und auszugeben. Damit wächst die Sprache zu einer Lösung, die nicht nur auf dem Papier robust ist, sondern in der Praxis international einsetzbar wird.

Florence auf Basis von Clang 20

Die Entscheidung, Florence auf Clang 20 aufzubauen, ist strategisch von höchster Bedeutung. Clang ist nicht nur ein moderner und standardnaher Compiler, sondern Teil der LLVM-Infrastruktur, die seit Jahren eine treibende Kraft hinter der Standardisierung von C++ ist, und von Firmen wie Google, Apple und Microsoft genutzt und unterstützt wird. Damit erhält C++Builder eine Grundlage, die nicht nur den heutigen Stand von C++20 und C++23 abbilden kann, sondern auch für die kommenden Entwicklungen gerüstet ist. Florence wird damit nicht zu einem kurzen Hoffnungsschimmer, sondern zur Brücke in eine moderne und zukunftsfähige Welt des C++.

Entwicklung im Überblick

flowchart LR
    A["C++17"] --> B["C++20"]
    B --> C["C++23"]

    A -->|"structured bindings parallel algorithms"| B
    B -->|"Concepts, Ranges, Coroutine, span, chrono (Zeitzonen, Kalender, Uhrzeiten^)"| C
    C -->|"mdspan, deducing this, Generator, Ranges Extensions (zip, enumerate, to), chrono IO"| D["Moderne Anwendungen"]

Ausblick und persönliches Versprechen

Am 10. September 2025 wird Embarcadero Florence im Detail vorstellen. Schon heute lässt sich erkennen, dass dieses Release mehr ist als nur eine neue Versionsnummer. Es ist der Versuch, den Rückstand vergangener Jahre aufzuholen und den Entwicklerinnen und Entwicklern wieder eine Plattform zu geben, die auf Augenhöhe mit modernen C++-Standards agiert.

Ich sehe darin nicht nur eine Chance für Embarcadero, sondern auch für alle, die mit der Plattform arbeiten. Sollte Florence die angekündigten Eigenschaften wirklich liefern, werde ich meine im Rahmen des adecc Scholar Streams entwickelte Metaprogramming-Bibliothek, die bereits auf C++20 und C++23 basiert, um eine Anbindung an die Firedac®-Bibliothek erweitern. Damit wird es möglich, dass die Oberfläche der adecc Scholar-Bibliothek ebenso wie die Datenbankzugriffe nahtlos sowohl auf Qt6 als auch auf VCL, FMX und Firedac® nutzbar sind.

Und noch ein Schritt ist geplant: Nach der offiziellen Freigabe von C++Builder 13 Florence werden wir nicht nur Artikel, sondern auch Webinare anbieten. Dort wollen wir zeigen, dass modernes C++ anders ist: robuster, sicherer und schneller. Florence wird, so hoffe ich, nicht nur den Anschluss herstellen, sondern den Weg in eine lebendige und innovative Zukunft der C++-Entwicklung eröffnen.