Ein Blog

Posts mit Tag "cpp"

C++ wird ja von einem Komittee designt, das auch gern mal etwas over-engineert. Vielleicht kennt ihr Spec# oder Sing#. Zentraler Teil ist dort, dass eine Methode Pre- und Postconditions haben kann, damit automatisierte Verifikationstools (optimal im Compiler selbst) das Programm besser auf Korrektheit prüfen kann.

Hier ist das in C++: Contracts

Vielleicht habt ihr ja schonmal von Ladybird gehört. Das ist der Versuch eines ehemaligen WebKit-Engineers, eine weitere, komplett unabhängige Browser-Engine neben Gecko, Blink und WebKit aufzubauen und etwas mehr Diversität zu schaffen. Die Sponsoren können sich sehen lassen.

Ladybird ist aktuell zum Großteil in C++ geschrieben. Das wollten sie ändern und auf eine sichere Sprache wechseln. Zur überraschung vieler wurde Swift und nicht Rust gewählt. Die Wahl kann ich verstehen, denn Swift bietet built-in Support für C++-Interop (wofür Google eine eigene Sprache baut) und hat mittlerweile auch Ownership & Borrowing, analog zu Rust. Man kommt in Swift mittlerweile auch ohne GC aus. Als Grund nannten sie damals auch, dass die DOM-Apis im Browser allesamt eher Objektorientiert sind und das in C++/Swift besser abbildbar ist, als in Rust, wo sehr oft auf Immutability gesetzt wird. Auch ein großer Faktor wird gewesen sein, dass der Owner früher bei Apple war.

Sagten wir, wir machen Swift und nicht C++? Nein, doch nicht. Nur C++.

Und es kommt doch noch anders: Ladybird adopts Rust. tldr: Andreas Kling hat mit KI die JavaScript-Engine von C++ nach Rust portiert und ist jetzt überzeugt, dass es für den Rest des Browsers funktioniert.

Schade, dass es nicht bei Swift geblieben ist, ich finde die Sprache sehr unterschätzt.

C++ Modules are here to stay.

Der Post liest sich viel zu positiv. “So einfach” kann es doch gar nicht sein, das würde ich von C++ nicht erwarten. Da gibt es in der Praxis dann bestimmt noch ein paar hässliche Sachen. Das “ultra fast run script” hat auch schon viel zu viele Einstellungen, die es tut.

V8 verwendet ja Pointer Tagging, um optimiert mit Zahlen zu arbeiten. Wer sowas selbst mal einsetzen will: Pointer Tagging in C++: The Art of Packing Bits Into a Pointer

C++ 26 ist fertig. Hier noch ein Video.

Andrew Kelley bei CppCast über Zig. Hier ist er auch noch bei einem anderen Podcast.

cppinsights: See your source code with the eyes of a compiler.

Beispiel aus dem Readme:

class Base {};
class Derived : public Base {};
int main() {
  Derived d;
  Derived d2 = d;
  d2 = d;
  Base& b = d;
}

Wird zu:

class Base
{
  public:
  // inline constexpr Base() noexcept = default;
  // inline constexpr Base(const Base &) noexcept = default;
  // inline constexpr Base & operator=(const Base &) noexcept = default;
};
class Derived : public Base
{
  public:
  // inline constexpr Derived() noexcept = default;
  // inline constexpr Derived(const Derived &) noexcept = default;
  // inline constexpr Derived & operator=(const Derived &) noexcept = default;
};
int main()
{
  Derived d;
  Derived d2 = Derived(d);
  d2.operator=(d);
  Base & b = static_cast<Base&>(d);
  return 0;
}

Apple sucht Compiler-Leute, die den Interop von Swift und C++ verbessern.

