C++26: Bekommt die Programmiersprache Contracts und Reflexion?

Kurz vor dem geplanten offiziellen Start von C++23 hat sich das ISO-C++-Komitee bereits zum zweiten Mal getroffen, um den nächsten Standard C++26 vorzubereiten. Bereits beim Treffen im Juni hatte der Beirat 40 Vorschläge wie den Unterstrich _ als namenlosen Platzhalter für C++26 akzeptiert.

Nun hat das Komitee vier weitere Änderungen in der Sprache und 19 in der Standard Library in C++26 aufgenommen. Zwei größere Neuerungen sind laut dem jüngsten Trip-Report von Herb Sutter zwar für C++26 noch nicht beschlossen, aber gut auf Kurs: Contracts und Reflexion.

Verträge mit Funktionen

Eigentlich sollten Contracts bereits in C++20 enthalten sein, aber seinerzeit gab es zu viele Meinungsverschiedenheiten bezüglich des Designs bei der Umsetzung. Das Design-by-Contract-Prinzip hat seinen Ursprung in der von Bertrand Meyer entwickelten Programmiersprache Eiffel. Es soll für ein reibungsloses Zusammenspiel einzelner Softwarekomponenten sorgen.

Der aufrufende Kontext schließt dabei einen Vertrag (Contract) mit einer Funktion oder Methode ab, der aus Vor- und Nachbedingungen besteht. Der Aufrufer hat dafür zu sorgen, dass die Vorbedingungen erfüllt sind, und die aufgerufene Funktion ist dafür verantwortlich, dass beim Beenden die Nachbedingungen gelten. Beide Arten der Vertragsbedingungen sind außerhalb der Funktion festgelegt.

Hinzu kommen Invarianten, also unveränderliche Aussagen, die gelten müssen, während die Funktion ausgeführt wird. Die Überprüfung findet über Assertions innerhalb der Funktion statt, die im Gegensatz zu den Vor- und Nachbedingungen auf lokale Variablen zugreifen können.

Auf dem jüngsten Meeting hat sich das Komitee auf eine Syntax für Contracts geeinigt, die im Vergleich zu dem vorherigen Vorschlag auf die bisher vorgesehen doppelten Klammern für die Bedingungen verzichtet und das Schlüsselwort assert durch contract_assert ersetzt, um Inkompatibilitäten zu vermeiden. Herb Sutter zeigt in seinem Blogbeitrag dafür folgendes Beispiel:

// neue Syntax für Contracts:
int f(int i)
    pre (i >= 0)
    post (r: r > 0)
{
    contract_assert (i >= 0);
    return i+1;
}

// zuvor geplante Syntax:
int f(int i)
    [[pre: i >= 0]]
    [[post r: r > 0]]
{
    [[assert: i >= 0]]
    return i+1;
}

Reflektiert betrachtet

Reflexion ist ein weiteres wichtiges Konzept, das C++ im Gegensatz zu vielen anderen Sprachen wie C#, Java, Python oder PHP bisher nicht kennt. Das soll sich ebenfalls mit C++26 ändern. Mittels Reflexion kann ein Programm zur Compile-Zeit – nicht dynamisch wie unter anderem in Java – auf die eigene Struktur zugreifen und beispielsweise Informationen zur Struktur von Klassen und Methoden abrufen und sie sogar verändern.

Das ISO-C++-Komitee hat sich nun einstimmig für das Proposal mit dem Titel "Reflection for C++26" entschieden. Es basiert auf zwei früheren Vorschlägen, die im Titel ihre Wurzeln bei JavaScript beziehungsweise Python zeigen: "Using Reflection to Replace a Metalanguage for Generating JS Bindings" und "Python bindings with value-based reflection".

Das nun für C++26 vorgesehene Proposal zeigt die geplante Syntax anhand eines typischen Beispiels für Reflexion: das Umwandeln eines Enum zu einem String:

template <typename E>
  requires std::is_enum_v<E>
constexpr std::string enum_to_string(E value) {
  template for (constexpr auto e : std::meta::members_of(^E)) {
    if (value == [:e:]) {
      return std::string(std::meta::name_of(e));
    }
  }

  return "<unnamed>";
}

enum Color { red, green, blue };
static_assert(enum_to_string(Color::red) == "red");
static_assert(enum_to_string(Color(42)) == "<unnamed>");

Weitere Details zu den beiden geplanten Neuerungen für C++26 sowie den kleineren, teilweise bereits akzeptierten, lassen sich dem Blogbeitrag von Herb Sutter entnehmen.

Derweil steht vermutlich im Dezember der Start von C++23 an, das inhaltlich bereits seit Mitte des Jahres fertig ist, aber noch auf die Freigabe nach der Abstimmungsphase wartet.

(rme)