Swift ist IMHO eine wirklich unterschätzte Sprache. Die haben keine Angst vor breaking Changes und trotzdem schaffen sie es, kein Python 3 zu erzeugen. Der Code ist üblicherweise sehr lesbar und seit einiger Zeit haben sie sogar ein Ownership-Modell, das zwar etwas verboser ist, aber IMHO deutlich verständlicher als das von Rust ist. Vielleicht wären sie populärer geworden, wenn Linux- und Windows-Support nicht so lange gedauert hätte, wer weiß ¯\_(ツ)_/¯

TIL: Dieses Pattern, wo eine Basisklasse sich selbst als Template (oder Typparameter) übergibt, hat einen Namen:

template <class T>
class Base
{
    // methods within Base can use template to access members of Derived
};
class Derived : public Base<Derived>
{
    // ...
};

Name: Curiously recurring template pattern

Es ist komplett an mir vorbei gegangen, dass C23 verabschieded wurde.

Meine Highlights:

  • signed Integer sind jetzt definiert als Zweierkomplement
  • #embed, womit man Rohdaten aus anderen Dateien inkludieren kann, z. B. in einem C-Array. Das wird so einige Buildprozesse vereinfachen.
  • Enums können jetzt einen zugrundeliegenden Typen haben: enum e : unsigned short { x };
  • Es gibt jetzt nullptr (und nullptr_t) auch in C
  • true und false sind jetzt Keywords
  • 0b-Literale

Außerdem gibt es noch bessere Kompatibilität zwischen gleichförmigen Structs. Mit N3003 wird dieser Generics-Hack nun viable (Codebeispiel von Reddit übernommen):

#include <stdio.h>
#include <stdlib.h>

#define Vec(T) struct Vec__##T { T *at; size_t _len; }

#define vec_push(a,v) ((a)->at = realloc((a)->at, ++(a)->_len), (a)->at[(a)->_len - 1] = (v))
#define vec_len(a) ((a)._len)

void fill(Vec(int) *vec) {
    for (int i = 0; i < 10; i += 2)
        vec_push(vec, i);
}

int main() {
    Vec(int) x = { 0 }; // or = {} in C2x
    // pre C2x you'd need to typedef Vec(int) to make the pointers compatible and use it for `x` and in fill:
    // --v
    fill(&x);
    for (size_t i = 0; i < vec_len(x); ++i)
        printf("%d\n", x.at[i]);
}

Auf cppreference gibt es auch noch eine kleine Übersicht der Änderungen.

Ein sehr interessanter Talk über undefined behaviour in C und C++: Garbage In, Garbage Out: Arguing about Undefined Behavior von Chandler Carruth; entwickelt für Google an LLVM und Clang.

Er erklärt, warum UB im Kontext von C und C++ Sinn ergibt, gibt ein paar Beispiele und reflektiert, was für Fehler man im Standard und bei den Implementierungen gemacht hat.

Zig kann Hot-Code-Reloading. Bei VS kam das für C++ erst in VS 2022. .NET kann es auch seit Version 6.

On finding the average of two unsigned integers without overflow.

Enthält auch eine (ehemalig) patentierte Variante.

Gut gefällt mir auch der untere Part:

Bonus chatter: C++20 adds a std::midpoint function that calculates the average of two values (rounding toward a). Bonus viewing: std::midpoint? How hard could it be? (Vortrag geht eine Stunde)

Habt Ihr UB in einem C++-Programm? Oder Implementation-Defined Behavior (IB)? Vielleicht kennt Ihr den Spruch, dass der Compiler absolut alles machen kann, wenn er UB oder IB findet. GCC startet ggf. ein Spiel.

TIL: restrict in C hat kein Äquivalentes Konzept in C++. Ist vielleicht auch ganz gut so. Sowas sollte eher vom Compiler enforced werden.

Falls Ihr ein neues C/C++-Projekt anlegt und Euch fragt, welche Compiler-Flags Ihr so gesetzt haben solltet. Hier schreibt RedHat was darüber. Ihr solltet natürlich schauen, dass die Flags zu Eurem Vorhaben passen. Für Embedded-Software gibt’s hier auch einen Eintrag.

Wer noch andere kennt oder Verbesserungen hat, her damit!