Zig Basics

Zig programmieren für Einsteiger

David Pierre Sugar

Zig Basics
David Pierre Sugar

Copyright © 2024 David Pierre Sugar. All rights reserved.

Munich, Germany 2024: First Edition (beta)

Self Publishers Worldwide

Seattle San Francisco New York
London Paris Rome Beijing Barcelona
Für Franzi und Pierre.
Inhaltsverzeichnis
Zig Crash Course ........................................................................................................................................... 1
Zig installieren .......................................................................................................................................... 1
Linux ..................................................................................................................................................... 1
Windows .............................................................................................................................................. 3
Compiler Grundlagen ............................................................................................................................. 7
Funktionen .............................................................................................................................................. 10
Unit Tests ................................................................................................................................................. 11
Comptime ................................................................................................................................................ 12
Kryptographie ......................................................................................................................................... 16
Graphische Applikationen ................................................................................................................... 22
Installation unter Linux .................................................................................................................. 23
Installation unter Windows ........................................................................................................... 23
Projekt anlegen ................................................................................................................................. 24
Die Anwendung ............................................................................................................................... 25
Zig als C Build-System ......................................................................................................................... 30
Bibliothek schreiben ........................................................................................................................ 30
Bibliothek einbinden ....................................................................................................................... 32
Grundlagen .................................................................................................................................................... 37
Konstanten und Variablen ................................................................................................................... 38
Variablen-Deklarationen ................................................................................................................ 38
Typ-Annotationen ........................................................................................................................... 38
Variablen benennen ......................................................................................................................... 39
Lokale Variablen ............................................................................................................................... 40
Container-Level Variablen ............................................................................................................. 41
Statisch-lokale Variablen ................................................................................................................ 41
Kommentare ............................................................................................................................................ 42
Ganzzahlen (Integer) ............................................................................................................................. 43
Darstellung von Integern im Speicher ........................................................................................ 44
Integer-Literale ................................................................................................................................. 44
Laufzeit-Variablen ............................................................................................................................ 45
Integer-Operatoren .......................................................................................................................... 45
Integer-Bounds ................................................................................................................................. 46
Fließkommazahlen (Float) ................................................................................................................... 46
Float-Literale ..................................................................................................................................... 47
Darstellung von Floats im Speicher ............................................................................................. 47
Konvertierung von numerischen Typen .......................................................................................... 48
Integer Konvertierung .................................................................................................................... 48
Float Konvertierung ........................................................................................................................ 49
Typen Alias ............................................................................................................................................. 50
Booleans ................................................................................................................................................... 50
defer .......................................................................................................................................................... 51
 Optionals .................................................................................................................................................. 52
null ....................................................................................................................................................... 53
Zeiger (Pointer) ...................................................................................................................................... 55
Arrays und Slices ................................................................................................................................... 56
Arrays ................................................................................................................................................. 58
Slices ................................................................................................................................................... 59
Sentinel-Terminierte Slices ............................................................................................................ 61
Padding ............................................................................................................................................... 62
Errors ........................................................................................................................................................ 63
Error-Set Coercion ........................................................................................................................... 64
Globales Error-Set ............................................................................................................................ 65
catch .................................................................................................................................................... 65
try ........................................................................................................................................................ 66
errdefer ............................................................................................................................................... 67
Error-Sets zusammenführen ......................................................................................................... 67
Speicherverwaltung .................................................................................................................................... 69
Grundlagen .............................................................................................................................................. 69
Lifetimes ................................................................................................................................................... 72
Static Memory ................................................................................................................................... 72
Automatic Memory ......................................................................................................................... 73
Dynamic Memory ............................................................................................................................ 77
Häufige Fehler ........................................................................................................................................ 80
Speicherzugriffsfehler (Access Errors) ........................................................................................ 80
Buffer Overflow/ Over-Read .................................................................................................... 80
Invalid Page Fault ....................................................................................................................... 81
Use After Free ............................................................................................................................. 81
Zusammenfassung ................................................................................................................................. 82
Hands-On: Taschenrechner ....................................................................................................................... 83
Projekt anlegen ....................................................................................................................................... 84
Hello dvui ................................................................................................................................................ 85
User Interface .......................................................................................................................................... 87
Zustände Bitte ......................................................................................................................................... 92
Ausdruck Evaluieren ............................................................................................................................. 95
Refactoring .............................................................................................................................................. 97
Zusammenfassung ............................................................................................................................... 100
Control Flow ............................................................................................................................................... 101
Bedingte Anweisungen ...................................................................................................................... 101
If ......................................................................................................................................................... 101
If mit Errors ..................................................................................................................................... 103
If mit Optionals .............................................................................................................................. 104
Pointer-Capture .............................................................................................................................. 105
Switch ............................................................................................................................................... 105
While-Schleifen .................................................................................................................................... 108
For-Schleifen ......................................................................................................................................... 108
 Vorwort

Zig ist eine Sprache geeignet für die Systemprogrammierung.

Das alleine macht Zig nicht besonders, jedoch verheiratet Zig die Simplizität von C mit vielen
modernen Features, was vor allem Neulingen, die eine systemnahe Programmiersprache lernen
wollen, zugute kommt.
Zig als Systemprogrammiersprache ist unter anderem geeignet für:
• Kryptographie
• Mikrokontrollerprogrammierung
• Dateisysteme
• Datenbanken
• Betriebssysteme
• Treiber
• Spiele
• Simulationen
• Networking
• Security-Tooling
• Die Entwicklung von höheren Programmiersprachen
Insbesondere Startups, aber auch große Unternehmen, haben in den letzten Jahren auf Zig als
Programmiersprache und Build-System gesetzt. Darunter Uber1, Tigerbeetle2, ZML3 und KPMG4.
Diese verwenden Zig in ganz unterschiedlichen Anwendungsbereichen, darunter Datenbanken,
maschinellem Lernen und Computer-Security.
In der Welt der Systemprogrammiersprachen reiht sich Zig neben C ein und verzichtet auf viele
Konzepte die andere Programmiersprachen überkomplex machen, darunter Vererbung. Damit ist
Zig erfrischend übersichtlich, was vor allem Einsteigern zu gute kommt, bietet jedoch auch viele
Verbesserungen gegenüber C. Ein wichtiger Fokus liegt auf der Lesbarkeit des Codes, d.h. was
man sieht wird vom Computer später auch tatsächlich so ausgeführt (mit Abstrichen natürlich).

[Link]
1

[Link]
2

3 [Link]

4 [Link]

[Link]
Insbesondere bedeutet das: keine versteckten Allokationen, bei denen die Sprache ohne Zutun
des Entwicklers dynamisch Speicher alloziert. Alles was mit der Allokation von dynamischem
Speicher zu tun hat ist in Zig explizit!
Fun-Fact: Während der StackOverflow 2024 Developer Survey5 gaben 6.2% der Befragten an
„umfangreiche Entwicklungsarbeiten“ in Zig getätigt zu haben und 73.8% wollen die Sprache
im kommenden Jahr (2025) nutzen. Damit ist Zig trotz seines Alpha-Status eine gern genutzte
Programmiersprache und reiht sich von der Zahl der Anwender neben Sprachen wie Swift, Dart,
Elixir und Ruby ein.

Zielgruppe
Falls Sie bereits Erfahrung mit C oder einer anderen systemnahen Programmiersprache haben
und mehr über Zig erfahren wollen ist diese Buch für Sie. Wenn Sie Erfahrung mit einer höheren
Programmiersprache haben und mehr über Systemprogrammierung und Zig erfahren wollen ist
dieses Buch ebenfalls für Sie.
Grundsätzlich empfehle ich Ihnen parallel zum lesen dieses Buches eigene Programmierprojekte
zu realisieren um praktische Erfahrung mit der Sprache zu sammeln. Beginnen Sie mit etwas
einfachem, vertrauten und steigern Sie sich, sobald Sie ein Gefühl für die Sprache bekommen
haben. Sie werden merken, dass die Grundlagen in Zig schnell zu erlernen sind, es gibt jedoch
auch nach einiger Zeit viel zu entdecken. Sollten Sie etwas Inspiration benötigen, so kann Ihnen
Project Euler6 eventuell weiterhelfen.
Wichtig zu erwähnen ist, dass Zig derzeit noch nicht die Version 1.0 erreicht hat, d.h. die Sprache
und damit auch die Standardbibliothek werden sich in Zukunft noch ändern. Damit kann es sein,
dass bestimmte Beispiele mit einer zukünftigen Zig-Compiler-Version nicht mehr compilieren.
Sollte das für Sie ein Dealbreaker sein, so empfehle ich Ihnen die Finger von diesem Buch zu
lassen und zu warten bis Zig Version 1.0 veröffentlicht wurde.

Voraussetzungen
Die Zig-Version, die in diesem Buch verwendet wird ist 0.13.07. Je nachdem wann Sie dieses Buch
lesen kann es sein, dass diese Version nicht mehr aktuell ist. Bei Abweichungen von der angege-
benen Version ist nicht garantiert, dass die in diesem Buch abgebildeten Beispiele compilieren.
Zwar sind die meisten Konzepte und Beispiele in diesem Buch unabhängig von einem bestimm-
ten Betriebssystem und Architektur, jedoch geht das Buch grundsätzlich von einem x86_64 Linux
System aus. Dies wird relevant wenn auf Assembler, Calling-Conventions und ähnliche Konzepte
Bezug genommen wird, da diese immer sowohl von der Architektur als auch dem Betriebssystem
abhängen. Sollte Ihr Computer eine dieser Anforderungen nicht erfüllen, so empfiehlt es sich
ggf. ein virtuelle Maschine zu verwenden8.

5 [Link]
6 [Link]
7 [Link]

8 [Link]

overview
Struktur
Die ersten Kapitel beschäftigen sich mit den Grundlagen der Programmiersprache Zig. Das
erste Kapitel bietet anhand von Beispielen einen Überblick über die Sprache. Im zweiten Kapitel
werden die grundlegenden Datentypen der Programmiersprache näher beleuchtet. In Kapitel
drei wird der Leser in grundlegende Konzepte der Speicherverwaltung eingeführt, die für die
korrekte und sichere Entwicklung von Anwendungen unabdingbar sind. In Kapitel vier nutzen
wir das Gelernte und entwickeln wir einen kleinen, minimalistischen Taschenrechner. Kapitel
fünf geht näher auf If-Statements, Switch und Schleifen ein.
Diese Buch befindet sich noch im Entstehungsprozess, das heiß es wird nach und nach um
weitere Kapitel ergänzt. Weiterhin kann sich der Inhalt einzelner Kapitel ändern.
Zig bietet für jede Compiler-Version zusätzliche Ressourcen zum Lernen der Sprache und als
Referenz9, darunter die Language Reference und die Online-Dokumentation der Standardbiblio-
thek. Diese können beim Entwickeln eigener Projekte aber auch beim nachvollziehen der Code-
Beispiele eine große Hilfe darstellen.

Konventionen
Die folgenden Konventionen werden in diesem Buch eingehalten:
Italic: Markiert neue Begriffe, URLs, Email-Adressen, Dateinamen und -endungen.
Konstanter Abstand : Wird verwendet für Programmbeispiele, sowie zum benennen von Pro-
grammbausteinen, wie etwa Variablennamen oder Umgebungsvariablen.
Konstanter Abstand Fett : Zeigt Kommandos oder andern, vom Nutzer zu tippenden, Text.

Ziggy markiert einen Tipp bzw. einen Hinweis.

Code Beispiele
Die in diesem Buch abgebildeten Code-Beispiele finden sich auf Github unter todo zum Down-
load.
Alle Beispiele können von Ihnen ohne Einschränkung verwendet werden. Sie brauchen die
Autoren nicht explizit um Genehmigung fragen. Am Schluss geht es darum Ihnen zu helfen und
nicht darum Ihnen Steine in den Weg zu legen.
Zitierungen würden uns freuen, sind jedoch keinesfalls notwendig. Ein Zitat umfasst gewöhnlich
Titel, Autor, Publizist und ISBN. In diesem Fall wäre dies: ,,Zig Basics by David Pierre Sugar’‚.
Sollten Sie Fehler im Buch oder Code finden, die nicht auf unterschiedliche Compiler-Versionen
zurückzuführen sind können Sie uns mit einem Verbesserungsvorschlag kontaktieren.

9 [Link]
Fragen, Anmerkungen und Verbesserungen
Ich habe mein Bestes getan dieses Buch so informativ und technisch korrekt wie möglich zu
gestalten. Ich bin mir jedoch auch sicher, dass dieses Buch besser sein könnte als es gerade ist.
Sollten Sie Fehler finden oder generell Feedback zu diesem Buch geben wollen, so können Sie
mich unter david@[Link] kontaktieren. Dies gibt mir die Möglichkeit dieses Buch über die
Zeit zu verbessern. Es ist mir jedoch nicht immer möglich zu antworten. Nehmen Sie es sich
deswegen nicht zu Herzen wenn Sie nichts von mir hören.

Danksagung
TDB
Zig Basics

Kapitel 1

Zig Crash Course

In diesem Kapitel schauen wir uns einige kleine Zig Programme an, damit Sie ein Gespür für
die Programmiersprache bekommen. Machen Sie sich nicht zu viele Sorgen wenn Sie nicht alles
sofort verstehen, in den folgenden Kapiteln werden wir uns mit den hier vorkommenden Konzept
noch näher beschäftigen. Wichtig ist, dass Sie diese Kapitel nicht nur lesen sondern die Beispiel
auch ausführen, um das meiste aus diesem Kapitel herauszuholen.

Zig installieren
Um Zig zu installieren besuchen Sie die Seite [Link] und folgen den Instruktionen
unter „GET STARTED“10.
Die Installation ist unter allen Betriebssystemen relativ einfach durchzuführen. In der Download
Sektion11 finden Sie vorkompilierte Zig-Compiler für die gängigsten Betriebssysteme, darunter
Linux, macOS und Windows.

Linux
Unter Linux können Sie mit dem Befehl uname -a Ihre Architektur bestimmen. In meinem Fall
ist dies X86_64 .

$ uname -a
Linux ... x86_64 x86_64 x86_64 GNU/Linux

Die Beispiele in diesem Buch basieren auf der Zig-Version 0.13.0, d.h. um den entspre-
chenden Compiler auf meinem Linux system zu installieren würde ich die Datei zig-linux-
x86_64-[Link] aus der Download-Sektion herunterladen.

10 [Link]
11 [Link]

1
 Linux

Abbildung 1: Download Seite von [Link]

Mit dem tar Kommandozeilenwerkzeug kann das heruntergeladene Archiv danach entpackt
werden.

$ tar -xf zig-linux-x86_64-[Link]

Der entpackte Ordner enthält die Folgenden Dateien.

$ ls zig-linux-x86_64-0.13.0
doc lib LICENSE [Link] zig

• doc: Die Referenzdokumentation der Sprache. Diese ist auch online, unter [Link]
documentation/0.13.0/, zu finden und enthält einen Überblick über die gesamte Sprache. Ich
empfehle Ihnen ergänzend zu diesem Buch die Dokumentation zu Rate zu ziehen.
• lib: Enthält alle benötigten Bibliotheken, inklusive der Standardbibliothek. Die Standardbi-
bliothek enthält viel nützliche Programmbausteine, darunter geläufige Datenstrukturen, einen
JSON-Parser, Kompressionsalgorithmen, kryptographische Algorithmen und Protokolle und
vieles mehr. Eine Dokumentation der gesamten Standardbibliothek findet sich online unter
[Link]
• zig: Dies ist ein Kommandozeilenwerkzeug mit dem unter anderem Zig-Programme kompiliert
werden können.

2
Zig Basics

Um den Zig-Compiler nach dem Entpacken auf einem Linux System zu installieren, können wir
diesen nach /usr/local/bin verschieben.

$ sudo mv zig-linux-x86_64-0.13.0 /usr/local/bin/zig-linux-x86_64-0.13.0

Danach erweitern wir die $PATH Umgebungsvariable um den Pfad zu unserem Zig-Compiler.
Dies können wir in der Datei ~/.profile oder auch ~/.bashrc machen12.

# Sample .bashrc for SuSE Linux

# ...

export PATH="$PATH:/usr/local/bin/zig-linux-x86_64-0.13.0"

Nach Änderung der Konfigurationsdatei muss diese neu geladen werden. Dies kann entweder
durch das öffnen eines neuen Terminalfensters erfolgen oder wir führen im derzeitigen Terminal
das Kommando source .bashrc in unserem Home-Verzeichnis aus. Danach können wir zum
überprüfen, ob alles korrekt installiert wurde, das Zig-Zen auf der Kommandozeile ausgeben
lassen. Das Zig-Zen kann als die Kernprinzipien der Sprache und ihrer Community angesehen
werden, wobei man dazu sagen muss, dass es nicht „die eine“ Community gibt.

$ source ~/.bashrc
$ zig zen

* Communicate intent precisely.

* Edge cases matter.
* Favor reading code over writing code.
* Only one obvious way to do things.
* Runtime crashes are better than bugs.
* Compile errors are better than runtime crashes.
* Incremental improvements.
* Avoid local maximums.
* Reduce the amount one must remember.
* Focus on code rather than style.
* Resource allocation may fail;
resource deallocation must succeed.
* Memory is a resource.
* Together we serve the users.

Windows
Der einfachste Weg um den Zig-Compiler unter Windows zu installieren ist unter Verwendung
von Visual Studio Code. Hierzu besuchen Sie [Link] und laden dort

12 Je nach verwendetem Terminal kann die Konfigurationsdatei auch anders heißen.

3
 Windows

zuerst den Installer für Windows herunter. Öffnen Sie nach der Installation VS-Code, suchen Sie
nach der Zig Language Extension und installieren Sie diese13.

Abbildung 2: Installation der Zig Language Extension in Visual Studio Code

Die Extension installiert nicht nur den Zig-Compiler, sondern auch zusätzliche Tools, wie etwa
den ZLS Language Server14.
Mit der Tastenkombination CTRL + Shift + P lässt sich ein Kontextmenü öffnen, über welches
sich verschiedene Zig-Kommandos ausführen lassen:
• Mit dem Kommando Zig Setup: Install Zig lassen sich unterschiedlich Compiler-
Versionen installieren. Für dieses Buch wird die Version 0.13.0 benötigt. Auf meinem
Computer werden die verschiedenen Versionen alle unter C:\Users\<UserName>\App-
Data\Roaming\Code\User\globalStorage\[Link]-zig\zig abgelegt, d.h. Version 0.13.0
wird unter C:\Users\<UserName>\AppData\Roaming\Code\User\globalStorage\[Link]-
zig\zig\windows-x86_64-0.13.0 installiert.
• Das Kommando Zig: Run Zig kompiliert und führt das derzeitige Projekt aus.
Zum jetzigen Zeitpunkt gibt es leider keine einfache Möglichkeit, via Visual Studio
Code, direkt ein neues Zig-Projekt anzulegen. Um ein neues Projekt anzulegen öffnen
wir mittels File > Open Folder... zuerst einen leeren Projektordner. Danach kann
mit Terminal > New Terminal ein neues Terminalfenster geöffnet werden. Innerhalb
des Fensters kann mit C:\Pfad\zu\Zig\[Link] init der Projektordner initialisiert wer-
den. Der Pfad zu [Link] sollte sich grundsätzlich nur in der Versionsnummer und
dem Benuternamen unterscheiden, d.h. es sollte ausreichen bei dem folgenden Komman-

13Stellen Sie sicher, dass Sie die korrekte Extension installieren. Der Herausgeber der Extension ist ziglang ,
markiert mit einem blauen Haken.
14 [Link]

4
Zig Basics

C:\Users\Sugar\AppData\Roaming\Code\User\globalStorage\[Link]-
do zig\zig\windows-x86_64-0.13.0\[Link] init Sugar
durch Ihren Benutzernamen zu ersetzen.

Abbildung 3: Initialisierung eines neuen Zig-Projekts über die Kommandozeile in VS-Code

Alternativ können Sie Zig auch manuell herunterladen und dessen Pfad zur Path-Umgebungs-
variable hinzufügen. Der Vorteil hierbei ist, dass sie nicht bei jedem Aufruf von [Link] den
gesamten Pfad mit angeben müssen. Die Path-Variable wird vom Betriebssystem verwendet, um
nach ausführbaren Dateien zu suchen. Um den Pfad hinzuzufügen gehen Sie wie folgt vor:
1. Öffnen sie die Systemsteuerungen (engl. System).
2. Wählen Sie Erweiterte Systemsteuerungen aus.
3. Klicken Sie auf Umgebungsvariablen und wählen Sie unter Systemvariablen die Variable
Path aus. Wählen sie Bearbeiten (Edit) aus.
4. Fügen Sie den Pfad zu [Link] zu den bestehenden Pfaden hinzu und schließen Sie alle Fenster
mit OK.

5
 Abbildung 4: Neuen Pfad unter Windows hinzufügen
Angenommen wir haben die Datei zig-windows-x86_64-[Link] heruntergeladen und in den
Documents Ordner entpackt (Bei mir wäre der vollständige Pfad in diesem Fall C:\Users\Sugar\Do-
cuments\zig-windows-x86_64-0.13.0). In diesem Fall können Sie die enthaltene [Link] zugänglich
machen, indem Sie, wie oben beschrieben, die Path umgebungsvariable auswählen und Bear
beiten beziehungsweise Edit auswählen. Danach sehen Sie eine Liste aller Pfade, auf die Path
verweist. Klicken Sie auf Neu / New und tragen Sie hier C:\Users\Sugar\Documents\zig-windows-
x86_64-0.13.0 ein, wobei Sie Sugar durch Ihren Benutzernamen ersetzen. Danach drücken Sie OK.

Abbildung 5: Der neue Pfad verweist auf den heruntergeladenen Zig-Ordner

Damit die Änderungen wirksam werden muss danach die Eingabeaufforderung bzw. PowerShell
neu gestartet werden.

6
Zig Basics

Abbildung 6: Nach dem Hinzufügen des Zig-Ordners zu Path sollten [Link] von überall, inner-
halb der PowerShell, aufrufbar sein

Compiler Grundlagen
Mit dem Kommando zig help lässt sich ein Hilfetext auf der Kommandozeile anzeigen, der die
zu Verfügung stehenden Kommandos auflistet.
Praktisch ist, dass Zig für uns ein neues Projekt, inklusive Standardkonfiguration, anlegen kann.

$ mkdir hello && cd hello

$ zig init
info: created [Link]
info: created [Link]
info: created src/[Link]
info: created src/[Link]
info: see `zig build --help` for a menu of options

Das Kommando zig init initialisiert den gegebenen Ordner mit Template-Dateien, durch die
sich sowohl eine Executable, als auch eine Bibliothek bauen lassen. Schaut man sich die erzeugten
Dateien an so sieht man, dass Zig eine Datei namens [Link] erzeugt hat. Bei dieser handelt
es sich um die Konfigurationsdatei des Projekts. Sie beschreibt aus welchen Dateien eine Execu-
table bzw. Bibliothek gebaut werden soll und welche Abhängigkeiten (zu anderen Bibliotheken)
diese besitzen. Ein bemerkenswertes Detail ist dabei, dass [Link] selbst ein Zig Programm ist,
welches kompiliert und ausgeführt wird um die eigentlichle Anwendung zu bauen.
Die Datei [Link] enthält weitere Informationen über das Projekt, darunter dessen Namen,
die Versionsnummer, sowie mögliche Dependencies. Dependencies können dabei lokal vorliegen
und über einen relativen Pfad angegeben oder von einer Online-Quelle, wie etwa Github,
bezogen werden. Die Endung der Datei steht im übrigen für Zig Object Notation (ZON), ein
Dateiformat, welches an die Zig-Basistypen angelehnt ist.
Schauen wir in src/[Link], so sehen wir das Zig für uns ein kleines Programm geschrieben hat.

7
 Compiler Grundlagen

const std = @import("std");

pub fn main() !void {

[Link]("All your {s} are belong to us.\n", .{"codebase"});

const stdout_file = [Link]().writer();

var bw = [Link](stdout_file);
const stdout = [Link]();

try [Link]("Run `zig build test` to run the tests.\n", .{});

try [Link](); // don't forget to flush!

}

Der Code kann auf den ersten Blick überwältigend wirken, schauen wir ihn uns deswegen Stück
für Stück an.

const std = @import("std");

Mit der @import() Funktion importieren wir die Standardbibliothek ( std ) und binden diese
an eine Konstante mit dem selben Namen. Die Standardbibliothek ist eine Ansammlung von
nützlichen Funktionen und Datentypen, die während der Entwicklung von Anwendungen häu-
figer zum Einsatz kommen und deswegen von Zig zur Verfügung gestellt werden. Die Funktion
@import() wird nicht nur zum importieren der Standardbibliothek verwendet, sondern auch
um auf Module und andere, zu einem Projekt gehörende, Quelldateien zuzugreifen.
Nach der Definition der Konstante std beginnt die main Funktion:

pub fn main() !void {

Unsere main Funktion beginnt, wie alle Funktionen, mit fn und dem Namen der Funktion. Sie
gibt keinen Wert zurück, aus diesem Grund folgt auf die leere Parameterliste () der Rückga-
betyp void . Das Ausrufezeichen ! weist darauf hin, das die Funktion einen Fehler zurückgeben
kann. Fehler in Zig sind eigenständige Werte, die von einer Funktion zurückgegeben werden
können und sich semantisch vom eigentlichen Rückgabewert unterscheiden.

[Link]("All your {s} are belong to us.\n", .{"codebase"});

Als erstes gibt die main Funktion einen String über die Debugausgabe auf der Kommandozeile
aus. Die Funktion print erwartet dabei einen Format-String, der mit Platzhaltern (z.B. {s} )
versehen werden kann, sowie eine Liste an Ausdrücken (z.B. .{"codebase"} ) deren Werte in
den String eingefügt werden sollen. Der Platzhalter {s} gibt z.B. an, dass an der gegebenen

8
Zig Basics

Stelle ein String eingefügt werden soll. Neben s gibt es unter anderem noch d für Ganzzahlen
und any für beliebige werte.

const stdout_file = [Link]().writer();

var bw = [Link](stdout_file);
const stdout = [Link]();

Via [Link] können wir mit getStdIn() , getStdOut() und getStdErr() auf stdin ,
stdout und stderr zugreifen. Alle drei Funktionen geben jeweils eine Objekt vom Typ File
zurück. Die Funktion writer() welche auf der stdout-Datei aufgerufen wird, gibt einen Writer
zurück. Ein Writer ist ein Wrapper um einen beliebiges Datenobjekt (z.B. eine offene Datei, ein
Array, …) und stellt eine standartisiertes Interface zur Verfügung um Daten zu serialisieren. In
unserem Fall wird der stdout_file Writer wiederum in einen BufferedWriter gewrapped,
welcher nicht bei jedem einzelnen Schreibvorgang auf die Datei stdout zugreift, sondern erst
wenn genug Daten geschrieben wurden bzw. wenn die Funktion flush() aufgerufen wird. Die
Konstante stdout ist also ein Writer der einen Writer umschließt, der eine Datei umschließt,
in die schlussendlich geschrieben werden soll.

try [Link]("Run `zig build test` to run the tests.\n", .{});

Der BufferedWriter ( stdout ) wird verwendet um (indirekt) den String „Run zig build test to
run the tests.“ nach stdout (standardmäßig die Kommandozeile) zu schreiben. Da diese Schreib-
operation fehlschlagen kann wird vor den Ausdruck ein try gestellt. Damit wird ein potenzieller
Fehler „nach oben“ propagiert, was im gegebenen Fall zu einem Programmabsturz führen würde,
da main keine Funktion über sich besitzt. Als Alternative könnte mit einem catch Block der
Fehler explizit abgefangen werden.

try [Link]();

Um sicher zu gehen, dass auch alle Daten aus dem BufferedWriter tatsächlich geschrieben
wurden, muss schlussendlich flush() aufgerufen werden.
Das von Zig vorbereitete „Hello, World“-Programm kann mit zig build run , von einem belie-
bigen Ordner innerhalb des Zig-Projekts, ausgeführt werden.

$ zig build run

All your codebase are belong to us.
Run `zig build test` to run the tests.

Im gegebenen Beispiel wurden zwei Schritte ausgeführt. Zuerst wurde der Zig-Compiler aufge-
rufen um das Programm in src/[Link] zu kompilieren und im zweiten Schritt wurde das
Programm ausgeführt. Zig platziert dabei seine Kompilierten Anwendungen in zig-out/bin und
Bibliotheken in zig-out/lib.
9
Funktionen
Zig’s Grammatik ist sehr überschaubar und damit leicht zu erlernen. Diejenigen mit Erfahrung
in anderen C ähnlichen Programmiersprachen wie C, C++, Java oder Rust sollten sich direkt
Zuhause fühlen. Die unterhalb abgebildete Funktion berechnet den größten gemeinsamer Teiler
(greatest common divisor) zweier Zahlen.

chapter01/[Link]
fn gcd(n: u64, m: u64) u64 {
return if (n == 0)
m
else if (m == 0)
n
else if (n < m)
gcd(m, n)
else
gcd(m, n % m);
}

Das fn Schlüsselwort markiert den Beginn einer Funktion. Im gegebenen Beispiel definieren
wir eine Funktion mit dem Name gcd , welche zwei Argumente m und n , jeweils vom Typ
u64 , erwartet. Nach der Liste an Argumenten in runden Klammern folgt der Typ des erwarteten
Rückgabewertes. Da die Funktion den größten gemeinsamen Teiler zweier u64 Ganzzahlen be-
rechnet ist auch der Rückgabewert vom Typ u64 . Der Körper der Funktion wird in geschweifte
Klammern gefasst.
Zig unterscheidet zwischen zwei Variablen-Typen, Variablen und Konstanten. Konstanten kön-
nen nach ihrer Initialisierung nicht mehr verändert werden, während Variablen neu zugewiesen
werden können. Funktionsargumente zählen grundsätzlich zu Konstanten, d.h. sie können nicht
verändert werden. Der Zig-Compiler erzwingt die Nutzung von Konstanten, sollte eine Variable
nach ihrer Initialisierung nicht mehr verändert werden. Dies ist eine durchaus kontroverse De-
signentscheidung, welche aber auf das Zig-Zen zurückgeführt werden kann, das besagt: ,,Favor
reading code over writing code„. Sollten Sie also eine Variable in fremden Code sehen so können
Sie sicher sein, dass diese an einer anderen Stelle manipuliert bzw. neu zugewiesen wird.
Eine Besonderheit, die Zig von anderen Sprachen unterscheidet ist, dass Integer mit beliebiger
Präzision unterstützt werden. Im obigen Beispiel handelt es sich bei u64 um eine vorzeichenlose
Ganzzahl (unsigned integer) mit 64 Bits, d.h. es können alle Zahlen zwischen 0 und 264 − 1
dargestellt werden. Zig unterstützt jedoch nicht nur u8 , u16 , u32 oder u128 sondern alle
unsigned Typen zwischen u0 und u65535 .

10
Zig Basics

Alle Zig-Basistypen sind Teil des selben union : [Link]. Das union
beinhaltet den Int Typ welcher ein struct mit zwei Feldern ist, signedness
und bits , wobei bits vom Typ u16 ist, d.h. es können alle Integer-Typen
zwischen 0 und 216 − 1 Bits verwendet werden. Ja Sie hören richtig, der Zig-
Compiler ist seit Version 0.10.0 selbst in Zig geschrieben, d.h. er ist self-hosted.

Innerhalb des Funktonskörpers werden mittels if verschiedene Bedingungen abgefragt. Sollte

eine beider Zahlen 0 sein, so wird jeweils die andere zurückgegeben, ansonsten wird gcd
rekursiv aufgerufen bis für eine der beiden Zahlen die Abbruchbedingung (0) erreicht ist. Wie
auch bei C muss die Bedingung in runde Klammern gefasst werden. Bei Einzeilern können die
geschweiften Klammern um einen Bedingungsblock weggelassen werden. In diesem Fall wird
der Rückgabewert der Bedingung an den umschließenden Block gereicht.
Mittels eines return Statements kann von einer Funktion in die aufrufende Funktion zurück-
gekehrt werden. Das Statement nimmt bei bedarf zusätzlich einen Wert der an die aufrufende
Funktion zurückgegeben werden soll. Im obigen Beispiel gibt gcd mittels return den Wert des
ausgeführten If-Else-Asudruck zurück.
Das vollständige Programm finden Sie im zugehörigen Github-Rerpository. Mittels
zig build-exe chapter01/[Link] kann das Beispiel kompiliert werden.

Unit Tests
Wie von einer modernen Programmiersprache zu erwarten bietet Zig von Haus aus Unterstüt-
zung für Tests. Tests beginnen mit dem Schlüsselwort test , gefolgt von einem String der den
Test bezeichnet. In geschweiften Klammern folgt der Test-Block.

chapter01/[Link]
test "assert that the gcd of 21 and 4 is 1" {
try [Link](@as(u64, 1), gcd(21, 4));
}

Die Standardbibliothek bietet unter [Link] eine ganze Reihe an Testfunktionen für
verschiedene Datentypen und Situationen. Im obigen Beispiel verwenden wir ExpectEqual ,
welche als erstes Argument den erwarteten Wert erhält und als zweites Argument das Resultat
eines Aufrufs von gcd . Die Funktion überprüft beide Werte auf ihre Gleichheit und gibt im
Fehlerfall einen error zurück. Dieser Fehler kann mittels try propagiert werden, wodurch der
Testrunner im obigen Beispiel erkennt, dass der Test fehlgeschlagen ist.

$ zig test chapter01/[Link]

All 1 tests passed.

11
Innerhalb einer Datei sind Definitionen auf oberster Ebene (top-level definitions) unabhängig
von ihrer Reihenfolge, was die Definition von Tests mit einschließt. Damit können Tests an einer
beliebigen Stelle definiert werden, darunter direkt neben der zu testenden Funktion oder am
Ende einer Datei. Der Zig-Test-Runner sammelt automatisch alle definierten Tests und führt dies
beim Aufruf von zig test aus. Worauf Sie jedoch achten müssen ist, dass Sie ausgehend von
der Wurzel-Datei (in den meisten Fällen src/[Link]), die konzeptionell den Eintritspunkt für
den Compiler in ihr Programm oder Ihre Bibliothek darstellt, Zig mitteilen müssen in welchen
Dateien zusätzlich nach Tests gesucht werden soll. Dies bewerkstelligen Sie, indem Sie die
entsprechende Datei innerhalb eines Tests importieren.

const foo = @import("[Link]");

test "main tests" {

_ = foo; // Tell test runner to also look in foo for tests
}

Comptime
Die meisten Sprachen erlauben eine Form von Metaprogrammierung, d.h. das Schreiben von
Code der wiederum Code generiert. In C können die gefürchteten Makros mit dem Präprozessor
verwendet werden und Rust bietet sogar zwei verschiedene Typen von Makros, jeweils mit einer
eigenen Syntax. Zig bietet mit comptime seine eigene Form der Metaprogrammierung. Was
Zig von anderen kompilierten Sprachen unterscheidet ist, dass die Metaprogrammierung in der
Sprache selber erfolgt, das heißt wer Zig programmieren kann, der hat das nötige Handwerks-
zeug um auch Metaprogrammierung in Zig zu betreiben.
Ein Aufgabe für die Metaprogrammierung sehr gut geeignet ist, ist die Implementierung von
Container-Typen wie etwa [Link] . Eine ArrayList ist ein Liste von Elementen eines
beliebigen Typen, die eine Menge an Standardfunktionen bereitstellt um die Liste zu manipu-
lieren. Nun wäre es sehr aufwändig die ArrayList für jeden Typen einzeln implementieren zu
müssen. Aus diesem Grund ist ArrayList als Funktion implementiert, welche zur Compilezeit
einen beliebigen Typen übergeben bekommt auf Basis dessen einen ArrayList -Typ generiert.

var list = [Link](u8).init(allocator);

try [Link](0x00);

Der Funktionsaufruf ArrayList(u8) wird zur Compilezeit ausgewertet und gibt einen neuen
Listen-Typen zurück, mit dem sich eine Liste an u8 Objekten managen lassen. Auf diesem Typ
wird init() aufgerufen um eine neu Instanz des Listen-Typs zu erzeugen. Mit der Funktion
append() kann z.B., ein Element an das Ende der Liste angehängt werden. Eine stark simplifi-
zierte Version von ArrayList könnte wie folgt aussehen.

chapter01/[Link]
12
Zig Basics

const std = @import("std");

// Die Funktion erwartet als Compilezeitargument einen Typen `T`

// und gibt ein Struct zurück, dass einen Wrapper um einen Slice
// des Type `T` darstellt.
//
// Der Wrapper implementiert Funktionen zum managen des Slices
// und unterstützt unter anderem:
// - das Hinzufügen neuer Elemente
pub fn MyArrayList(comptime T: type) type {
return struct {
items: []T,
allocator: [Link],

// Erzeuge eine neue Instanz von MyArrayList(T).

// Der übergebene Allocator wird von dieser Instanz gemanaged.
pub fn init(allocator: [Link]) @This() {
return .{
.items = &[_]T{},
.allocator = allocator,
};
}

pub fn deinit(self: *@This()) void {

[Link]([Link]);
}

// Füge da Element `e` vom Typ `T` ans ende der Liste.
pub fn append(self: *@This(), e: T) !void {
// `realloc()` kopiert die Daten bei Bedarf in den neuen
// Speicherbereich aber die Allokation kann auch
// fehlschlagen. An dieser Stelle verbleiben wir der
// Einfachheit halber bei einem `try`.
[Link] = try [Link]([Link], [Link]
+ 1);
[Link][[Link] - 1] = e;
}
};
}

pub fn main() !void {

var gpa = [Link](.{}){};
const allocator = [Link]();

var list = MyArrayList(u8).init(allocator);

defer [Link]();

13
 try [Link](0xAF);
try [Link](0xFE);

[Link]("{s}", .{[Link]([Link][0..])});
}

Mit dem comptime Keyword sagen wir dem Compiler, dass das Argument T zur Compilezeit
erwartet wird. Beim Aufruf von MyArrayList(u8) wertet der Compiler die Funktion aus und
generiert dabei einen neuen Typen. Das praktische ist, dass wir MyArrayList nur einmal imple-
mentieren müssen und diese im Anschluss mit einem beliebigen Typen verwenden können.
Der comptime Typ T kann innerhalb und auch außerhalb des von der Fukntion MyArrayList
zurückgegebenen Structs, anstelle eines expliziten Typs, verwendet werden.
Structs die mit init() initialisiert und mit deinit() deinitialisiert werden sind ein wieder-
kehrendes Muster in Zig. Dabei erwartet init() meist einen [Link] der von der
erzeugten Instanz verwaltet wird.
Ein weiterer Anwendungsfall bei dem Comptime zum Einsatz kommen kann ist die Implemen-
tierung von Parsern. Ein Beispiel hierfür ist der Json-Parser der Standardbibliothek ( [Link] ),
welcher dazu verwendet werden kann um Zig-Typen als Json zu serialisieren und umgekehrt15.
Um ein Zig-Objekt zu de-/serialisieren werden Informationen über den Typ des Objekts und
dessen Beschaffenheit benötigt. Hierzu kommen die Funktionen @TypeOf() und @typeInfo()
zum Einsatz, wie das folgende Beispiel zeigt.

chapter01/[Link]
const std = @import("std");

const MyStruct = struct {

a: u32 = 12345,
b: []const u8 = "Hello, World",
c: bool = false,
};

fn isStruct(obj: anytype) bool {

const T = @TypeOf(obj);
const TInf = @typeInfo(T);

return switch (TInf) {

.Struct => |S| blk: {
inline for ([Link]) |field| {
[Link]("{s}: {any}", .{ [Link], @field(obj,

Die JavaScript Object Notation (JSON) ist eines der gängigsten Datenformate und wird unter anderem zur
15

Übermittlung von Daten im Web verwendet ([Link]

14
Zig Basics

[Link]) });
}

break :blk true;

},
else => return false,
};
}

pub fn main() void {

const s = MyStruct{};

[Link]("{s}", .{if (isStruct(s)) "is a struct!" else "is not

a struct!"});
}

Anstelle eines Typen kann anytype für Parameter verwendet werden. In diesem Fall wird der
Typ des Parameters, beim Aufruf der Funktion, abgeleitet. Zig erlaubt Reflexion (type reflection).
Unter anderem erlaubt Zig die Abfrage von (Typ-)Informationen über ein Objekt. Funktionen
denen ein @ vorangestellt sind heißen Builtin-Function (eingebaute Funktion) und werden
direkt vom Compiler bereitgestellt, d.h., sie können überall in Programmen, ohne Einbindung
der Standardbibliothek, verwendet werden.
Die Funktion @TypeOf() ist insofern speziell, als dass sie eine beliebige Anzahl an Ausdrücken
als Argument annimmt und als Rückgabewert den Typ des Resultats zurückliefert. Die Ausdrü-
cke werden dementsprechend evaluiert. Im obigen Beispiel wird @TypeOf() genutzt um den
Typen des übergebenen Objekts zu bestimmen, da isStruct() aufgrund von anytype mit
einem Objekt beliebigen Typs aufgerufen werden kann.
Die eigentliche Reflexion kann mithilfe der Funktion @typeInfo() durchgeführt werden,
die zusätzliche Informationen über einen Typ zurückliefert. Felder sowie Deklarationen von
structs , unions , enums und error Sets kommen dabei in der selben Reihenfolge vor, wie
sie auch im Source Code zu sehen sind. Im obigen Beispiel testen wir mittels eines switch
Statements ob es sich um ein struct handelt oder nicht und geben dementsprechend entweder
true oder false zurück. Sollte es sich um ein struct handeln, so iterieren wir zusätzlich über
dessen Felder und geben den Namen des Felds, sowie dessen Wert aus. Den Wert des jeweiligen
Felds erhalten wir, indem wir mittels @field() darauf zugreifen. Die Funktion @field()
erwartet als erstes Argument ein Objekt (ein Struct) und als zweites Argument einen zu Compile-
Zeit bekannten String, der den Namen des Felds darstellt, auf das zugegriffen werden soll. Damit
ist @field(s, "b") das Äquivalent zu s.b .
Für jeden Typen, mit dem isStruct() aufgerufen wird, wird eine eigene Kopie der Funktion
(zur Compile Zeit) erstellt, die an den jeweiligen Typen angepasst ist. Das Iterieren über die
einzelnen Felder eines structs muss zur Compile Zeit erfolgen, aus diesem Grund nutzt die

15
obige Funktion inline um die For-Schleife zu entrollen, d.h., aus der Schleife eine lineare
Abfolge von Instruktionen zu machen.

$ zig build-exe chapter01/[Link]

$ ./reflection
info: a: 12345
info: b: { 72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100 }
info: c: false

Reflexion kann in vielen Situationen äußerst nützlich sein, darunter der Implementierung von
Parsern für Formate wie JSON oder CBOR16, da im Endeffekt nur zwei Funktionen implementiert
werden müssen, eine zum Serialisieren der Daten und eine zum Deserialisieren. Mithilfe von
Reflexion kann dann, vom Compiler, für jeden zu serialisierenden Datentyp eine Kopie der
Funktionen erzeugt werden, die auf den jeweiligen Typen zugeschnitten ist.

Kryptographie
Ein Großteil der Anwendungen, die Sie wahrscheinlich täglich verwenden, benutzt in irgend
einer Form Kryptographie. Dabei handelt es sich grob gesagt um mathematische Algorithmen,
mit denen vorwiegend die Vertraulichkeit (Confidentiality), Integrität (Integrity) und Authenti-
zität (Authenticity) von Daten gewährleistet werden kann. Typische Anwendungsbereiche die
Kryptographie verwenden sind Messenger, Video Chats, Networking (TLS), Passwortmanager
und Smart Cards. Zig bietet in seiner Standardbibliothek bereits jetzt eine Vielzahl and krypto-
graphischen Algorithmen und Protokollen, wobei ein Großteil davon von Frank Denis17, Online
auch bekannt als jedisct1, beigetragen wurde. Ohne groß ein Authoritätsargument aufmachen
zu wollen, ist Frank der Maintainer von libsodium18 und libhydrogen19, zwei viel genutzte,
kryptographische Bibliotheken.
Wir werden uns in einem späteren Kapitel noch genauer mit Kryptographie auseinandersetzen,
machen Sie sich deshalb keine Sorgen, wenn Sie nicht alles in diesem Abschnitt auf Anhieb
verstehen. Fürs erste schauen wir uns einen gängigen Anwendungsfall von Kryptographie an, die
Verschlüsselung einer Datei. Angenommen wir haben eine Datei deren Inhalt geheim bleiben soll
und wir wollen des weiteren überprüfen können, dass der Inhalt der Datei nicht verändert wurde.
In solch einem Fall bietet sich die Verwendung eines AEAD (Authenticated Encryption with
Associated Data) Ciphers an. Zig bietet unter [Link] verschiedene AEAD Cipher an.
Die Unterschiede zwischen den Ciphern ist für dieses Beispiel Out-of-Scope. Sie müssen sich
fürs erste damit begnügen mir zu glauben, dass XChaCha20Poly1305 20 für diese Art von Problem

16 [Link]
17 [Link]
18 [Link]

19 [Link]

20 [Link]

16
Zig Basics

eine gute Wahl ist. Der Name XChaCha20Poly1305 enthält dabei zwei Informationen, die uns
Aufschluss über die Zusammensetzung des Ciphers geben:
• XChaCha20: Zur Verschlüsselung der Daten wird die „Nonce-eXtended“ Version der
ChaCha20 Stromchiffre verwendet. XChaCha20 erwartet einen Schlüssel und eine Nonce
(Number used once: Eine Byte-Sequenz die nur einmal für eine Verschlüsselung verwendet
werden darf) und leitet daraus eine Schlüsselsequenz ab, die mit dem Klartext XORed wird.
Die eXtended Version verwendet dabei eine 192-Bit Nonce anstelle einer 96-Bit Nonce, was
es deutlich sicherer macht diese zufällig mittels eines (kryptographisch sicheren) Zufallszah-
lengenerators zu erzeugen. Dieser Teil des Algorithmus ist für die Vertraulichkeit der Daten
verantwortlich.
• Poly1305 : Poly1305 ist ein Hash, der zur Erzeugung von (one-time) Message Authentica-
tion Codes (MAC) verwendet werden kann. MACs sind sogenannte Keyed-Hashfunktionen,
bei denen in einen Hash (keine Sorge, wir werden uns noch näher damit beschäftigen) ein
geheimer Schlüssel integriert wird. Die Hashsumme wird dabei in unserem Beispiel über den
Ciphertext, d.h. den Verschlüsselten Text, gebildet21. Durch den Einbezug eines Schlüssels kann
nicht nur überprüft werden, dass die Integrität der Datei nicht verletzt wurde (sie wurde nicht
verändert), sondern es kann auch sichergestellt werden, dass die MAC von Ihnen generiert
wurde, da nur Sie als Nutzer der Anwendung den geheimen Schlüssel kennen.

chapter01/[Link]
const std = @import("std");

const argon2 = [Link].argon2;

const XChaCha20Poly1305 = [Link].chacha_poly.XChaCha20Poly1305;

var gpa = [Link](.{}){};

const allocator = [Link]();

const Mode = enum {

encrypt,
decrypt,
};

pub fn main() !void {

var password: ?[]const u8 = null;
var mode: ?Mode = null;

// Als erstes parsen wir die übergebenen Kommandozeilenargumente.

// Diese bestimmen zum einen mit welchem Passwort die Daten
// verschlüsselt werden sollen und zum anderen den Modus, d.h.
// ob ver- bzw. entschlüsselt werden soll.
var ai = try [Link](allocator);

21 Dies wird als Encrypt-than-Mac bezeichnet.

17
 Kryptographie

defer [Link]();

while ([Link]()) |arg| {

// `[Link]` kann dazu verwendet werden zwei Strings mit einander
zu vergleichen...
if ([Link] > 11 and [Link](u8, "--password=", arg[0..11])) {
password = arg[11..];
} else if ([Link] >= 9 and [Link](u8, "--encrypt", arg[0..9])) {
mode = .encrypt;
} else if ([Link] >= 9 and [Link](u8, "--decrypt", arg[0..9])) {
mode = .decrypt;
}
}

// Sollten nicht alle benötigten Argumente übergeben worden sein, so

beenden wir den Prozess.
if (password == null or mode == null) {
[Link]("usage: ./encrypt --password=<password> [--encrypt|--
decrypt]", .{});
return;
}

// Als nächstes lesen wir die übergebenen Daten von `stdin` ein.
const stdin = [Link]();
const data = try [Link](allocator, 64_000);
defer {
// Wir überschreiben die Daten bevor wir den Speicher wieder freigeben.
@memset(data, 0);
[Link](data);
}

if (mode == .encrypt) {
// Bei der Verschlüsselung müssen wir eine Reihe an (öffentlichen)
// Parametern festlegen, die bei der Entschlüsselung wiederverwendet
// werden müssen.

// Als erstes müssen wir ein Schlüssel von unserem Passwort ableiten.
// Hierfür verwenden wir die Argon2id Key-Derivation-Function (KDF).
var salt: [32]u8 = undefined;
[Link](&salt);

var key: [XChaCha20Poly1305.key_length]u8 = undefined;

try [Link](allocator, &key, password.?, &salt, .{
// Die Parameter bestimmen wie aufwendig die Brechnung des Schlüssels
`key` ist.
// Damit wird verhindert, diesen durch "Brute-Forcing" brechen
zu können.

18
Zig Basics

.t = 3,
.m = 4096,
.p = 1,
}, .argon2id);

// Nun können wir die Daten ver-/ bzw. entschlüsseln.

// Der TAG wird von der encrypt() Funktion erzeugt und später
// von decrypt() überprüft.
var tag: [XChaCha20Poly1305.tag_length]u8 = undefined;

// Für jede Verschlüsselung muss eine neue, einzigartige Nonce

// verwendet werden. Da wir die eXtended Version von ChaCha20
// verwenden, kann diese durch einen kryptographisch sicheren
// Zufallszahlengenerator festgelegt werden.
var nonce: [XChaCha20Poly1305.nonce_length]u8 = undefined;
[Link](&nonce);

[Link](data, &tag, data, "", nonce, key);

// Der Salt, Nonce und Tag müssen mit den verschlüsselten Daten
serialisiert werden,
// da wir diese später zur Entschlüsselung benötigen.
const stdout = [Link]();
try [Link]([Link](), "{s}:{s}:{s}:{s}", .{
// Wir serialisieren die Binärdaten in Hexadezimal.
[Link](salt[0..]),
[Link](nonce[0..]),
[Link](tag[0..]),
[Link](data),
});
} else {
// Da wir die Daten in Hexadezimal serialisiert haben, müssen wir diese
// wieder voneinander trennen und in Binärdaten umwandeln.
var si = [Link](u8, data, ":");

const salt = [Link]();

if (salt == null or salt.?.len != 32 * 2) {
[Link]("invalid data (missing salt)", .{});
return;
}
var salt_: [32]u8 = undefined;
_ = try [Link](&salt_, salt.?);

const nonce = [Link]();

if (nonce == null or nonce.?.len != XChaCha20Poly1305.nonce_length *
2) {

19
 [Link]("invalid data (missing nonce)", .{});
return;
}
var nonce_: [XChaCha20Poly1305.nonce_length]u8 = undefined;
_ = try [Link](&nonce_, nonce.?);

const tag = [Link]();

if (tag == null or tag.?.len != XChaCha20Poly1305.tag_length * 2) {
[Link]("invalid data (missing tag)", .{});
return;
}
var tag_: [XChaCha20Poly1305.tag_length]u8 = undefined;
_ = try [Link](&tag_, tag.?);

const ct = [Link]();
if (ct == null) {
[Link]("invalid data (missing cipher text)", .{});
return;
}

const pt = try [Link](u8, ct.?.len / 2);

defer {
@memset(pt, 0);
[Link](pt);
}

_ = try [Link](pt, ct.?);

// Danach können wir die deserialisierten Daten verwenden um

// den Ciphertext zu entschlüsseln.
var key: [XChaCha20Poly1305.key_length]u8 = undefined;
try [Link](allocator, &key, password.?, &salt_, .{
.t = 3,
.m = 4096,
.p = 1,
}, .argon2id);

try [Link](pt, pt, tag_, "", nonce_, key);

const stdout = [Link]();

try [Link]([Link](), "{s}", .{pt});
}
}

In diesem Beispiel laufen eine Vielzahl von Konzepten zusammen, die sie im Laufen diese
Buches noch häufiger antreffen werden. Unsere Anwendung erwartet Daten, z.B. den Inhalt
einer Datei, über stdin , sowie zwei Kommandozeilenargumente: --password und --encrypt

20
Zig Basics

bzw. --decrypt . Basierend auf diesen Argumenten werden die übergebenen Daten entweder
verschlüsselt oder entschlüsselt und nach stdout geschrieben.
Wir beginnen mit einigen Top-Level-Deklarationen, damit wir den Pfad zu Datenstrukturen,
wie etwa XChaCha20Poly1305 , nicht immer ausschreiben müssen. Weiterhin definieren wir ein
Enum Mode welches zwei operationelle Zustände ausdrücken kann, Verschlüsselung ( encrypt )
und Entschlüsselung ( decrypt ).
Innerhalb von main parsen wir zuerst die übergebenen Argumente, indem wir durch die
Funktion argsWithAllocator() einen Iterator über die Kommandozeilenargumente beziehen
und mithilfe dessen über die einzelnen Argumente iterieren. Iteratoren sind ein häufig wieder-
zufindendes Konzept und lassen sich hervorragend mit while Schleifen kombinieren. Solange
[Link]() ein Element zurückliefert, wird diese an arg gebunden und die Schleife wird
fortgeführt. Liefert next() den Wert null zurück, so wird automatisch aus der Schleife ausge-
brochen.
Danach stellen wir sicher, dass sowohl ein Passwort als auch ein Modus vom Nutzer spezifiziert
wurden. Sollte eines der beiden Argumente fehlen, so wird ein entsprechender Fehler gelogged
und der Prozess vorzeitig beendet.
Als nächstes wird eine über stdin übergebene Datei eingelesen und an die Konstante data
gebunden. Da der für die Datei benötigte Speicher dynamisch alloziert wird muss dieser
wider freigegeben werden. Hierfür wird eine defer -Block verwendet, der vor Beendigung der
Anwendung ausgeführt wird. Innerhalb dieses Blocks wird zusätzlich der Speicherinhalt mittels
@memset überschrieben.

Der Umgang mit Sicherheitsrelevanten Daten ist durchaus herausfordernd.

Grundsätzlich muss darauf geachtet werden, dass sensible Daten nicht zu lange
im Speicher verweilen. Voraussetzung hierfür ist, dass Sie überhaupt wissen
wo überall sensible Daten abgespeichert werden. Zum einen können Sie Daten,
nachdem diese nicht mehr benötigt werden, überschreiben. Sie sollten jedoch
auch weniger offensichtlich Angriffsvektoren, wie das Swappen von Hauptspei-
cher, im Hinterkopf behalten.

Sowohl für die Ver- als auch Entschlüsselung muss zuerst ein geheimer Schlüssel vom übergebe-
nen Passwort, mittels einer Key-Derivation-Funktion, abgeleitet werden. Für diese Beispiel wird
Argon2id22, der Gewinner der 2015 Password Hashing Competition, verwendet. Die Berechnung
eines Schlüssels durch Argon2 hängt von den Folgenden (öffentlichen) Parametern ab:
• Salt: eine zufällige Sequenz die in die Schlüsselberechnung einfließt.
• Time: Die Anzahl an Iterationen für die Berechnung.
• Memory: Die Speicher-Kosten für die Berechnung.
• Parallelismus: Die Anzahl an parallelen Berechnungen.

22 [Link]

21
Time, Memory und Parallelismus bestimmen wie aufwändig die Ableitung eines Schlüssels ist.
Grundsätzlich gilt: je aufwendiger desto besser, jedoch schlägt sich dies auch in einer längeren
Wartezeit nieder (spielen Sie deshalb gerne mit den Parametern). Alle Parameter werden bei
der Verschlüsselung festgelegt und müssen mit dem Ciphertext zusammen gespeichert werden,
da bei der Entschlüsselung die selben Parameter wieder in die KDF einfließen müssen um den
Selben Schlüssel vom Passwort abzuleiten.
Zur Verschlüsselung wird eine zufällige Nonce generiert welche zusammen mit den zu verschlüs-
selnden Daten, einem Zeiger auf ein Array für den Tag, zusätzliche Daten (in diesem Fall der
leere String "" ) und dem abgeleiteten Schlüssel an encrypt übergeben werden. Die Funktion
verschlüsselt daraufhin die Daten. Danach wird der Salt, die Nonce, der Tag, sowie die verschlüs-
selten Daten, getrennt durch ein : , in die Standardausgabe stdout geschrieben.
Für die Entschlüsselung wird dieser String anhand der : , mittels split , aufgeteilt. Sollten
die eingelesenen Daten nicht im erwarteten Format vorliegen, das heißt Salt, Nonce, Tag oder
Ciphertext fehlen, so wird ein Fehler ausgegeben und die Anwendung beendet. Andernfalls,
werden die eingelesenen Parameter verwendet um den Ciphertext, mittels decrypt , wieder zu
entschlüsseln.
Das kleine Verschlüsselungsprogramm kann wie folgt verwendet werden:

$ cat [Link]
Hello, World!
$ cat [Link] | ./encrypt --password=supersecret --encrypt > [Link]
$ cat [Link]
828dfa14efa4b1f8242a8258a411301bd79bc4b7528294500305a4e9baaecbba:
85e4593786697e4e49212131a8e6e6bb68d25f43613dd870:ec666e95ebe1fa4c
53a1183379ae0dbd:80a7fe0475834364229c15dfb96d
$ cat [Link] | ./encrypt --password=supersecret --decrypt
Hello, World!

Graphische Applikationen
Ein weiterer Anwendungsfall für Zig ist die Entwicklung graphischer Applikationen. Hierfür
existiert eine Vielzahl an Bibliotheken, darunter GTK und QT. Was beide Bibliotheken gemein-
sam haben ist, dass sie in C beziehungsweise C++ geschrieben sind. Normalerweise würde das
die Entwicklung von Bindings voraussetzen, um die Bibliotheken in anderen Sprachen nutzen
zu können. Zig integriert jedoch direkt C, wodurch C-Bibliotheken direkt verwendet werden
können23.
In diesem Abschnitt zeige ich Ihnen, wie sie eine simple GUI-Applikation mit GTK4 und Zig
schreiben können. Hierfür müssen Sie zuerst eine GTK4-Entwicklungsumgebung installieren.

23 Mit wenigen Einschränkungen. Zig scheitert zurzeit noch an der Übersetzung einer Makros.

22
Zig Basics

Installation unter Linux

Unter Linux ist die Installation von GTK4 relativ einfach. Für die meisten Distributionen kann
GTK4 einfach über den mitgelieferten Paketmanager, zum Beispiel APT unter Debian und
Ubuntu, installiert werden.

sudo apt install libgtk-4-dev

Installation unter Windows

Unter Windows ist die Installation von GTK4 etwas umständlicher als unter Linux. Ein Weg ist
die Verwendung von gvsbuild24, beziehungsweise den von gsvbuild gebauten GTK-Bibliotheken.
Unter Releases finden sich sowohl Pre-Build GKT3 als GTK4 Bibliotheken für Windows.
Laden Sie das aktuellste Zip-Archiv, zum Beispiel GTK4_Gvsbuild_2024.12.0_x64.zip herunter und
entpacken sie dessen Inhalt nach C:\gtk.

Abbildung 7: Der Inhalt von C:\gtk nach dem Entpacken.

Nachdem Sie den Ordner entpackt haben, müssen drei Umgebungsvariablen erzeugt beziehungs-
weise angepasst werden. Hierzu gehen Sie analog wie bei der Installation von Zig vor (siehe
Anfang des Kapitels).
• Fügen Sie zu Path den Pfad C:\gtk\bin hinzu.
• Fügen Sie zu LIB den Pfad C:\gtk\lib hinzu. Erzeugen Sie eine neu Variable mit dem Namen
LIB , falls diese nicht existiert.
• Fügen Sie zu INCLUDE die Pfade C:\gtk\include;C:\gtk\include\cairo;C:\gtk\include\glib-2.0;C:
\gtk\include\gobject-introspection-1.0;C:\gtk\lib\glib-2.0\include; hinzu. Erzeugen Sie eine neu
Variable mit dem Namen INCLUDE , falls diese nicht existiert.

24 [Link]

23
 Abbildung 8: Erweiterung der Umgebungsvariablen Path , LIB und INCLUDE .
Weitere Informationen finden Sie im angegebenen Github-Repository.
Achten Sie darauf, dass Sie den Rechner neu starten beziehungsweise ein neues PowerShell-
Fenster öffnen müssen, bevor die Änderungen wirksam werden.

Projekt anlegen
Nachdem GTK4 korrekt installiert wurde legen wir als erstes einen neuen Projektordner an und
initialisieren diesn.

$ mkdir gui
$ cd gui
$ zig init
info: created [Link]
info: created [Link]
info: created src/[Link]
info: created src/[Link]
info: see `zig build --help` for a menu of options

Fügen Sie danach gtk4 als Bibliothek zu Ihrer Anwendung hinzu. Hierfür öffnen Sie [Link]
mit einem Texteditor und erweitern die Datei um die folgenden Zeilen:

chapter01/gui/[Link]
//...
const exe = [Link](.{
//...
});
// Fügen Sie die folgenden beiden Zeilen hinzu
[Link]();
// Gegebenfalls müssen Sie "gtk4" durch "gtk-4" ersetzen!
[Link]("gtk4");
//...

24
Zig Basics

Mit linkSystemLibrary können Sie Systembibliotheken, in unserem Fall GTK4, verlinken. LibC
ist eine standart C-Bibliothek und wird, bis auf wenige Ausnahmen, von allen C-Anwendungen,
unter anderem GTK4, benötigt. Um LibC zu verlinken wird die Funktion linkLibC verwendet,
deren Aufruf äquivalent zu dem Aufruf linkSystemLibrary("c") ist. Grundsätzlich können
Sie sich merken, dass Sie bei der Verwendung einer C-Bibliothek mit Zig auch immer LibC
verlinken müssen25.
Führen Sie nach dem Hinzufügen der benötigten Bibliotheken zig build aus um zu überprüfen,
dass Zig die benötigte Bibliothek auf Ihrem System findet. An dieser Stelle kann es zu Problemen
kommen, die entweder auf eine falsche Installation von GTK4 oder auf einen falschen Bezeichner
(probieren Sie gegebenenfalls gtk-4 anstelle von gtk4 ) zurückzuführen sind. Stellen Sie bei
Problemen sicher, dass GTK4 auf Ihrem System vorliegt und dass die entsprechenden Umge-
bungsvariablen auf GTK4 verweisen.
War der Build-Prozess erfolgreich, steht der eigentlichen Anwendung nichts mehr im Wege.

Die Anwendung
Erzeugen Sie als nächstes die Datei src/[Link] und fügen Sie den Folgenden Code hinzu:

chapter01/gui/src/[Link]
pub usingnamespace @cImport({
@cInclude("gtk/gtk.h");
});

const c = @cImport({
@cInclude("gtk/gtk.h");
});

/// g_signal_connect re-implementieren

pub fn z_signal_connect(
instance: [Link],
detailed_signal: [*c]const [Link],
c_handler: [Link],
data: [Link],
) [Link] {
var zero: u32 = 0;
const flags: *[Link] = @as(*[Link], @ptrCast(&zero));
return c.g_signal_connect_data(
instance,
detailed_signal,
c_handler,
data,
null,
flags.*,

25 Seltene Ausnahmen bestätigen dabei die Regel

25
 Die Anwendung

);
}

Zig ist zwar ziemlich gut darin mit C zu integrieren, jedoch werden Sie von Zeit zu Zeit noch
auf Probleme stoßen. In den meisten Fällen lässt sich dies jedoch relativ einfach lösen. Innerhalb
von src/[Link] inkludieren wir zuerst die GTK4 Header-Datei gtk.h . Wie Ihnen vielleicht
aufgefallen ist, haben wir an keiner Stelle innerhalb von [Link] auf diese Datei verwiesen.
Zig reicht es in den aller meisten Fällen aus, wenn Sie die Bibliothek benennen die Sie einbinden
möchten und fügt die benötigten Pfade automatisch hinzu.
Das Schlüsselwort usingnamespace sorgt dafür, dass wir auf alle in gtk.h deklarierten Objekte,
über [Link] , direkt zugreifen können.
Eine in gtk.h deklarierte Funktion, die wir später noch benötigen, ist g_signal_connect .
Diese lässt sich leider nicht ohne weiteres direkt verwenden (einer der seltenen Fälle bei denen
Zig derzeit noch versagt). Aus diesem Grund implementieren wir die Funktion selber und nennen
unsere Implementierung z_signal_connect .
Nun haben wir alles vorbereitet und können uns um die eigentliche Anwendung kümmern.
Ersetzen Sie den Code in src/[Link] mit dem folgenden Programm:

chapter01/gui/src/[Link]
const std = @import("std");
const gtk = @import("[Link]");

fn onActivate(app: *[Link]) void {

const window: *[Link] = gtk.gtk_application_window_new(app);

gtk.gtk_window_set_title(
@as(*[Link], @ptrCast(window)),
"Zig Basics",
);
gtk.gtk_window_set_default_size(
@as(*[Link], @ptrCast(window)),
920,
640,
);

gtk.gtk_window_present(@as(*[Link], @ptrCast(window)));
}

pub fn main() !void {

const application = gtk.gtk_application_new(
"[Link]",
gtk.G_APPLICATION_FLAGS_NONE,

26
Zig Basics

);
_ = gtk.z_signal_connect(
application,
"activate",
@as([Link], @ptrCast(&onActivate)),
null,
);
_ = gtk.g_application_run(
@as(*[Link], @ptrCast(application)),
0,
null,
);
}

Ganz oben importieren wir die Standardbibliothek, als auch die Datei [Link] unter dem
Namen gtk . Danach folgt die Funktion onActivate , welche verwendet wird um ein GTK-
Fenster zu erzeugen. Schauen wir uns aber zuerst die main Funktion an.
Innerhalb von main wird als erstes, mithilfe von gtk_application_new , ein Anwendungsob-
jekt erzeugt, welches an die Konstante application gebunden wird. Als nächstes wird an
Callback registriert, der durch das Signal activate aufgerufen wird. Als Callback nutzen wir
die Funktion onActivate . Nachdem die Anwendung mittels g_application_run die GTK-An-
wendung gestartet hat, wird das activate Signal ausgelöst, wodurch onActivate aufgerufen
wird.
Die Funktion onActivate erzeugt als erstes ein neues Fenster für die Anwendung und weist
dem Fenster, mithilfe von get_window_set_title , den Titel Zig Basics zu. Danach wird eine
Fenstergröße von 920 x 640 Pixeln festgelegt, bevor das Fenster mit gtk_window_present
angezeigt wird.
Innerhalb des Root-Verzeichnisses des Projekts können Sie mit zig build run die Anwendung
starten. Nach dem Starten des Programms sollten Sie ein leeres Fenster sehen.

27
 Abbildung 9: Leeres GKT4-Fenster
Nur ein leeres Fenster ist etwas langweilig, deshalb fügen wir als nächstes noch einen Button
hinzu, der den Text „Hello, World!“ auf der Kommandozeile ausgibt. Ich weis, ein Button ist nicht
viel spannender als ein leeres Fenster, er sollte jedoch als Beispiel genügen.
Zuerst muss ein Callback definiert werden, der aufgerufen wird sobald der Button vom Nutzer
gedrückt wird.

chapter01/gui/src/[Link]
fn onButtonClicked(_: *[Link], _: [Link]) void {
[Link]("Hello, World!", .{});
}

Callbacks in GTK erwarten zwei Argumente, einen Zeiger auf das Widget (z.B. der Button)
welches den Callback ausgelöst hat und optional einen Zeiger auf Daten, die an die Funktion
übergeben werden sollen. Da wir weder das Widget noch Daten benötigen, werden die Parame-
ternamen durch _ ersetzt. Damit stellen wir den Compiler zufrieden der erwartet, dass alle
deklarierten Variablen verwendet werden, Parameter eingeschlossen.
Allgemein setzt sich eine GTK Anwendung aus Widgets (Bausteinen) zusammen. Alles was in
einem Fenster angezeigt wird, wird intern als Baumstruktur, bestehend aus Objekten vom Typ
GtkWidget , abgebildet, wobei das Fenster selber die Wurzel des Baums ist. GtkWidget ist dabei
ein generischer Typ, das heist er umfasst Verhalten das von allen Bausteinen geteilt wird, egal
ob es sich dabei um einen Button, Text oder eine andere graphische Komponente handelt.
Fügen Sie den folgenden Code zwischen dem Aufruf von gtk_window_set_default_size und
z_signal_connect ein.

chapter01/gui/src/[Link]

28
Zig Basics

const button = gtk.gtk_button_new_with_label("Click Me!");

gtk.gtk_window_set_child(
@as(*[Link], @ptrCast(window)),
@as(*[Link], @ptrCast(button)),
);
_ = gtk.z_signal_connect(
button,
"clicked",
@as([Link], @ptrCast(&onButtonClicked)),
null,
);

Da alle Bausteine als GtkWidget verwendet werden können ist es teilweise nötig einzelne
Zeiger auf den richtigen, von einer Funktion erwarteten, Parametertypen zu casten. Der Aus-
druck @as(*[Link], @ptrCast(window)) bedeutet zum Beispiel: betrachte den Zeiger
window als einen Zeiger zu einem GtkWindow .

Mit der Funktion gtk_window_set_child kann ein Widget als Kind des gegebenen Fensters
gesetzt werden. Danach registrieren wir noch einen Callback für den Button, der bei einem Click
(Signal „clicked“) ausgelöst wird. Als Callback verwenden wir die Funktion onButtonClicked ,
die wir zuvor definiert hatten.
Nachdem Sie das Programm mit zig build run gestartet haben sollten Sie innerhalb des
Fensters einen Button sehen, der das Fenster ausfüllt.

Abbildung 10: GKT4-Fenster mit Button

Beim clicken des Buttons sollte „Hello, World!“ auf der Kommandozeile ausgegeben werden.
Herzlichen Glückwunsch! Sie haben ihre erste graphische Benutzerobefläche in Zig program-
miert.

29
 Die Anwendung

Zig als C Build-System

Zig integriert nicht nur hervorragend mit C sondern kann auch als Build-System für C und C+
+ Projekte verwendet werden. Damit stellt Zig unter anderem eine Alternative zu Make oder
CMake dar.
Genau wie für Zig Projekte können Sie auch zu Ihren C und C++ Projekten einen [Link]
Datei hinzufügen, welche den Build-Prozess beschreibt. Außerdem macht es Sinn eine
[Link] Datei hinzuzufügen, die zusätzliche Metadaten zu Ihrem Projekt liefert.

In diesem Beispiel möchte ich ihnen Zeigen, wie Sie eine kleine Bibliothek in C schreiben und
diese im Anschluss in einem weiteren Projekt verwenden können.

Bibliothek schreiben
Legen Sie zuerst einen Ordner math an und initialisieren Sie diesen mit cd math && zig init .
Entfernen Sie danach alle Dateien in src und fügen Sie die Datei math.c hinzu, welche den
folgenden Code enthält:

chapter01/math/src/math.c
#include "math.h"

int add(int a, int b) {

return a + b;
}

Definieren Sie danach eine zugehörige Header-Datei:

chapter01/math/src/math.h
#ifdef __cplusplus
extern "C" {
#endif

int add(int, int);

#ifdef __cplusplus
}
#endif

Unsere Bibliothek enthält genau eine Funktion add() , deren Prototyp in der Header-Datei
deklariert wird. Damit die Bibliothek auch mit C++ verwendet werden kann, prüfen wir ob
__cplusplus definiert ist und umschließen die Deklaration falls nötig mit extern "C" { } .
Durch extern "C" sagen wir dem C++-Compiler, dass er keine zusätzlichen Parameterinfor-
mationen dem Namen hinzufügen soll, der zum linken verwendet wird.

30
Zig Basics

Öffnen Sie danach [Link] und entfernen Sie alles bis auf den folgenden Code:

chapter01/math/[Link]
const std = @import("std");

pub fn build(b: *[Link]) void {

const target = [Link](.{});
const optimize = [Link](.{});

const lib = [Link](.{

// Wir verwenden mymath damit es keine Überschneidungen mit
// der math.h aus der C-Standardbibliothek gibt!
.name = "mymath",
.target = target,
.optimize = optimize,
});
[Link](.{
.files = &.{"src/math.c"},
.flags = &.{"-std=gnu11"},
});

[Link]([Link]("src"));
[Link]([Link]("src/math.h"), "mymath.h");

[Link]();
[Link](lib);
}

Mit addSharedLibrary() erzeugen Sie eine neue dynamische Bibliothek. Sollten Sie eine
statische Bibliothek benötigen, können Sie diesen Aufruf einfach durch addStaticLibrary()
austauschen. Die Funktion erwartet ein Argument vom Typ SharedLibraryOptions mit dem
die Eigenschaften der Bibliothek beeinflusst werden können. Dazu zählt unter anderem der Name
der Bibliothek, sowie die Zielarchitektur ( target ) und der Optimierungsgrad ( optimize ).
C-Quelldateien können der Bibliothek lib , mit der Methode addCSourceFiles() , hinzugefügt
werden. Zusätzlich zu den Quelldateien können auch Flags angegeben werden, die beim kompi-
lieren mit berücksichtigt werden sollen. addCSourceFiles() kann dabei beliebig oft aufgerufen
werden.

[Link](.{
.files = &.{"src/math.c"},
.flags = &.{"-std=gnu11"},
});

Zig sucht automatisch nach benötigten Headern im System (zum Beispiel in /usr/include),
jedoch kann es auch nötig sein weitere Pfade anzugeben, in denen für das Projekt benötigte

31
 Bibliothek schreiben

Header liegen. Dies erfolgt durch die addIncludePath() Methode, welche auf dem mit
addStaticLibrary() erzeugten Objekt aufgerufen wird. Der Pfad kann relativ zum Root-
Verzeichnis des Projekts angegeben werden.

[Link]([Link]("src"));

Wenn die eigene Bibliothek Header exportieren soll, die für die Verwendung der Bibliothek
benötigt werden, so kann dies durch installHeader() erfolgen. Die Methode erwartet als
erstes Argument einen Pfad zu der zu exportierenden Header-Datei und als zweites den Namen
für die Header-Datei, unter welchem diese exportiert werden soll. Im gegebenen Fall exportieren
wir die Header Datei unter dem Namen mymath.h, damit diese sich nicht mit der math.h aus der
Standardbibliothek überschneidet.

[Link]([Link]("src/math.h"), "mymath.h");

Bei der Verwendung von C wird in den meisten Fällen LibC benötigt, die Standardbibliothek für
die Programmiersprache C. Diese kann mit linkLibC() gelinkt werden.

[Link]();

Mit installArtifact() kann Zig angewiesen werden die Bibliothek zu bauen.

[Link](lib);

Nach dem Ausführen von zig build sollten Sie die folgenden Dateien in zig-out vorfinden:

$ ls -R zig-out/
zig-out/:
include lib

zig-out/include:
math.h

zig-out/lib:
libmath.a

Um die Bibliothek systemweit verwenden zu können, müssen die Dateien an die entsprechenden
Stellen im Dateisystem kopiert werden. Unter Linux ist dies zum Beispiel /usr/local/include für
math.h. Für dieses Beispiel wird dies jedoch nicht benötigt.

Bibliothek einbinden

32
Zig Basics

Um die im vorherigen Abschnitt implementierte Bibliothek zu verwenden, erzeugen wir mit

mkdir user && cd user && zig init ein neues Projekt, im selben Verzeichnis, in dem auch
math liegt.
Für diesen Teil des Beispiels verwenden wir C++, damit Sie mir auch glauben wenn ich Ihnen
sage, dass Sie Zig sowohl für C als auch C++ Projekte verwenden können. Löschen Sie alle
Dateien unter src und fügen Sie die Datei src/[Link] hinzu.

chapter01/user/src/[Link]
#include <iostream>
#include "mymath.h"

int main()
{
std::cout << "4 + 3" << add(4, 3) << "\n";
}

Fügen Sie als nächstes unter [Link] die math Bibliothek als Abhängigkeit hinzu:

chapter01/user/[Link]
//...
.dependencies = .{
.mymath = .{
.path = "../math",
},
},
//...

Entfernen Sie dann alles bis auf den folgenden Code aus [Link]:

chapter01/[Link]
const std = @import("std");

pub fn build(b: *[Link]) void {

const target = [Link](.{});
const optimize = [Link](.{});

const math_dep = [Link]("mymath", .{

.target = target,
.optimize = optimize,
});

const exe = [Link](.{

.name = "user",

33
 .target = target,
.optimize = optimize,
});
[Link](.{
.files = &.{"src/[Link]"},
.flags = &.{},
});
[Link](math_dep.artifact("mymath"));
[Link]();
[Link](exe);

// Erlaubt es mit `zig build run` die Anwendung auszuführen.

const run_cmd = [Link](exe);
run_cmd.[Link]([Link]());
if ([Link]) |args| {
run_cmd.addArgs(args);
}
const run_step = [Link]("run", "Run the app");
run_step.dependOn(&run_cmd.step);
}

Zwei Besonderheiten dieses Build-Skripts sind zum einen der Aufruf von [Link]() ,
sowie [Link]() .
Mit [Link]() können sie, über den Namen (in diesem Fall mymath ), auf die in
[Link] definierten Abhängigkeiten zugreifen. Als zusätzliches Argument erwartet die
Methode sowohl die Zielarchitektur als auch den Optimierungsgrad.

const math_dep = [Link]("mymath", .{

.target = target,
.optimize = optimize,
});

Die mymath Abhängigkeit enthält sowohl die dynamische Bibliothek, als auch die zugehörige
Header-Datei mymath.h (beziehungsweise die Bauanleitung für diese). Mit [Link]()
können wir die Bibliothek mit unserer Executable linken. Hierzu greifen wir mit
math_dep.artifact("mymath") auf die Bibliothek zu und übergeben diese an linkLibrary()
26.

[Link](math_dep.artifact("mymath"));

Mit zig build run können Sie die C++-Anwendung bauen und ausführen.

26 Eigentlich greifen wir mit artifact() auf den Compile-Step für mymath zu.

34
Zig Basics

$ zig build run

4 + 3 = 7

35
36
Zig Basics

Kapitel 2

Grundlagen

Zig ist eine kompilierte Sprache, d.h. sie wird, bevor der Programmcode ausgeführt werden kann,
in eine Sprache übersetzt die vom Prozessor verstanden wird. Die Übersetzungsarbeit übernimmt
dabei ein Compiler.
Zig verfügt über viel Datentypen, darunter vorzeichenbehaftete und -unbehaftete Ganzzahlen
(Integer), Fließkommazahlen (Float), Booleans und Stirngs. Weiterhin besitzt Zig eine Vielzahl
an Collection-Typen, darunter Arrays, Tuples.
Zig unterscheidet bei Variablen zwischen Variablen und Konstanten, welche Werte speichern,
die über einen Namen referenziert werden. Der Name einer Variable beziehungsweise Konstante
wird auch als Identifier bezeichnet. Konstanten sind nach ihrer Initialisierung nicht mehr verän-
derbar, während Variablen neu zugewiesen werden können. Durch die Unterscheidung zwischen
Variablen und Konstanten kann die Absicht hinter einer Variablen-Deklaration eindeutiger
ausgedrückt werden.
Zusätzlich zu simplen Typen stellt Zig zusätzliche Collection-Typen, darunter Hash-Maps und
Array-Listen, über die Standardbibliothek bereit.
Weiterhin unterstützt Zig optionale Typen, welche die Abwesenheit eines Wertes ausdrücken.
Das heißt ein optionaler Typ kann entweder einen Wert besitzen oder keinen. Optionals ersetzen
unter anderem NULL-Pointer, wodurch vielen, aus C bekannten Speicherfehlern, vorgebeugt
werden kann.
In Zig sind Fehler ebenfalls Werte, das heißt anstatt eine Exception zu werfen können Funktionen
einen Fehler-Wert an die Aufrufende Funktion zurückgeben, welche potenzielle Fehler behan-
deln muss bevor auf den eigentlichen Rückgabewert zugegriffen werden kann.

Im laufe dieses Buches werden Sie häufiger auf die Wörter Ausdruck (engl.
Expression) und Statement stoßen. Ein Ausdruck ist ein „Stück-Code“, das evalu-
iert werden kann und einen Wert produziert. Statements dagegen, produzieren
keinen Wert, das heißt sie können unter anderem nicht als Funktionsargument
verwendet werden.

37
Konstanten und Variablen
Konstanten und Variablen bestehen aus einem Namen in Snake-Case ( buffer oder
private_key ) und einem Typen (zum Beispiel u8 oder []const u8 ). Sie werden verwendet
um Werte vom entsprechenden Typ zu binden (zum Beispiel 13 oder "Hello, World!" ).
Konstanten können nach ihrer Initialisierung nicht mehr neu zugewiesen werden.

Variablen-Deklarationen
Konstanten und Variablen müssen vor ihrer Verwendung deklariert und initialisiert werden.
Konstanten werden mit dem const Schlüsselwort deklariert, während für Variablen var
verwendet wird.

const es256 = "ES256";

var retries = 3;
retries -= 1;

In diesem Beispiel wird ein Konstante mit dem Namen es256 deklariert und ihr wird der Wert
"ES256" zugewiesen. Danach wird eine Variable mit dem Namen retries deklariert und der
Wert 3 zugewiesen. Die Anzahl an Versuchen muss als Variable deklariert werden, da die Anzahl
dekrementiert wird.
Sollte eine Variable sich nach ihrer Initialisierung nicht mehr verändern muss diese immer als
Konstante deklariert werden! Dies wird vom Compiler sichergestellt.
Konstanten und Variablen müssen bei ihrer Deklarationen auch initialisiert werden. Alternativ
kann ihnen auch der Wert undefined zugewiesen werden, was so viel bedeutet wie „der Wert
der Variable ist zu diesem Zeitpunkt undefiniert“.

var later: u8 = undefined;

later = 3;

Wichtig zu betonen ist bei der Verwendung von undefined , dass Zig den Typ der Variable nicht
ableiten kann. Deshalb muss der Typ, bei der Deklaration der Variable, explizit mit angegeben
werden.

Typ-Annotationen
Durch Typ-Annotation kann der Typ einer Konstante oder Variable angegeben werden. Hierzu
wird hinter dem Variablen-Namen ein „ : “ angehängt, gefolgt vom Namen des Typen, der
verwendet werden soll.

const hello: []const u8 = "Hello, World!";

38
Zig Basics

Im obigen Beispiel wird eine Konstante mit dem Namen hello vom Typ []const u8 (String)
deklariert.
In vielen Fällen kann Zig den Typ einer Variable ableiten, zum Beispiel durch den verwendeten
Initialisierungswert. Es gibt jedoch auch Situationen, bei denen der Typ einer Variable klar
ausgedrückt werden muss. Ein solcher Fall betrifft die Verwendung von undefined , bei dem
der Compiler keinen Typen für die Variable ableiten kann. Es gibt jedoch auch Situationen, bei
denen der Compiler den falschen Typen für eine Variable bestimmt.

var i = 0;
while (i < 10) : (i += 1) {}

Im obigen Beispiel wird der Variable i der Typ comptime_int zugewiesen, da Integer-Literale
ebenfalls vom Typ comptime_int sind. Variablen vom Typ comptime_int müssen jedoch zur
Kompilierzeit bekannt sein, was im gegebenen Fall nicht zutrifft, da i zur Laufzeit, innerhalb
der Schleife, inkrementiert wird.
Dies führt zu dem folgenden Fehler beim Kompilieren:

$ zig build-exe chapter02/[Link]

error: variable of type 'comptime_int' must be const or comptime
var i = 0;
^
note: to modify this variable at runtime, it must be given an explicit fixed-
size number type

Um da Problem zu lösen muss der Variable i ein Integer-Typ mit einer bekannten Größe
zugewiesen werden. Für Zähler-Variablen ist dies oft usize .

var i: usize = 0;
while (i < 10) : (i += 1) {}

Variablen benennen
Die Namen von Konstanten und Variablen müssen mit einem Buchstaben oder Underscore ( _ )
beginnen, gefolgt einer beliebigen Anzahl an Buchstaben oder Ziffern. Dabei ist darauf zu achten,
dass der Name nicht mit dem Identifier eines Schlüsselworts überlappt. Zum Beispiel ist es nicht
erlaubt eine Konstante const zu nennen.

const pi = 3.14;
const private_key = "\x01\x02\x03\x04";

Es ist Konvention, die Namen von Variablen und Konstanten in Snake-Case zu schreiben, das
heißt Wörter werden in Kleinbuchstaben geschrieben, getrennt durch einen Unterstrich ( _ ).

39
 Variablen benennen

Die Namen von Variablen dürfen niemals die Namen von Variablen aus einem umschließenden
Scope überschatten, das heißt sie dürfen nicht den selben Namen besitzen.
Sollte ein Name nicht die genannten Bedingungen erfüllen, so kann die @"" Syntax verwendet
werden.

const @"π" = 3.14;

Die @"" Syntax kann auch verwendet werden um Schlüsselwörter als Varia-
blen-Namen verwenden zu können. Dies sollte jedoch vermieden werden um
Verwirrung vorzubeugen.

Lokale Variablen
Lokale Variablen erscheinen innerhalb von Funktionen, Comptime-Blöcken und @cImport -
Blöcken.
Einer lokalen Variable kann das comptime Schlüsselwort vorangestellt werden. Dadurch ist der
Wert der Variable zur Kompilierzeit bekannt und das Laden und Speichern der Variable passiert
während der semantischen Analyse des Programms, anstatt zur Laufzeit.

const std = @import("std");

test "comptime vars" {

var x: i32 = 1;
comptime var y: i32 = 1;

x += 1;
y += 1;

try [Link](x == 2);

try [Link](y == 2);

// Da `y` zur Kompilierzeit bekannt ist und die Bedingung ebenfalls

// zur Kompilierzeit überprüft werden kann, wird der gegebene
// Block vom Compiler weg-optimiert, wodurch der Compile-Error
// nicht ausgelöst wird.
if (y != 2) {
@compileError("wrong y value");
}
}

Die Life-Time einer lokalen Variable, das heißt der Zeitraum in dem die Variable existiert, beginnt
und endet mit dem Block, indem sie deklariert wurde.

40
Zig Basics

Container-Level Variablen
Container-Level Variablen werden außerhalb einer Funktion, Comptime-Blocks oder @cImport
-Blocks deklariert und sind vergleichbar mit globalen Variablen in anderen Sprachen.

Jedes syntaktische Konstrukt in Zig, welches als Namensraum dient und Varia-
blen- oder Funktionsdeklaraionen umschließt, wird als Container bezeichnet.
Weiterhin können Container selbst Typdeklarationen sein, welche instantiiert
werden können. Dazu zählen struct s, enum s, union s und sogar Quellcode-
Dateien mit der Dateiendung .zig.

Der Initialisierungswert einer container-level Variable ist implizit comptime . Ist die deklarierte
Variable eine Konstante, so ist ihr Wert zur Kompilierzeit bekannt, andernfalls ihr Wert zur
Laufzeit bekannt.

const std = @import("std");

var x: i32 = sub(y, 10);

const y: i32 = sub(34, 9);

fn sub(a: i32, b: i32) i32 {

return a - b;
}

test "Container-Level Variablen" {

try [Link](x == 15);
try [Link](y == 25);
}

Die Life-Time einer container-level Variable ist statisch, das heißt die Variable existiert während
der gesamten Laufzeit des Programms.

Statisch-lokale Variablen
Es ist möglich lokale Variablen mit einer statischen Life-Time zu deklarieren, indem ein Contai-
ner innerhalb einer Funktion verwendet wird.

chapter02/static_local_variable.zig
const std = @import("std");

fn next() i32 {
const S = struct {
var x: i32 = 0;
};

41
 defer S.x += 1;
return S.x;
}

test "Statische, lokale Variable" {

try [Link](next() == 0);
try [Link](next() == 1);
try [Link](next() == 2);
}

Kommentare
Kommentare können genutzt werden um die Funktionsweise von Programmabschnitten zu
Dokumentieren. Dabei unterscheidet Zig zwischen drei Arten von Kommentaren.
Normale Kommentare beginnen mit // und können an einer beliebigen Stelle im Code platziert
werden. Alles was auf // innerhalb einer Zeile folgt ist Teil des Kommentars.

// Das ist ein Kommentar

Doc-Kommentare können für die Dokumentation einzelner Programmteile genutzt werden und
beginnen mit /// . Mehrere, hintereinander folgende Doc-Kommentare bilden einen zusam-
menhängenden Block und erlauben es Kommentare über mehrere Zeilen hinweg zu verfassen.
Doc-Kommentare sind kontextabhängig und dokumentieren was auch immer dem Kommentar
folgt.

chapter02/[Link]
//! Ein Modul bestehend aus einem Struct `Color` und
//! einer Funktion `add(u32, u32) u32`.

const std = @import("std");

/// Eine Farbe bestehend aus Red, Green und Blue.

pub const Color = struct {
r: u8,
g: u8,
b: u8,
};

/// Addition zweier Zahlen.

///
/// # Argumente
/// * `a`- Die erste Zahl

42
Zig Basics

/// * `b`- Die zweite Zahl

///
/// # Rückgabewert
/// Das Resultat von `a + b`.
pub fn add(a: u32, b: u32) u32 {
return a + b;
}

test "Main Test" {

_ = Color;
try [Link](add(3, 4) == 7);
}

Top-Level-Kommentare beginnen mit //! und dokumentieren den umschließenden Container.

Sie werden in der Regel genutzt um Module zu dokumentieren.

Mit zig test -femit-docs <your-code>.zig können die Doc- und Top-
Level-Kommentare in eine HTML-Seite umgewandelt werden. Zig wird
hierfür einen neuen Ordner mit dem Namen docs anlegen. Mit
python3 -m [Link] kann ein HTTP-Server gestartet werden um die
Dokumentation anzuzeigen.
Zurzeit scheint es jedoch noch Probleme mit dem Erzeugen zu geben.

Ganzzahlen (Integer)
Integer sind Ganzzahlen, das heißt sie Besitzt keine Bruchkomponente und können entweder
vorzeichenbehaftet (signed) oder vorzeichenunbehaftet (unsigned) sein.
Zig unterstützt Ganzzahlen mit einer beliebigen Bitbreite. Der Bezeichner eines jeden Integer-
Typen beginnt mit einem Buchstaben i (signed) oder u (unsigned) gefolgt von einer oder
mehreren Ziffern, welche die Bitbreite in Dezimal darstellen. Als Beispiel, i7 ist eine vorzei-
chenbehaftete Ganzzahl der sieben Bit zur Kodierung der Zahl zur Verfügung stehen. Die
Aussage, dass die Bitbreite beliebig ist entspricht dabei nicht ganz der Wahrheit. Die maximal
erlaubte Bitbreite beträgt 216 − 1 = 65535. Beispiele für Integer sind:

Typ Wertebereich

i7 −26 bis 26 − 1

i32 −231 bis 231 − 1

u8 0 bis 28 − 1

43
 Typ Wertebereich

u64 0 bis 264 − 1

Darstellung von Integern im Speicher

Vorzeichenbehaftete Ganzzahlen werden im Zweierkomplement dargestellt27. In Assembler wird
nicht zwischen vorzeichenbehafteten und vorzeichenunbehafteten Zahlen unterschieden. Alle
mathematischen Operationen werden von der CPU auf Registern, mit einer festen Bitbreite
(meist 64 Bit auf modernen Computern), ausgeführt. Dabei entspricht jede, vom Computer
ausgeführte, arithmetische Operationen effektiv einem „Rechnen mit Rest“, auch bekannt als
modulare Arithmetik28. Die Bitbreite 𝑚 der Register (z.B. 64) repräsentiert dabei den Modulo
2𝑚 . Damit entspricht ein 64 Bit Register dem Restklassenring ℤ264 = {0, 1, 2, …, 264 − 1} und
jegliche Addition zweier Register resultiert in einem Wert der ebenfalls in ℤ264 liegt, d.h. auf
x86_64 wäre die Instruktion add rax, rbx äquivalent zu rax = rax + rbx mod 264 . Diese
Verhalten überträgt sich analog auf Ganzzahlen in Zig.
Das Zweierkomplement einer Zahl 𝑎 ∈ ℤ𝑚 ist das additive Inverse 𝑎′ dieser Zahl, d.h. 𝑎 +
𝑎′ ≡ 0. Dieses kann mit 𝑎′ = 𝑚 − 𝑎 berechnet werden. Für i8 wäre das additive Inverse zu
𝑎 = 4 die Zahl 𝑎′ = 28 − 4 = 256 − 4 = 252. Addiert man beide Zahlen modulo 256, so erhält
man wiederum das neutrale Element 0, 𝑎 + 𝑎′ mod 256 = 4 + 252 mod 256 = 256 mod 256 =
0. Das Zweierkomplement hat seinen Namen jedoch nicht von der Subtraktion, sondern von der
speziellen Weise wie das additive Inverse einer Zahl bestimmt wird. Dieser Vorgang kann wie
folgt beschrieben werden:
1. Gegeben eine Zahl in Binärdarstellung, invertiere jedes Bit, d.h. jede 1 wird zu einer 0 und
umgekehrt.
2. Addiere 1 auf das Resultat und ignoriere mögliche Überläufe.
Für das obige Beispiel mit der Zahl 4 vom Typ i8 sieht dies wie folgt aus:
000001002 = 416 invertiere alle Bits der Zahl 4
111110112 = 25116 addiere 1 auf die Zahl 251
111111002 = 25216

Integer-Literale
Zur Compile-Zeit bekannte Literale vom Typ comptime_int haben kein Limit was ihre Größe
(in Bezug auf die Bitbreite) und konvertieren zu anderen Integertypen, solange das Literal im
Wertebereich des Typen liegt.

27 [Link]
28 [Link]

44
Zig Basics

// Variable `i` vom Typ `comptime_int`

var i = 0;

Optional können die Prefixe 0x , 0o und 0b an ein Literal angehängt werden um Literale in
Hexadezimal, Octal oder Binär anzugeben, z.B. 0xcafebabe .
Um größere Zahlen besser lesbar zu machen, kann ein Literal mit Hilfe von Unterstrichen
aufgeteilt werden, z.B. 0xcafe_babe .

Laufzeit-Variablen
Um die Variable zur Laufzeit modifizieren zu können, muss ihr eine expliziter Type mit fester
Bitbreite zugewiesen werden. Dies kann auf zwei weisen erfolgen.
1. Deklaration der Variable i mit explizitem Typ, z.B. var i: usize = 0 .
2. Verwendung der Funktion @as() , von welcher der Compiler den Type der Variable i
ableiten kann, z.B. var i = @as(usize, 0) .
Ein häufiger Fehler, der aber schnell behoben ist, ist die Verwendung einer Variable vom Typ
comptime_int in einer Schleife.

var i = 0;
while (i < 100) : (i += 1) {}

Was zu einem entsprechenden Fehler zur Kompilierzeit führt.

$ zig build-exe chapter02/[Link]

error: variable of type 'comptime_int' must be const or comptime
var i = 0;
^
note: to modify this variable at runtime, it must be given an explicit fixed-
size number type

Der Zig-Compiler ist dabei hilfreich, indem er neben dem Fehler auch einen Lösungsansatz
bietet. Nachdem der Variable i ein expliziter Typ zugewiesen wird ( var i: usize ) compiliert
das Programm ohne weitere Fehler.

Integer-Operatoren
Zig unterstützt verschiedene Operator für das Rechnen mit Integern, darunter + (Addition), -
(Subtraktion), * (Multiplikation) und / (Division).
Die Verwendung dieser Operatoren führt bei einem Überlauf jedoch zu undefiniertem Verhalten
(engl. undefined behavior). Aus diesem Grund stellt Zig spezielle Versionen dieser Operatoren
zur Verfügung, darunter:

45
 Integer-Operatoren

• Operatoren für Sättigungsarithmetik: Alle Operationen laufen in einem festen Intervall

zwischen einem Minimum und einem Maximum ab welches nicht unter- bzw. überschritten
werden kann.
‣ Addition ( +| ): @as(u8, 255) +| 1 == @as(u8, 255)
‣ Subtraktion ( -| ): @as(u32, 0) -| 1 == 0
‣ Multiplikation ( *| ): @as(u8, 200) *| 2 == 255
• Wrapping-Arithmetik: Dies ist äquivalent zu modularer Arithmetik.
‣ Addition ( +% ): @as(u32, 0xffffffff) +% 1 == 0
‣ Subtraktion ( -% ): @as(u8, 0) -% 1 == 255
‣ Multiplikation ( *% ): @as(u8, 200) *% 2 == 144

Integer-Bounds
Auf den Minimal- und Maximalwert eines Integers kann mit [Link] und
[Link] zugegriffen werden.

try [Link](minInt(i128) == -170141183460469231731687303715884105728);

try [Link](maxInt(i128) == 170141183460469231731687303715884105727);

Beide Funktionen erwarten als Argument den Integer-Typ, für den das Minimum oder Maximum
bestimmt werden soll. Da beide Funktionen comptime sind wird der Rückgabewert zur Kompi-
lierzeit bestimmt.

Fließkommazahlen (Float)
Fließkommazahlen haben eine Bruchkomponente, wie etwa 3.14 oder -0.5 .
Im Gegensatz zu Integern erlaubt Zig keine beliebige Bitbreite für Fließkommazahlen. Zur
Verfügung stehen:

Typ Repräsentation

f16 IEEE-754-2008 binary16

f32 IEEE-754-2008 binary32

f64 IEEE-754-2008 binary64

f80 IEEE-754-2008 80-bit extended precision

f128 IEEE-754-2008 binary128

Der Typ f32 entspricht dem Typ float (single precision) in C, während f64 dem Typ double
(double precision) entspricht. Je nach Prozessortyp stehen dedizierte Maschineninstruktionen

46
Zig Basics

für zumindest einen Teil der Typen zur Verfügung, was eine effizientere Verwendung ermöglicht.
Auf x86_64 Prozessor stehen z.B. Instruktionen für single und double Precision zur Verfügung.

Float-Literale
Literale sind immer vom Typ comptime_float , welcher äquivalent zum größtmöglichen Fließ-
kommatypen ( f128 ) ist, und können zu jedem beliebigen Fließkommatypen konvertiert werden.
Enthält ein Literal keinen Bruchteil, so ist eine Konvertierung zu einem Integertyp ebenfalls
möglich.
Alle Float-Literale haben einen Dezimalpunkt ( . ). Sie können entweder als Dezimalzahl ange-
geben werden (ohne Präfix) oder als Hexadezimalzahl (mit dem Präfix 0x ). Optional kann ein
Exponent mit angegeben werden. Für Dezimalzahlen wird hierfür ein E oder e verwendet und
für Hexadezimalzahlen ein P oder p .
Für Dezimalzahlen mit einem Exponenten e wird die angegebene Fließkommazahl mit 10𝑒
multipliziert:
• 123.0E+77 = 123.0 ∗ 1077
Für Hexadezimalzahlen mit einem Exponenten p wird die Fließkommazahl mit 2𝑝 multipliziert:
• 0x103.70p-5 = 103.7016 ∗ 2−5

const fp = 123.0E+77;
const hfp = 0x103.70p-5;

Darstellung von Floats im Speicher

Die interne Darstellung einer Fließkommazahl besteht für das Format IEEE-754 aus einem Vor-
zeichenbit, gefolgt von einem Exponenten und einem Bruch. Wie viele Bits jeweils für Exponent
und Bruch zur Verfügung stehen ist abhängig von der Bitbreite der Fließkommazahl. Für IEEE-754
binary32 sieht dies wie folgt aus:

31 30 … 23 22 … 0
s exponent (e) fraction (f)

Diese Darstellung entspricht der Gleichung (−1)𝑠 ∗ 1.𝑓 ∗ 2𝑒−127 . Der Bruch 𝑓 entspricht einer
normalisierten, binär kodierten Fließkommazahl, d.h. die Zahl wird um eine entsprechende
Anzahl an Stelle verschoben, sodass genau eine führende Eins vor dem Komma steht. Als Beispiel
entspricht die Fließkommazahl 3.25 in binär der Zahl 11.01 oder anders ausgedrückt 11.01 ∗
20 . Um die Zahl zu normalisieren wird diese nun um eine Stelle nach rechts verschoben 1.101 ∗
21 . Die Zahl nach der führenden Eins (101) entspricht 𝑓 und der Exponent 𝑒 ist die Summe des
Exponenten der normalisierten Darstellung und einem Bias (im Fall von f32 ist dieser 127), d.h.
𝑒 = 1 + 127 = 12816 = 100000002 . Damit wird 3.25 wie folgt kodiert:

47
 Darstellung von Floats im Speicher

31 30 … 23 22 … 0
0 100000002 101000000000000000000002

Aufgrund der Darstellung von Fließkommazahlen kann sich die Ausführung

bestimmter Operationen, wie ein Tests auf Gleichheit ( == ), als trickreich her-
ausstellen. Ein Beispiel ist die wiederholte Addition der Fließkommazahl 0.1.
Die Summe ∑10 𝑘=1
0.1 ist erwartungsgemäß 1.0, je nach Präzision der Fließkom-
mazahl gilt jedoch ∑10𝑘=1
0.1 ≠ 1.0.

Konvertierung von numerischen Typen

Von Zeit zu Zeit kann es nötig sein einen numerischen Typen in einen anderen zu konvertieren.
Hierfür stehen die eingebauten Funktionen @intCast() und @floatCast() zur Verfügung.

Integer Konvertierung
Die Funktion @intCast(anytype) konvertiert einen Integer zu einem anderen Integer, wobei
der numerische Wert beibehalten wird. Der Typ des Rückgabewertes wird dabei vom Compiler
abgeleitet. Hierzu muss @as() in Kombination mit @intCast() verwendet werden. Alternativ
kann einer Variable auch explizit ein Typ zugewiesen werden, an den der konvertierte Wert
gebunden werden soll.

chapter02/[Link]
test "Konvertierungs-Test: pass" {
var a: u16 = 0x00ff; // runtime-known
_ = &a;
const b: u8 = @intCast(a);
_ = b;
const c = @as(u8, @intCast(a));
_ = c;
}

Grundsätzlich kann zwischen einer Narrowing- und Widening-Konvertierung unterschieden

werden. Bei ersterer ist der Ziel-Typ kleiner als der ursprüngliche Typ. Hierdurch kann es
passieren das der numerische Wert „out-of-range“ ist, das heißt der Ziel-Typ hat nicht genug
Bits um den Wert im Speicher darzustellen. Ein solcher Fall führt zu undefiniertem Verhalten,
wobei Zig, je nach Optimierung, das „Abschneiden“ von Bits erkennt und den Prozess vorzeitig
beendet.

chapter02/[Link]

48
Zig Basics

test "Konvertierungs-Test: fail" {

var a: u16 = 0x00ff; // runtime-known
_ = &a;
const b: u7 = @intCast(a);
_ = b;
}

$ zig test [Link]

thread 363318 panic: integer cast truncated bits
zig-book/code/chapter02/[Link]:19: 0x103cdad in
[Link]-Test: fail (test)
const b: u7 = @intCast(a);
^
zig-linux-x86_64-0.13.0/lib/compiler/test_runner.zig:157:25: 0x1048099 in
mainTerminal (test)
if (test_fn.func()) |_| {
^
zig-linux-x86_64-0.13.0/lib/compiler/test_runner.zig:37:28: 0x103e11b in main
(test)
return mainTerminal();
^
zig-linux-x86_64-0.13.0/lib/std/[Link]:22: 0x103d259 in
posixCallMainAndExit (test)
[Link]();
^
zig-linux-x86_64-0.13.0/lib/std/[Link]:5: 0x103cdc1 in _start (test)
asm volatile (switch (native_arch) {
^
???:?:?: 0x0 in ??? (???)

Sollte es erlaubt sein einen Wert, bei einer Narrowing-Konvertierung, abzuschneiden, so kann
entweder @truncate oder alternativ der Und-Operator ( & ) in Kombination mit einer Bit-Maske
verwendet werden.
Widening-Konvertierungen wiederum sind unkritisch und damit immer erfolgreich.

Float Konvertierung
Die Funktion @floatCast(anytype) konvertiert einen Float zu einem anderen Float, wobei der
numerische Wert an Präzision verlieren kann. Die Konvertierung von Floats ist dabei sicher. Der
Typ des Rückgabewerts wird wie bei der Konvertierung von Integern abgeleitet.

chapter02/[Link]

49
 test "Float Konvertierung" {
var a: f32 = 1234567.0; // runtime-known
_ = &a;
const b: f16 = @floatCast(a);
_ = b;
}

Typen Alias
Alle primitiven Typen in Zig haben type als ihren Meta-Typ und können selbst an Konstanten
gebunden werden. Damit erlaubt Zig die Definition eines Alias für einen bestehenden Typen.
Ein Alias ist nützlich, um einen Typen bei einem Namen zu referenzieren. Beispielsweise werden
Universally Unique Identifier (UUID)29 als 128-Bit-Zahl kodiert.

[Link]
/// Universally Unique IDentifier
///
/// A UUID is 128 bits long, and can guarantee uniqueness across space and
time (RFC4122).
pub const Uuid = u128;

Nachdem ein Alias definiert wurde kann dieser überall verwendet werden, wo auch der
ursprüngliche Bezeichner des Typen verwendet werden kann.

[Link]
/// Create a version 4 UUID using a user provided RNG
pub fn new2(r: [Link]) Uuid {
// Set all bits to pseudo-randomly chosen values.
var uuid: Uuid = [Link](Uuid);
// Set the two most significant bits of the
// clock_seq_hi_and_reserved to zero and one.
// Set the four most significant bits of the
// time_hi_and_version field to the 4-bit version number.
uuid &= 0xffffffffffffff3fff0fffffffffffff;
uuid |= 0x00000000000000800040000000000000;
return uuid;
}

Booleans
29 [Link]

50
Zig Basics

Zig besitzt einen primitiven Boolean Typ bool . Ein Boolean ist ein Daten-Typ der zwei mögliche
Werte annehmen kann true oder false . Er ist nach Georg Boole30 benannt, der die Boolsche-
Algebra definierte.
Booleans werden primär in Conditional-Satements und -Expressions (Kontrollstrukturen)
verwendet31, zum Beispiel in Kombination mit If-Then-Else Blöcken, um zu bestimmen, welcher
Block ausgeführt werden soll.

const name = "Sesam, öffne dich!";

if ([Link](u8, name, "Sesam, öffne dich!") {

[Link]("Ruhm und Reichtum!", .{});
} else {
[Link]("...", .{});
}

Die Funktion [Link] überprüft ob die zwei gegebenen Strings, bezogen auf ihren Inhalt,
gleich sind. Falls ja wird der Wert true zurückgegeben, andernfalls der Wert false .
Im Gegensatz zu C verhindert Zig, dass numerische Werte als Booleans verwendet werden32.

defer
Mit dem defer Schlüsselwort können Ausdrücke und Blöcke markiert werden, die beim
Verlassen eines Blocks ausgeführt werden sollen. Solche defer -Ausdrücke und -Blöcke werden
in der umgekehrten Reihenfolge ausgeführt, in welcher sie definiert wurden.

chapter02/[Link]
const std = @import("std");
const print = [Link];

fn myDefer() void {
defer {
print("Wird als zweites ausgeführt\n", .{});
}

defer print("Wird als erstes ausgeführt\n", .{});

if (false) {
defer print("Wird nie ausgeführt\n", .{});
}

30 [Link]
31 [Link]
32 In C ist der Wert 0 äquivalent zu False und alle verbleibenden Werte äquivalent zu True .

51
 }

test "defer test #1" {

myDefer();
}

defer s werden dabei nur ausgeführt, wenn Sie beim Ausführen eines Blocks auch erreicht
wurden. Im obigen Beispiel kommt zuerst ein defer -Block vor, gefolgt von einem defer -
Ausdruck. Da defer s in umgekehrter Reihenfolge ausgeführt werden, wird beim Verlassen der
Funktion zuerst „Wird als erstes ausgeführt“ auf der Kommandozeile ausgegeben, gefolgt von
„Wird als zweites ausgeführt“. „Wird nie ausgeführt“ wird nicht ausgegeben, da die If-Bedingung
immer false ist und somit der If-Block nie ausgeführt wird.
defer s eignen sich besonders gut zum aufräumen von Ressourcen. Ein Beispiel hierfür ist die
Deallokation von dynamisch alloziertem Speicher. Es ist gängige Praxis, dass auf die dynamische
Allokation von Speicher ein defer folgt, welches den Speicher wieder frei gibt, sollte dieser
nach dem Verlassen des umschließenden Blocks nicht mehr benötigt werden.

var mem = try [Link].c_allocator.alloc(T: u8, n: 16);

defer [Link].c_allocator.free(mem);
// do something...

Optionals
In Situationen bei denen eine Wert fehlen kann, können Optionals verwendet werden. Ein
Optional repräsentiert zwei mögliche Zustände: Entweder es ist ein Wert vorhanden oder es
ist kein Wert vorhanden. Dies ist nicht zu verwechseln mit undefinierten Werten, die bei der
Verwendung von undefined vorkommen!
Als ein Beispiel stellt die Zig Standardbibliothek die Funktion [Link] zur Verfügung.
Diese erlaubt das Konvertieren eines Integer in einen anderen Integer-Typen. Falls der gegebene
Wert nicht in den neuen Integer-Typen passt, so wird von der Funktion null zurückgegeben.

const std = @import("std");

const cast = [Link];

test "Integer Konvertierung" {

try [Link](cast(u8, @as(u32, 300)) == null);
try [Link](cast(u8, @as(u32, 255)).? == @as(u8, 255));
}

Ein optionaler Typ besteht aus einem beliebigen Typen, dem ein ? vorangestellt wird, zum
Beispiel ?u32 oder ?[]const u8 .

52
Zig Basics

null
Um einer optionalen Variable einen wertlosen Zustand zuzuweisen, wird der Wert null
verwendet.

var optional: ?u32 = 7;

optional = null;

Sollte eine optionale Variable einen Wert besitzen, so wird dieser als „ungleich zu null “
betrachtet. Dies kann mit dem Gleicheits- ( == ) beziehungsweise Ungelichheits-Operator ( != )
abgefragt werden.

chatper02/[Link]
test "Optional" {
const num: ?u8 = [Link](u8, @as(u32, 255));

if (num != null) {
try [Link](num.? == 255);
} else {
try [Link](1 == 0); // fail
}
}

Mit dem ? -Operator kann auf den Wert eines Optionals zugegriffen werden. Es sollte jedoch
sichergestellt werden, dass ein Wert existiert!
Das obige Beispiel kann auch wie folgt geschrieben werden:

chatper02/[Link]
test "Optional #2" {
const num: ?u8 = [Link](u8, @as(u32, 255));

if (num) |n| {
try [Link](n == 255);
} else {
try [Link](1 == 0); // fail
}
}

Optionale Variablen können als Bedingung, innerhalb einse If-Statements, verwendet werden.
Sollte num einen Wert besitzen, so wird dieser an n gebunden und der If-Block wird betreten.
Andernfalls wird der Else-Block ausgeführt.
Variablen die nicht als „optional“ deklariert wurden enthalten garantiert immer einen Wert! Dies
vereinfacht es, Fälle bei denen ein Wert fehlen kann, wie etwa der Zeiger bei einer verketteten

53
Liste, zu handhaben. Optionals erzwingen es, explizit auf den Wert einer optionalen Variable
zuzugreifen. Entweder durch Verwendung des ? -Operators oder eines If-Statements. Damit
wird verhindert, dass ein optionaler Wert aus Versehen als nicht optionaler Wert gehandhabt
wird.
Je nach Situation kann wie folgt mit fehlenden Werten umgegangen werden:
• Überspringe den Code der auf den eigentlichen Wert angewandt werden würde.
• Bereitstellen eines Fallback-Werts.
• Propagiere den null Wert an die darüber liegende Funktion oder beende den Prozess
vorzeitig.

chatper02/[Link]
test "Handling" {
var num: ?u8 = [Link](u8, 250);

// Überspringe Block falls `num == null`

if (num) |*n| {
n.* += 1;
}
try [Link](num.? == 251);

// Stelle einen Fallback-Wert bereit

const num2: u8 = if ([Link](u8, 256)) |n| n else 255;
try [Link](num2 == 255);
}

Neben If-Statements können Optionals auch in While-Schleifen verwendet werden. Sollte das
verwendete Optional null sein so wird aus der Schleife ausgebrochen, andernfalls wird eine
Iteration der schleife Durchlaufen.

chatper02/[Link]
test "while" {
const S = struct {
pub fn next() ?u2 {
const T = struct {
var v: ?u2 = 0;
};

defer {
if (T.v) |*v| {
if (v.* == 3) T.v = null else v.* += 1;
}
}

54
Zig Basics

return T.v;
}
};

const stdout = [Link]();

while ([Link]()) |value| {

try [Link]().print("{d}\n", .{value});
}
}

In diesem Beispiel wird eine Funktion next() definiert, die eine statische, lokale Variable v
besitzt. Diese wird mit 0 initialisiert. Bei jedem Aufruf von next() wird der aktuelle Wert von
v zurückgegeben. Der defer Block wird vor der Rückkehr aus der Funktion ausgeführt und
inkrementiert v , jedoch nur falls v nicht gleich drei ist. Sollte v gleich drei sein, so wird v
der null -Wert zugewiesen.
Verwendet man den Rückgabewert von next() als Bedingung einer While-Schleife so wird der
Rückgabewert an value gebunden, solange dieser nicht gleich null ist, das heißt value hat
den Typ u2 .
Führt man den Test aus, so sieht man, dass die Zahlen 0 bis 3 auf der Kommandozeile ausgegeben
werden, bevor aus der Schleife ausgebrochen wird.

$ zig test [Link]

0
1
2
3
All 4 tests passed.

Zeiger (Pointer)
Zig unterscheidet zwischen zwei Arten von Zeigern, single-item und many-item Pointer.
Ein single-item Pointer *T zeigt auf exakt einen Wert im Speicher und kann mit der Syntax
ptr.* dereferenziert werden. Mit Hilfe des Address-of-Operators & kann ein single-item
Pointer bezogen werden.

// Definiere eine Variable vom Typ u8

var v: u8 = 128;
// Beziehe einen Zeiger auf `v`
const v_ptr: *u8 = &v;

55
 // Dereferenziere den Zeiger `v_ptr` und addiere 1 zu `v`
v.* += 1;

Ein multi-item Pointer [*]T zeigt auf eine lineare Sequenz an Werten im Speicher mit unbe-
kannter Länge. Der Zeiger eines Slice ( .ptr ) ist ein multi-item Pointer. Allgemein teilen Slices
und multi-item Pointer die selbe Index- und Slice-Syntax.
• ptr[i]
• ptr[start..end]
• ptr[start..]

Genau wie C erlaubt auch Zig Zeigerarithmetik auf multi-item Pointer.

chapter02/[Link]
var array = [_]i32{ 1, 2, 3, 4 };

var array_ptr = array[0..].ptr;

[Link]("{d}", .{array_ptr[0]});
array_ptr += 1;
[Link]("{d}", .{array_ptr[0]});

Nach dem Compilieren mit zig build-exe chapter02/[Link] können wir die Beispiel
Anwendung ausführen und sehen, dass die ersten beiden Zahlen von array ausgegeben werden,
obwohl wir den selben Index für array_ptr verwenden. Grund dafür ist, dass wir den Zeiger
selbst, zwischen dem ersten und zweiten Aufruf von [Link]() , inkrementiert haben.

$ ./pointer
info: 1
info: 2

Ein weit verbreitetes Konzept in C sind NULL -terminierte Strings, d.h. ein 0 -Byte wird hinter
den letzten Character eines Strings geschrieben und markiert so dessen Ende. Zig bietet etwas
sehr ähnliches, nämlich sentinel-terminated Pointer, auf die im nächsten Abschnitt noch näher
eingegangen wird.

Arrays und Slices

Zig besitzt eine Vielzahl an Datentypen um eine (lineare) Sequenz an Werten im Speicher
darzustellen, darunter:

56
Zig Basics

• Der Typ [N]T repräsentiert ein Array vom Typ T bestehend aus N Werten. Die Größe eines
Arrays ist zur Compilezeit bekannt und Arrays werden grundsätzlich auf dem Stack alloziert.
Damit kann ein Array weder erweitert noch verkleinert werden.
• Der Typ []T bzw. []const T repräsentiert ein Slice vom Typ T , bestehend aus einem Zeiger
und einer Länge. Die Länge eines Slices ist zur Laufzeit bekannt. Slices referenzieren eine
Sequenz von Werten. Dies kann z.B. ein Array sein oder auch eine auf dem Heap gespeicherte
Sequenz. Die von einem konstanten Slice []const T referenzierten Werte können gelesen,
jedoch nicht verändert werden, während die Werte eines Slices []T sowohl gelesen als auch
verändert werden können.
Sowohl Arrays als auch Slices erlauben den Zugriff auf deren Länge durch den Ausdruck .len .

chapter02/[Link]
var a = [_]u8{ 1, 2, 3, 4 };
[Link]("length of a is {d}", .{[Link]});
const s = &a;
[Link]("length of a is still {d}", .{[Link]});

Mit dem Address-Of Operator & kann ein Slice für ein Array erzeugt werden. Alternativ
kann auch der Ausdruck a[0..] verwendet werden, der einen Bereich innerhalb des Arrays
beschreibt. Grundsätzlich liegt das erste Element einer Sequenz immer an Index 0 und es kann
mit a[0] auf dieses zugegriffen werden. Das letzte Element liegt immer an der Stelle [Link] - 1
und es kann mit a[[Link] - 1] darauf zugegriffen werden. Der Index muss dabei immer ein
Integer vom Typ usize oder ein Literal sein, das zu diesem Typ konvertiert werden kann. Die
Verwendung anderer Typen als Index führt zu einem Fehler zur Compilezeit.
Auf den Zeiger eines Slices kann mit .ptr zugegriffen werden, z.B. [Link] .
Zig überprüft bei dem Zugriff auf eine Array oder Slice zur Laufzeit, dass der Index innerhalb
des Speicherbereichs der Sequenz liegt. Ließt eine Anwendung über die Grenzen der Sequenz,
so führt dies zu einem Fehler zur Laufzeit der den Prozess beendet. Dies verhindert typische
Speicherfehler wie Buffer-Overflows and Buffer-Overreads die in Sprachen wie C weit verbreitet
sind und in der Vergangenheit zu Hauf von Angreifern ausgenutzt wurden um Anwendungen
zu exploiten.

chapter02/[Link]
var i: usize = 0;
while (true) : (i += 1) {
a[i] += 1;
}

57
 $ zig build-exe [Link] -Doptimize=ReleaseFast
$ ./slices
info: length of a is 4
info: length of a is still 4
thread 1232 panic: index out of bounds: index 4, len 4
[Link]:10: 0x103544c in main (slices)
a[i] += 1;
^
[Link]:22: 0x1034c99 in posixCallMainAndExit (slices)
[Link]();
^
[Link]:5: 0x1034801 in _start (slices)
asm volatile (switch (native_arch) {
^
???:?:?: 0x0 in ??? (???)
Aborted (core dumped)

Arrays
Es gibt eine Vielzahl von Möglichkeiten um Arrays in Zig zu definieren. Die einfachste Möglich-
keit ist, eine Sequenz von Werten in geschweiften Klammern anzugeben.

const prime: [5]u8 = .{2, 3, 5, 7, 11};

const names = [3][]const u8{"David", "Franziska", "Sarah"};

Für den Fall, dass initial keine Werte bekannt sind kann ein Array mit undefined initialisiert
werden. In diesem Fall ist der Inhalt des Speichers undefiniert.

const some: [1000]u8 = undefined;

Arrays können aber auch mit einem bestimmten Wert initialisiert werden. Im unteren Beispiel
wird das gesamte Array mit 0 Werten initialisiert.

const some: [1000]u8 = .{0} ** 1000;

Die Länge eines Arrays muss immer zur Compilezeit bekannt sein. Dementsprechend können
keine Variablen zur Angabe der Länge verwendet werden, außer die Variable ist vom Typ
comptime_int . Sollte ein Array benötigt werden, dessen Länge nur zur Laufzeit bekannt ist, so
muss der Speicher entweder manuell alloziert oder auf einen Kontainertypen wie ArrayList
aus der Standardbibliothek zurückgegriffen werden33.

33 Mehr dazu in folgenden Kapiteln.

58
Zig Basics

Viel Funktionen die über Sequenzen arbeiten erwarten ein Slice und kein Array. Zig konvertiert
dabei nicht automatisch Arrays zu Slices, d.h. bei einem Aufruf muss explizit der Address-Of
Operator & auf das Array angewandt werden oder alternativ ein Slice mit dem [] Operator
festgelegt werden.

chapter02/[Link]
const std = @import("std");

pub fn main() void {

const a: [5]u8 = .{ 1, 2, 3, 4, 5 };

foo(&a);
foo(a[1..]);
}

fn foo(s: []const u8) void {

for (s) |e| {
[Link]("{d}", .{e});
}
}

$ ./coersion
info: 1
info: 2
info: 3
info: 4
info: 5
info: 2
info: 3
info: 4
info: 5

Slices
Slices []T werden ohne Angabe einer Länge geschrieben und repräsentieren eine lineare Se-
quenz an Werten. Konzeptionell ist ein Slice eine Zeiger vom Typ [Link] .
Schaut man sich die Definition von Slice in zig/src/mutable_value.zig34 an, so sieht man, dass
ein Slice durch einen Zeiger ( ptr ), der auf den Beginn des referenzierten Speicherbereichs zeigt,
sowie eine Länge ( len ) beschrieben wird.

[Link]/ziglang/zig/src/mutable_value.zig

34 [Link]

59
 pub const Slice = struct {
ty: [Link], // wir ignorieren dieses Feld :)
/// Must have the appropriate many-ptr type.
ptr: *MutableValue,
/// Must be of type `usize`.
len: *MutableValue,
};

Je nach Typ einer Variable bzw. eines Parameters konvertiert Zig die Referenz zu einem Struct
automatisch in ein Slice.

const b: [3][]const u8 = .{ "David", "Franziska", "Sarah" };

// Zig konvertiert die Referenz automatisch zu einem Slice.

const sb: []const []const u8 = &b;
_ = sb;

// `rb` ist ein Pointer zu einem Array.

const rb: *const [3][]const u8 = &b;
_ = rb;

Da b eine Konstante ist, muss auch das Slice sb ( []const T ), sowie der Pointer rb auf das
Array ( *const [N]T ) konstant sein. Wäre b eine Variable, so wäre auch das const , in Bezug
auf das Slice bzw. den Pointer, optional, je nachdem ob das Array durch die jeweilige Referenz
verändert werden soll oder nicht.

/----------------------\
b | |
-------v------------------------|----------------------
stack | | | | | | |3| |
-----|-|-|---------------------------------------------
| \ \---------------- sb
\ | |
| -------| |
-------v--------v----------v---------------------------
data | |"David"|"Franziska"|"Sarah"| |
-------------------------------------------------------

Mithilfe des [] Operators können Slices für einen bestehenden Speicherbereich angegeben
werden. Innerhalb der eckigen Klammern muss dafür ein Bereich spezifiziert werden, der durch
das Slice eingegrenzt werden soll:
• [0..] : Der gesamte Bereich, vom ersten bis zum letzten Element.
• [N..M] : Ein Bereich beginnend ab Index N (eingeschlossen) und endend bei Index M
(ausgeschlossen).

60
Zig Basics

const name = "David";

// Die ersten drei Buchstaben
try [Link]("Dav", name[0..3]);
// Die letzten zwei Buchstaben
try [Link]("id", name[3..]);
// Die mittleren drei Buchstaben
try [Link]("avi", name[1..4]);

Um Buffer-Overreads vorzubeugen überprüft Zig, dass die angegeben Indices valide sind. Sind
die Indices zur Compilezeit bekannt, so führt ein invalider Index zu einem Compile-Fehler,
andernfalls zu einer Panic zur Laufzeit.

chapter02/slice_error.zig
const a = "this won't work";
// ...
const n: usize = 20;
[Link]("{s}", .{a[1..n]});

Versucht man den obigen Code mit zig build-exe chapter02/slice_error.zig zu Compi-
lieren so erhält man den folgenden Fehler:

error: end index 20 out of bounds for array of length 15 +1 (sentinel)

[Link]("{s}", .{a[1..n]});

Sentinel-Terminierte Slices
Slices definieren einen Speicherbereich, durch einen Zeiger und eine Länge. Dadurch wird der
Speicherbereich explizit eingegrenzt, was in vielen Fällen die aus C bekannten NULL-Termina-
toren überflüssig macht. Jedoch unterstützt Zig auch NULL-terminierte Strings.
Allgemein werden Slices, deren Ende durch einen bestimmten Wert begrenzt wird (zum Beispiel
ein NULL-Byte), als sentinel-terminated Slices bezeichnet. Der Sentinel (Wächter) ist eine vorde-
finierter Wert der das Slice abschließt.
Sentinel-terminierte Slices werden mit der [:x]T Syntax definiert und besitzen wie auch alle
anderen Slices eine Länge, auf die über das .len Feld zugegriffen werden kann. Die Länge ist
dabei die Länge des Slices ohne den Sentinel-Wert!

const std = @import("std");

test "slice test" {

const name: [:0]const u8 = "Pierre";

61
 try [Link]([Link] == 5);
try [Link](name[6] == 0);
}

Sentinel-terminierte Slices können auch mit der data[start..end :x] Syntax erzeugt werden,
wobei data eine Zeiger auf mehrere Werte, ein Array oder ein Slice seien muss. Der Wert x
ist der Sentinel.

const arr = [_]u8{'h', 'e', 'l', 'l', 'o', 0, 'h', 'e', 'l', 'l', 'o', 0};
const s = arr[0..5 :0];

Wichtig dabei ist, dass das mit data[start..end :x] erzeugte Slice auch tatsächlich vom ange-
gebenen Sentinel terminiert wird! Sollte dies nicht der Fall sein, führt dies je zu undefiniertem
Verhalten. Je nach gewählter Optimierung führt dies im besten Fall zur einer Panic zur Laufzeit,
die den Prozess vorzeitig beendet.

Im Allgemeinen werden in Zig Slices, gegenüber sentinel-terminated Pointern,

präferiert. Der Grund hierfür ist, dass Slices über Bounds-Checking verfügen
und so gängige Speicherfehler abgefangen werden können. Es gibt jedoch auch
Situationen, in denen many-item Pointer bzw. sentinel-terminated Pointer ex-
plizit benötigt werden, z.B. beim Arbeiten mit C Code. Auf die Interoperabilität
zwischen Zig und C wird in einem späteren Kapitel noch näher eingegangen.

Padding
Ein Thema, welches immer wieder zu Verwirrung führt und teilweise online falsch dargestellt
wird, ist der Speicherverbrauch von bestimmten Arten von Arrays beziehungsweise Slices. Ein
klassisches Beispiel ist hierbei der Typ [8]u1 .
Oft findet man Behauptungen, dass [8]u1 genau ein Byte Speicher benötigt, da das Array
aus exakt acht Bit besteht. Das ist jedoch nicht richtig. Das minimale Padding für einen
Typen im Speicher beträgt ein Byte, d.h. obwohl u1 nur ein Bit Speicher Benötigt wird
trotzdem ein Byte pro u1 reserviert. Hierfür gibt es verschiedene Erklärungsansätze. Einer
davon ist die Adressierbarkeit einzelner Elemente eines Arrays. Angenommen ein Array
const arr: [8]u1 = .{0} ** 8; . Von solch einem Array erwarten wir, einzelne Elemente
adressieren zu können, zum Beispiel &arr[3] (Adresse des vierten Elements des Arrays
arr ). Die Zeigerarithmetik hierfür wäre ELEM3 = ARR_BASE + 3 , wobei ARR_BASE die Basis-
adresse von arr im Speicher ist. Das erste Element beginnt dementsprechend an der Adresse
ARR_BASE + 0 , das zweite Element an der Adresse ARR_BASE + 1 und so weiter (Ausgehend
davon, dass jedes Element ein Byte benötigt).
Gehen wir nun davon aus, jedes u1 eines [8]u1 würde tatsächlich nur ein Bit im Speicher
belegen. Die Adressierung des ersten Elements wäre noch möglich ( ARR_BASE + 0 ) aber wie

62
Zig Basics

würden die restlichen Elemente referenziert? Die Antwort hierauf lautet: gar nicht! Die meisten
CPUs erlauben die Adressierung einzelner Bytes, was auch als Byte-Addressing35 bezeichnet
wird. Es gibt weiterhin einzelne, vor allem ältere Arichtekturen die nur Wörter adressieren
können (Word-Addressing36). Nicht existent ist jedoch Bit-Adressierung in der Computerachi-
tektur.
Das Padding (von Arrays und Slices) ist dabei nicht nur nice to know, sondern hat reelle Konse-
quenzen beim Programmieren. Gehen wir nämlich im obigen Beispiel davon aus, dass ein [8]u1
genau ein Byte im Speicher belegt, so könnten wir in die Versuchung geraten das folgende zu
versuchen: @as(*u8, @ptrCast([Link])) . In diesem Fall wäre die Erwartungshaltung, dass
u8 äquivalent zu einem [8]u1 ist. Das ist jedoch falsch und würde zwangsläufig zu Bugs
führen!
Mit @sizeOf lässt sich die Menge an Bytes bestimmen die benötigt werden um einen
Bestimmten Typ im Speicher abzulegen. Für die Anzahl an Bits kann @bitSizeOf verwendet
werden, zum Beispiel @bitSizeOf([8]u8) . In meinem Fall gibt @bitSizeOf([8]u8) den Wert
64 zurück, was das benötigt Padding mit einschließt.

Errors
Während der Ausführung von Zig-Code kann ein Programm auf Fehler zur Laufzeit stoßen.
Dabei kann es sich zum Beispiel um eine fehlende Datei handeln, die nicht geöffnet werde kann.
Im Gegensatz zu Optionals, welche die Abwesenheit eines Wertes kommunizieren können, geben
Fehler mehr Aufschluss über den Grund, warum der Aufruf einer Funktion fehlgeschlagen ist.
Außerdem unterstützt Zig das Propagieren von Fehlern.
Zig betrachtet Errors als Werte, die in einem Error-Set zusammengefasst werden. Ein Error-Set ist
vergleichbar zu einem Enum, wobei jedem Error-Bezeichner ein eindeutiger ganzzahliger Wert
größer 0 zugewiesen wird37. Wird ein Error-Bezeichner (zum Beispiel [Link] )
mehrfach definiert, so wird diesem immer der selbe numerische Wert zugewiesen.
Error-Sets können mit dem error Schlüsselwort definiert werden. Ein Error-Typ wird dekla-
riert, indem dem Basistypen der Name des zugehörigen Error-Sets, gefolgt von einem ! ,
vorangestellt wird. Angenommen eine Funktion gibt potenziell einen Fehler aus dem Error-Set
MyErrors oder void (kein Rückgabewert) zurück, dann kann der Rückgabewert der Funktion
wie folgt geschrieben werden: MyErrors!void . Um einen Error zurück zu geben kann der
entsprechende Error-Wert, genau wie andere Rückgabewerte, mit return an die aufrufende
Funktion gereicht werden.

chapter02/[Link]

35 [Link]
36 [Link]
37 Standardmäßig ist der einem Error zugrunde liegende Integer-Typ ein u16 .

63
 const std = @import("std");

const MyErrors = error{

IsNotEight,
};

/// Check if the given number is eight.

/// Returns an error if `n` is not equal 8!
fn checkNumber(n: u8) MyErrors!void {
if (n != 8) return [Link];
}

test "Error test #1" {

try [Link]([Link], checkNumber(7));
}

Da den gleichen Error-Bezeichnern der gleiche numerische Wert zugewiesen wird,

kann im obigen Beispiel anstelle von [Link] auch [Link]
zurückgegeben werden. Zig erlaubt mit der Syntax error.<NameDesErrors> die Defi-
nition von Errors innerhalb eines impliziten Error-Sets. Dies ist die Kurzform für
(error{<NameDesErrors>}).<NameDesErrors> .

fn checkNumber(n: u8) MyErrors!void {

if (n != 8) return [Link];
}

Error-Set Coercion
Angenommen es existieren zwei Error-Sets, wobei das eine Error-Set eine Teilmenge des
Anderen darstellt. In einem solchen Fall erlaubt Zig die Coercion, das heißt das Umwandeln, von
der Tielmenge in die Obermenge.

chapter02/[Link]
const FileOpenError = error{
AccessDenied,
OutOfMemory,
FileNotFound,
};

const AllocationError = error{

OutOfMemory,
};

fn coerce(err: AllocationError) FileOpenError {

64
Zig Basics

return err;
}

test "Error-Set Coercion" {

try [Link]([Link] ==
coerce([Link]));
}

Was jedoch nicht funktioniert ist die Umwandlung einer Obermenge in eine Teilmenge!

Globales Error-Set
Zig erlaubt es das explizite Error-Set links vom ! wegzulassen, zum Beispiel !void . In diesem
Fall ist das Error-Set implizit anyerror , das globalen Error-Set, dem alle Errors der gesamten
Compilation-Unit angehören. Jedes Error-Set kann in anyerror umgewandelt werden. Außer-
dem kann eine Element aus dem globalen Error-Set explizit in ein nicht globales Error-Set
ge-castet werden.

fn checkNumber(n: u8) !void {

if (n != 8) return [Link];
}

Im obigen Beispiel wird der Rückgabewert automatisch in einen Wert vom Typ anyerror!void
umgewandelt.

In vielen Fällen ist es praktisch das Error-Set einer Funktion von Zig ableiten
zu lassen. Je nach Anwendungsfall kann dies jedoch auch Nachteile mit sich
bringen. Vor allem bei der Entwicklung von Modulen, die mit anderen Program-
mieren geteilt werden, sollten Sie sich angewöhnen explizite Error-Sets zu
verwenden.

catch
Mit catch können Errors, die von einer Funktion zurückgegeben werden, abgefangen und
entsprechend behandelt werden.

chapter02/[Link]
pub fn main() void {
const n = 7;
checkNumber(n) catch |e| {
[Link]("The number {d} is not equal 8: {any}", .{ n, e });
};
}

65
Das catch folgt direkt hinter dem Aufruf der Funktion. Optional kann der Fehler-Wert an eine
Variable (im obigen Fall e ) gebunden werden. Der catch -Block (eingegrenzt durch geschweifte
Klammern {} ) wird nur ausgeführt, falls die Funktion einen Error als Rückgabewert liefert.
catch eignet sich ebenfalls um im Fehlerfall einen Default-Wert bereitzustellen.

chapter02/[Link]
test "Default-Wert" {
const n = [Link](u64, "0xdeaX", 16) catch 16;
try [Link](n == 16);
}

In diesem Beispiel ist n entweder gleich dem entpackten Rückgabewert von parseInt() oder,
falls parseInt() einen Error zurück gibt, 16. Wie zu sehen ist muss nicht zwangsläufig ein Block
auf catch folgen, genauso zulässig ist ein Ausdruck. Der entpackte Rückgabewert der Funktion
und der Ausdruck rechts vom catch müssen den selben Typ besitzen (in diesem Beispiel u64 ).
Alternativ kann auch ein Block mit einem frei wählbaren Bezeichner (zum Beispiel blk )
verwendet werden. Der Bezeichner muss dabei die selben Anforderungen wie ein Variablen-
Name erfüllen.

const n = [Link](u64, "0xdeaX", 16) catch blk: {

break :blk 16;
}
try [Link](n == 16);

Mittels break kann der Default-Wert 16 in den umschließenden Block gereicht werden, wo er
an die Konstante n gebunden wird. Das Literal wird dabei automatisch vom Typ comptime_int
in einen u64 umgewandelt.

try
In vielen Fällen reicht es aus, beim Auftreten eines Errors, selbst einen Error an die aufrufende
Funktion zurückzugeben. Dies wird als Fehler-Propagierung bezeichnet und kann in Zig durch
die Verwendung von try umgesetzt werden. Hierzu wird vor den Aufruf einer Funktion, die
einen Fehler-Typen als Rückgabetyp besitzt, das Schlüsselwort try gesetzt.

fn foo(str: []const u8) !void {

const n = try [Link](u64, str, 16);
_ = n;
}

66
Zig Basics

Das Schlüsselwort try evaluiert den zugehörigen Ausdruck und kehrt im Fehlerfall mit dem
selben Error aus der Funktion zurück. Andernfalls wird der Rückgabewert der aufgerufenen
Funktion entpackt.
Dies ist die Kurzform für den folgenden Code:

fn foo(str: []const u8) !void {

const n = [Link](u64, str, 16) catch |e| return e;
_ = n;
}

errdefer
Es gibt Situationen, bei denen Code nur im Fehlerfall ausgeführt werden soll, zum Beispiel
um Speicher zu de-allozieren, der nicht mehr benötigt wird. Für solche Fälle kann errdefer
verwendet werden, das die gleichen Eigenschaften wie defer aufweist, mit dem großen Unter-
schied das errdefer nur ausgeführt wird, sollte die Funktion einen Fehler zurückgeben.

fn alwaysFail(a: [Link]) ![]const u8 {

const mem = try [Link](u8, 13);
errdefer [Link](mem);

@memcpy(mem, "Hello, World!");

if ([Link](u8, "Hello", mem[0..5])) {

// Weil der Fehler `HelloError` zurückgegeben wird,
// wird auch der von `mem` referenzierte Speicher
// freigegeben.
return [Link];
}

return mem;
}

Das praktische ist, dass durch errdefer die Allokation und Deallokation sehr nahe beieinander
liegen können. Dies macht es einfacher sicherzustellen, dass im Fehlerfall kein Speicherleck
(engl. Memory-Leak) entsteht.

Sowohl defer als auch errdefer beziehen sich auf den umschließenden
Block. Dadurch wird errdefer nicht ausgeführt, sollte der Error außerhalb des
Blocks zurückgegeben werden!

Error-Sets zusammenführen
Errors-Sets können mit dem || -Operator zusammengeführt werden.

67
const A = error{
Foo,
};

const B = error{
Bar,
};

const AB = A || B;

68
Zig Basics

Kapitel 3

Speicherverwaltung

Im Vergleich zu anderen Sprachen, wie etwa Java oder Python, muss der Speicher in Zig manuell
verwaltet werden. Dies bringt einige Vorteile mit sich, birgt aber auch Risiken, die bei Nichtbe-
achtung zu Schwachstellen in den eigenen Anwendungen führen können. Was Zig von anderen
Sprachen mit manueller Speicherverwaltung hervorhebt ist die explizite Verwendung und Ver-
waltung von Allokatoren, in der Programmiersprache repräsentiert durch den Allocator Typ.
Dies kann von anderen Programmiersprachen kommenden Entwicklern anfangs ungewohnt
vorkommen, bietet jedoch ein hohes Maß an Flexibilität, da Speicher zur Laufzeit dynamisch von
verschiedenen Speicherquellen alloziert werden kann.

Grundlagen
In den meisten Fällen kann ein Programm von zwei verschiedenen Quellen Speicher allozieren,
dem Stack und dem Heap. Wird eine Funktion aufgerufen, so alloziert diese Speicher auf
dem Stack der von den lokalen Variablen und Parametern zur Speicherung der zugehörigen
Werte verwendet wird. Dieser, von einer Funktion allozierte, Speicherbereich wird als Stack-
Frame bezeichnet. Die Allokation eines Stack-Frames wird durchgeführt, indem der Wert eines
spezielles CPU-Register, der sog. Stack-Pointer welcher auf das Ende des Stacks zeigt, verringert
wird. Die Anzahl an Bytes um die der Stack-Pointer verringert werden muss um alle lokalen
Variablen halten zu können wird vom Compiler zur Compilezeit berechnet und in entsprechende
Assemblerinstruktionen übersetzt.
Durch die Einschränkung, dass die Größe eines Stack-Frames zur Compilezeit bekannt sein
muss, lassen sich bestimmte Aufgaben schwer lösen. Angenommen Sie wollen eine Zeichenkette
unbekannter Länge von Ihrem Programm einlesen lassen, um diese später zu verarbeiteten. Eine
Möglichkeit um die Zeichenkette zu speichern wäre innerhalb der main Funktion eine Variable
vom Typ Array mit fester Länge zu deklarieren, jedoch ist dieser Ansatz sehr unflexibel da
Sie in dem gegebenen Szenario die Länge der zu erwartenden Zeichenkette nicht kennen. Bei
besonders kurzen Zeichenketten verschwenden Sie ggf. Speicher während sich besonders lange
Zeichenketten nicht einlesen lassen, da nicht genügend Speicher auf dem Stack alloziert wurde.
Um Probleme solcher Art besser lösen zu können, kann Speicher dynamisch zur Laufzeit eines
Programms alloziert werden. Der Heap kann als linearer Speicherbereich betrachtet werden, der

69
von einem Allokator verwaltet wird. Wird Speicher zur Laufzeit benötigt, so kann der Allokator
durch einen Funktionsaufruf angewiesen werden eine bestimmte Menge an Bytes zu allozieren.
Der Allokator sucht ein Stück Speicher mit der passenden Länge heraus, markiert dieses als
alloziert und gibt einen Zeiger auf den Beginn des Speicherbereichs zurück. Wird der Speicher
nicht mehr benötigt, so kann der Allokator durch einen weiteren Funktionsaufruf aufgefordert
werden den Speicher wieder frei zu geben. In C und C++ verwenden Sie i.d.R. malloc und free
um Speicher zu allozieren bzw. freizugeben, in den wenigsten Fällen müssen Sie sich jedoch
Gedanken um den zu verwendenden Allokator machen. Im Gegensatz dazu verwenden Sie in
Zig immer explizit einen Allokator.
In vielen Fällen, vor allem als Neuling, ist die Unterscheidung zwischen den vielen verschiedenen
Arten von Allokatoren, welche die Zig Standartbibliothek bereitstellt, weniger interessant. Wird
ein Standard-Allokator, im Sinne von malloc und free , benötigt, so kann auf den GeneralPur-
poseAllocator zurückgegriffen werden.

const Gpa = [Link](.{});

var gpa = Gpa{};
const allocator = [Link]();

Die Funktion GeneralPurposeAllocator erwartet ein Konfigurationsstruct als Argument zur

Compilezeit und gibt einen neuen GeneralPurposeAllocator -Typ zurück der der Konstante
Gpa zugewiesen wird. In den meisten Fällen kann durch Verwendung von .{} als Argument die
Standardkonfiguration übernommen werden. Danach kann der Gpa Allokator-Typ verwendet
werden um ein neues Allokator-Object zu erzeugen und an die Variable gpa zu binden. Durch
Aufruf der allocator() Funktion auf dem Objekt kann schlussendlich auf den eigentlichen
Allokator zugegriffen werden. Dies mag auf den ersten Blick kompliziert wirken, vor allem im
Vergleich zu anderen Sprachen wo Funktionen wie malloc() scheinbar immer zur Verfügung
stehen, in den meisten Fällen reicht es aber aus, den Allokator einmal am Anfang der Anwen-
dung zu instanziieren. Danach kann dieser zur Allokation von Speicher verwendet werden. Der
Allocator-Typ erlaubt es verschiedene Allokatoren durch das selbe, standardisierte Interface zu
verwenden. Das bedeutet, dass Entwickler von Bibliotheken bzw. Modulen das gesamte dyna-
mische Speichermanagement durch einen Typen (Allocator) handhaben können, während die
Verwender von besagten Bibliotheken die freie Wahl bezüglich des dahinter liegenden Allokators
besitzen.
Beim Allozieren von Speicher wird in Zig grundsätzlich zwischen der Allokation von exakt
einem Objekt und der Allokation mehrerer Objekte unterschieden. Soll speicher für genau ein
Objekt alloziert werden, so muss create() zum allozieren und destroy() zum Freigeben
des Speichers verwendet werden. Andernfalls können die Funktionen alloc() und free()
verwendet werden. Die Funktion create() erwartet einen Typen ( type ) als Argument und
alloziert daraufhin Speicher für exakt eine Instanz dieses Typen. Eine Allokation kann jedoch
fehlschlagen, z.B. weil kein ausreichender Speicher auf dem Heap vorhanden ist. Aus diesem
Grund gibt create() nicht direkt einen Zeiger auf den allozierten Speicher zurück, sondern
einen Fehler-Typ. Damit werden Entwickler gezwungen sich bewusst zu machen, dass eine
70
Zig Basics

Allokation fehlschlagen kann. Dies spiegelt sich auch im Zig-Zen wieder, in welchem es u.a.
heißt: ,,Resource allocation may fail; resource deallocation must succeed’‚ (auf Deutsch: Die
Allokation von Resourcen kann fehlschlagen; die deallokation von Resourcen muss gelingen).

// chapter03/hello_world.zig
const std = @import("std");

const Gpa = [Link](.{});

var gpa = Gpa{};
const allocator = [Link]();

pub fn main() !void {

const T = u8;
const L = "Hello, World".len;

// Hier allozieren wir Speicher für L Elemente vom Typ `u8` .

const hello_world = [Link](T, L) catch {
// Im Fall, dass der Speicher nicht alloziert werden kann,
// geben wir eine Fehlermeldung aus und beenden den
// Prozess ordnungsgemäß.
[Link]("We ran out of memory!", .{});
return;
};
// Defer wird vor dem Verlassen der Funktion ausgeführt.
// Es ist 'good practice' Speicher mittels `defer` zu
// deallozieren.
defer [Link](hello_world);

// Wir kopieren "Hello, World" in den allozierten Speicher.

@memcpy(hello_world, "Hello, World");

// Nun geben wir den String auf der Kommandozeile aus.

const stdout_file = [Link]().writer();
var bw = [Link](stdout_file);
const stdout = [Link]();

try [Link]("{s}\n", .{hello_world});

try [Link]();
}

Das obige Programm gibt ,,Hello, World’‚ auf der Kommandozeile aus, jedoch allozieren wir vor
der Ausgabe, zur Veranschaulichung, Speicher für den auszugebenden String auf dem Heap. Die
Funktion alloc() erwartet als Argument den Typ, für den Speicher alloziert werden soll ( u8 ),
sowie die Anzahl an Elementen. Aus dem Typ T und der Anzahl L berechnet sich die Anzahl an
Bytes die benötigt werden um L mal den Typ T im Speicher zu halten ( @sizeOf(T) * L ). Wie
bereits erwähnt kann die Speicherallokation fehlschlagen, aus diesem Grund müssen wir denn

71
Fehlerfall berücksichtigen bevor wir auf den Rückgabewert von alloc() zugreifen können38.
Da alloc() Speicher für mehr als ein Objekt alloziert, gibt die Funktion anstelle eines Zeigers
auf den Typ T einen Slice vom Typ T zurück. Ein Slice ist ein Wrapper um einen Zeiger, der
zusätzlich die Länge des referenzierten Speicherbereichs kodiert. Nach außer verhält sich ein
Slice wie ein Zeiger in C, d.h. mit dem Square-Bracket-Operator [] kann auf einzelne Element
zugegriffen werden, jedoch wird vor jedem Zugriff überprüft, ob der angegebene Index innerhalb
des allozierten Bereichs liegt um Out-of-Bounds-Reads zu vorzubeugen. Slices ersetzen in vielen
Fällen null-terminierte Strings, was dabei hilft Speicherfehlern vorzubeugen.
Ein wichtiger Punkt der zu jeder Allokation gehört ist die Deallokation des allozierten Speichers.
In Zig kann diese direkt nach dem Aufruf von alloc() bzw. create() platziert werden, indem
dem Aufruf von free() der defer Operator vorangestellt wird. Defer sorgt dafür, dass vor dem
Verlassen eines Blocks, im obigen Beispiel ist dies der Funktionsblock von main, alle defer Blöcke
ausgeführt werden und zwar in umgekehrter Reihenfolge in der sie deklariert werden. Dies ist
vor allem zum Aufräumen von Ressourcen sehr hilfreich.

Sehen Sie beim Lesen von Zig-Code keinen defer Block zur Bereinigung von
Speicher direkt nach einer Allokation sollten Sie erst einemal stutzig werden.
Es gibt aber auch Situationen, z.B. bei der Verwendung eines ArenaAllocators,
in denen nicht jede einzelne Allokation manuell bereinigt werden muss. In
solchen Fällen ist es aber durchaus nützlich für Leser Ihres Quellcodes, wenn Sie
durch ein Kommentar ersichtlich machen, dass das Fehlen einer Deallokation
beabsichtigt ist.

Lifetimes
Bei der Verwendung von Programmiersprachen mit manuellem Speichermanagement ist die
Berücksichtigung der Lifetime (Lebenszeit) von Objekten essenziell um Speicherfehler zu
vermeiden. Die Lifetime eines Objekts beschreibt ein abstraktes Zeitintervall zur Laufzeit, in
welchem ein bestimmtes Objekt oder eine Sequenz von Objekten im Speicher existieren und auf
diese zugegriffen werden darf. Die Art wie bzw. wo Speicher für ein Objekt alloziert wird hat
dabei großen Einfluss auf dessen Lebenszeit. Im Allgemeinen beginnt die Lifetime eines Objekts
mit dessen Erzeugung und endet wenn der Speicher des Objekt wieder freigegeben wird. Bezogen
auf die Art der Allokation kann grob zwischen den folgenden Fällen unterschieden werden:
• Statische Allokation
• Automatische Allokation
• Dynamische Allokation

Static Memory

38 Anstelle eines catch Blocks hätten wir an dieser Stelle auch try verwenden können.

72
Zig Basics

In Zig, wie auch in C, befinden sich statische Variablen und Konstanten, die im globalen Scope,
bzw. im Fall von Zig in einem Container39, einer Anwendung deklariert werden, in der .data
oder .bss Section eines Programms. Speicher für diese Sektionen wird beim Start eines Prozesses
gemapped und er bleibt bis zur Terminierung des Prozesses valide. Variablen die dies betrifft
haben eine statische Lifetime, d.h. sie sind vom Start eines Prozesses bis zu dessen Beendigung
valide. Selbes gilt für statische, lokale Variablen.

const std = @import("std");

const hello = "Hello, World";

pub fn main() void {

const local_context = struct {
var x: u8 = 128;
};

[Link]("{s}, {d}", .{ hello, local_context.x });

}

Die Konstante hello wird im umschließenden Container, dargestellt durch die Quelldatei,
deklariert und ist damit zum einen statisch, zum anderen ist sie aufgrund des const Modifiers
zur Compilezeit bekannt. Selbes gilt für die lokale, statische Variable x . Im gegensatz zu C
werden statische, lokalen Variablen nicht mit dem static Keyword deklariert sondern innerhalb
eines lokalen Structs welches ebenfalls einen Container darstellt. Lokale, statische Variablen
können nützlich sein um z.B. einen gemeinsamen „Shared-State“ zwischen Aufrufen der selben
Funktion zu verwirklichen.

In Zig wird jede Translationunit, d.h. jede Datei in der Quellcode liegt, als Struct
und damit als Container betrachtet. Dementsprechend gibt es eigentlich keine
global deklarierten Variablen wie man sie aus C kennt, sondern nur statische
Variablen die in Containern deklariert werden.

Automatic Memory
Objekte die durch Deklaration bzw. Definition innerhalb eines (Funktions-)Blocks erzeugt
werden erben ihre Lifetime von dem umschließenden Block. Für Variablen und Parameter von
Funktionen bedeutet dies, dass sich ihre Lifetime an der Lifetime eines Stack-Frames orientiert.
Bei jedem Funktionsaufruf wird für den Aufruf ein Stück zusammenhängender Speicher auf dem
Stack alloziert (der Stack-Frame) welcher groß genug ist um alle lokalen Variablen und Parameter
zu halten. Der Frame wird dabei durch zwei Spezialregister der CPU, dem Stack-Pointer (SP) und
dem Base-Pointer (BP), eingegrenzt. Der Stack-Pointer zeigt dabei auf das Ende vom Stack.

39Ein Container in Zig ist jedes Konstrukt, das als Namensraum (engl. namespace) dient. Dazu zählen u.a. Structs
aber auch Sourcedateien.

73
 Es gibt verschiedene Arten von Stacks, jedoch ist die wohl häufigst auftretende
Form der Full-Descending-Stack. Das bedeutet, dass der Stack nach unten
„wächst“ (Descending), d.h. von höheren zu niedrigeren Speicheradressen, und
der Stack-Pointer auf das erste valide Element des Stacks zeigt (Full).

// chapter03/stack_01.zig
const std = @import("std");

pub fn main() !void {

var i: usize = 0; // Begin der Lifetime von 'i' --/
// /
try foo(&i); // foo referenziert 'i' /
} // Ende der Lifetime von 'i' -----------------------/

pub fn foo(a: *u64) !void { // Begin der Lifetime von 'a' --/
a.* += 1; // /
} // Ende der Lifetime von 'a' -----------------------------/

Das obige Programm übergibt eine Referenz auf die Variable i als Argument an die Funktion
foo() , welche i inkrementiert. Die Lifetime der Variable startet mit ihrer Definition und endet
mit dem Funktionsblock von main. Innerhalb der Lifetime darf i von anderen Programmteilen,
in diesem Fall der Funktion foo() , referenziert und ggf. modifiziert werden.
Die Lifetime der Referenz a zu i beginnt mit dem Funktionsblock von foo() und endet mit
dem Ende des Funktionsblocks. Wichtig ist, dass die Lifetime einer Referenz immer innerhalb
der Lifetime des referenzierten Objekts liegen muss. Überschreitet die Lifetime einer Referenz
die Lifetime des referenzierten Objekts so spricht man von einem dangling Pointer (auf Deutsch
hängender Zeiger). Die Verwendung solcher dangling Pointer können zu schwerwiegenden
Programmfehlern führen, da der referenzierte Speicher als undefiniert gilt.
Um das Verhalten der Anwendung besser nachvollziehen zu können, besteht die Möglich-
keit mithilfe des Programms objdump die kompilierte Anwendung zu disassemblieren:
objdump -d -M intel stack_01 . Der Eintrittspunkt einer jeden Anwendung ist dabei die
main Funktion.

00000000010349b0 <stack_01.main>:
10349b0: push rbp ; Begin Prolog ---|
10349b1: mov rbp,rsp ; |
10349b4: sub rsp,0x10 ; End Prolog -----|
10349b8: mov QWORD PTR [rbp-0x8],0x0 ; i = 0
10349bf: 00
10349c0: lea rdi,[rbp-0x8] ; &i
10349c4: call 10348e0 <stack_01.foo>
10349cb: add rsp,0x10 ; Begin Epilog --|

74
Zig Basics

10349cf: pop rbp ; End Epilog ----|

10349d0: ret

Jede Funktion besitzt ein Symbol (im Fall von main ist dies stack_01.main ) welches repräsen-
tativ für die Adresse der ersten Instruktion steht. Beim Funktionsaufruf wird diese Adresse in
das Instruktions-Zeiger-Register (Instruction Pointer - IP) geschrieben, welcher immer auf die
nächste auszuführende Instruktion zeigt. Jede Funktion beginnt mit dem sogenannten Funkti-
ons-Prolog, welcher einen neuen Stack-Frame für den Funktionsaufruf erzeugt, und endet mit
dem Funktions-Epilog, welcher den Stack-Frame wieder entfernt, d.h. den Stack in den Zustand
vor dem Funktionsaufruf zurückversetzt.
Im Prolog wird zuerst der Zustand des Base Pointers (BP), welcher auf den oberen Teil des
derzeitigen Stack-Frames zeigt, auf den Stack gepushed, um diesen im Epilog wieder herstellen
zu können. Danach wird der BP mit dem Wert des SP überschrieben, d.h. BP und SP zeigen
beide auf den alten BP auf dem Stack. Danach werden 16 Bytes (0x10) für die Variablen und
Parameter von main auf dem Stack alloziert, indem der SP um die entsprechende Anzahl an Bytes
verringert wird. Innerhalb des allozierten Speicherbereichs wird die Variable i mit dem Wert
0 initialisiert. Die Adresse der Variable i (BP - 8) wird an die Funktion foo() mittels des RDI
Registers übergeben40.

In einer kompilierten Anwendung existieren Variablen nur implizit, d.h. es

gibt keine Symbole oder ähnliches mit denen z.B. die Variable i klar identi-
fiziert werden kann. In Assembler ist eine Variable lediglich ein Bereich im
(Haupt-)Speicher in welchem der Wert der Variable gespeichert ist.

Abbildung 11: Stack-Frame von main()

00000000010348e0 <stack_01.foo>:
10348e0: push rbp
10348e1: mov rbp,rsp
10348e4: sub rsp,0x20
10348e8: mov QWORD PTR [rbp-0x18],rdi

40Wer mehr über Assembler-Programmierung lernen möchte, dem empfehle ich das Buch ,,x86-64 Assembly
Language Programming with Ubuntu’‚ von Ed Jorgensen. Diese ist öffentlich zugänglich und bietet einen sehr
guten und verständlichen Einstieg.

75
 10348ec: mov QWORD PTR [rbp-0x8],rdi
10348f0: mov rax,QWORD PTR [rdi]
10348f3: add rax,0x1
10348f7: mov QWORD PTR [rbp-0x10],rax
10348fb: setb al
10348fe: jb 1034902 <stack_01.foo+0x22>
1034900: jmp 1034924 <stack_01.foo+0x44>
1034902: movabs rdi,0x101ed99
1034909: 00 00 00
103490c: mov esi,0x10
1034911: xor eax,eax
1034913: mov edx,eax
1034915: movabs rcx,0x101dfb0
103491c: 00 00 00
103491f: call 1034940 <builtin.default_panic>
1034924: mov rax,QWORD PTR [rbp-0x18]
1034928: mov rcx,QWORD PTR [rbp-0x10]
103492c: mov QWORD PTR [rax],rcx
103492f: xor eax,eax
1034931: add rsp,0x20
1034935: pop rbp
1034936: ret

Nach dem Aufruf von foo() wird zuerst ein neuer Stack-Frame für den Funktionsaufruf erzeugt.
Innerhalb dieses Stack-Frames wird der Parameter a mit der Adressen von i initialisiert. Was
auffällt ist, dass die in RDI gespeicherte Adresse gleich mehrmals auf den Stack geschrieben wird
und zusätzlich direkt dereferenziert wird um den Wert von i in das Regsiter RAX zu laden.
Schaut man sich jedoch den gesamten Funktionskörper an so sieht man, dass von der Speicher-
stelle BP - 24 die Adresse von i zum Zurückschreiben des inkrementierten Werts geladen wird.
Damit ist BP - 24 in diesem Fall der Parameter a . Dementsprechend sieht der Stack nach aufruf
von foo() wie folgt aus.

Abbildung 12: Stack-Frame von foo()

76
Zig Basics

Diese im Funktionsprolog vollzogenen Schritte werden vor dem Verlassen der Funktion, im
Epilog, umgekehrt, d.h. beim ausführen der ret Instruktion befindet sich der Stack, bezogen auf
sein Layout, im selben Zustand wie vor dem Fuktionsaufruf. Was sich natürlich geändert hat ist
der Wert der Variable i .

Dynamic Memory
Wir haben uns die Allokation von dynamischem Speicher anhand des
GeneralPurposeAllocator am Anfang dieses Kapitels schon etwas angeschaut. Die Lifetime
von dynamsich allozierten Objekten ist etwas tückischer als die von statisch oder automatisch
allozierten. Der Grund ist, dass bei komplexeren Programmen sowohl die Allokation als auch
die Deallokation eines Objekts an verschiedenen Stellen im Code passieren kann, z.B. abhängig
von einer Bedingung.
Ein Beispiel hierfür ist eine verkettete Liste, bei der alle Element dynamisch auf dem Heap
alloziert werden. Bezogen auf die Allokation würde es in diesem Szenario mindestens eine Stelle
geben und zwar der Bereich des Codes, in dem ein neues Listenelement erzeugt wird. Bei der
Deallokation eines Elements muss zumindest unterschieden werden, ob ein Element aus der
Liste entfernt wird oder ob die gesamte Liste, zum Ende des Programms, dealloziert werden soll,
wobei letzteres als ein Sonderfall angesehen werden kann. Ein weiterer Aspekt auf den geachtet
werden muss ist, dass nach dem Löschen eines Elements der Liste, alle Referenzen auf dieses
Element invalide sind, d.h. es darf nicht mehr auf den Speicher zugegriffen werden.

Abbildung 13: Beispiel einer verketteten Liste

// chapter03/[Link]
const std = @import("std");

// Element einer verketteten Liste mit zwei (optionalen)

// Zeigern auf das nächste und vorherige Element.
const Elem = struct {
prev: ?*Elem = null,
next: ?*Elem = null,
i: u32,

77
 pub fn new(i: u32, allocator: [Link]) !*@This() {
var self = try [Link](@This());
self.i = i;
return self;
}
};

pub fn main() !void {

// Hier fassen wir die Erzeugung eines neune Allokator-Typen
// und dessen Instanziierung in einen Ausdruck zusammen...
var gpa = [Link](.{}){};
// ... und binden dann den Allokator an eine Konstante.
const allocator = [Link]();

// Als nächstes erzeugen wir (manuell) eine verkettete

// Liste mit drei Elementen.
var lhs = try [Link](1, allocator);
defer [Link](lhs);
var middle = try [Link](2, allocator);
var rhs = try [Link](3, allocator);
defer [Link](rhs);

[Link] = middle;
[Link] = lhs;

[Link] = rhs;
[Link] = middle;

// Die Konstante L referenziert das erste Element aus

// der Liste (`lhs`).
const L = lhs;
// Ausgehend vom ersten Element geben wir alle Werte der
// Liste nacheinander aus.
[Link]("Wert von lhs: {d}", .{L.i});
[Link]("Wert von middle: {d}", .{[Link].?.i});
[Link]("Wert von rhs: {d}", .{[Link].?.next.?.i});

// Die Konstante `x` referenziert das mittlere Element...

const x = middle;
[Link](
"Wert von Elem referenziert von x vor deallokation: {d}",
.{x.i});

// ... welches als nächstes aus der Liste (manuell) entfernt wird.
[Link] = [Link];
[Link] = [Link];

78
Zig Basics

[Link](middle);
// ... ab diesem Zeitpunkt ist `x` ein dangling Pointer und
// darf nicht mehr dereferenziert werden...

// ... wir machen es trotzdem aber der Wert des referenzierten

// Objekts ist ab diesem Zeitpunkt undefiniert.
[Link](
"Wert von Elem referenziert von x NACH deallokation: {d}",
.{x.i});
}

In folgendem Beispiel erzeugen wir eine verkettete Liste mit drei Elementen. Als nächstes defi-
nieren wir eine Konstante L , die das erste Element der Liste lhs referenziert und geben nach
und nach, durch Dereferenzierung, die Werte aller drei Elemente aus. Da weder lhs , middle
noch rhs bis zum Zeitpunkt der Ausgabe dealloziert wurden, ist die Dereferenzierung erlaubt.
Wie Sie vielleicht gesehen haben ist die dritte Ausgabe, die letzte Stelle an der L dereferenziert
wird. Damit überschreitet die Lifetime von L zwar theoretisch die Lifetime von lhs , middle
und rhs , in der Praxis spielt dies für die Korrektheit der Anwendung jedoch keine Rolle. Anders
sieht es mit der Konstanten x aus. Zwischen der ersten und zweiten Dereferenzierung von x
wird middle aus der Liste entfernt und dealloziert. Damit ist x ab der Deallokation von middle
ein dangling Pointer was zum Problem wird, da x später noch einmal derefernziert wird. Auch
nach der Deallokation zeigt x weiterhin auf eine existierende Speicherstelle, jedoch wurde diese
durch die Deallokation freigegeben, d.h. die Daten an dieser Stelle sind undefiniert. Das hält Zig
jedoch nicht davon ab den referenzierten Speicher als Instanz von Elem zu interpretieren, was
sich auch in der Kommandozeilenausgabe widerspiegelt.

$ ./linked-list
info: Wert von lhs: 1
info: Wert von middle: 2
info: Wert von rhs: 3
info: Wert von Elem ... von x vor deallokation: 2
info: Wert von Elem ... von x NACH deallokation: 2863311530

Diese Art von Speicherfehler wird als Use-After-Free bezeichnet und kann unter den richtigen
Bedingungen von Angreifern genutzt werden, den Kontrollfluss des Programms zu übernehmen,
sollte es für den Angreifer möglich sein die Speicherstelle zu kontrollieren.
Etwas das Sie sich grundsätzlich Angewöhnen sollten ist, Referenzen die Sie nicht mehr benö-
tigen zu invalidieren. Eine Möglichkeit dies zu tun ist anstelle eines Pointers einen optionalen
Pointer zu verwenden.

var x: ?*Elem = middle;

// ...

79
 [Link] = [Link];
[Link] = [Link];
[Link](middle);
x = null; // wir invalidieren x direkt nach der Deallokation

Häufige Fehler
Im Gegensatz zu speichersicheren (engl. memory safe) Sprachen wie etwa Rust, bietet Zig einige
Fallstricke, die das Leben als Entwickler schwer machen können, aber nicht müssen! In diesem
Abschnitt werden wir uns einige davon näher anschauen und ich zeigen Ihnen, wie Zig Ihnen
dabei hilft sicheren Code zu schreiben.

Speicherzugriffsfehler (Access Errors)

Speicherzugriffsfehler sind eine typische Fehlerquelle und haben in der Vergangenheit schon
zu so einigen Exploits geführt. Allgemein handelt es sich dabei um einen Oberbegriff für
Programmierfehler, durch die unzulässig auf eine Speicherstelle zugegriffen wird. Zu den
Speicherzugriffsfehlern gehören der Buffer-Overflow, Buffer-Over-Read, Invalid-Page-Fault und
Use-After-Free. Den Use-After-Free haben wir uns im Kontext von Lifetimes schon angeschaut,
an dieser Stelle möchte ich Ihnen die verbleibenden Fehler etwas näher bringen.

Buffer Overflow/ Over Read

Der Buffer-Overflow und Buffer-Over-Read sind nah miteinander verwandt, kommen jedoch
jeweils mit ihren eigenen Problemen. Beim Buffer-Overflow wird Speicher außerhalb eines
validen Bereichs beschrieben. Dies ist meist das Resultat der unzureichenden Überprüfung der
Grenzen eines Objekts, z.B. eines Arrays. Ein klassisches Beispiel ist ein Array, dass an einer
Stelle indiziert wird die außerhalb der Grenzen des Arrays liegt.

var x: [10]u8 = .{0} ** 10;

x[10] = 1; // Index 10 ist out-of-bounds -> buffer overrread!

Diese Art von Fehlern können genutzt werden um Daten von naheliegenden Objekten oder sogar
Adressen zu überschreiben. In der Vergangenheit wurde diese Art von Fehler von Angreifern ge-
nutzt um Schadcode in Anwendungen einzuschleusen, die Rücksprungadresse zu überschreiben
und so die Kontrolle über den Prozess zu übernehmen. Moderne Compiler injizieren deswegen
sogenannte Stack-Canaries, einen randomisierten Wert der von einem Angreifer nicht erraten
werden kann und der vor der Rückkehr in die aufrufende Funktion überprüft wird, in Stack-
Frames die potenziell von einem Buffer-Overflow betroffen sein könnten. Ist ein Stack-Frame von
einem Buffer-Overflow betroffen und wurde die Rücksprungadresse überschrieben, so bedeutet
dies, dass auch der Canary überschrieben wurde. In diesem Fall wird der Prozess zur Sicherheit
beendet. Wie das Zig-Zen so schön sagt: ,,Laufzeit-Crashes sind besser als Bugs’‚ (engl. „Runtime
crashes are better than bugs“).

80
Zig Basics

Im obigen Fall wird der Buffer-Overflow schon zur Compile-Zeit erkannt, da Arrays eine
zur Compile-Zeit bekannte Länge besitzen (Zig-Zen: „Compile errors are better than runtime
crashes“).

error: index 10 outside array of length 10

x[10] = 1;

Allozieren wir den Speicher jedoch dynamisch so kann der Compiler uns nicht mehr vor unserem
Fehler bewahren.

var x = try [Link](u8, 10);

x[10] = 1;

Da wir in Zig jedoch in den meisten Fällen mit Arrays oder Slices arbeiten und nicht mit rohen
Zeigern und Zig für beide Datenstrukturen die Grenzen bei einem Speicherzugriff überprüft,
wird der Buffer-Overflow zumindest zur Laufzeit erkannt und der Prozess beendet (Zig-Zen:
„Runtime crashes are better than bugs“).

thread 7940 panic: index out of bounds: index 10, len 10

[Link]:6: 0x1037424 in main (buffer-overflow)
x[10] = 1;

Invalid Page Fault

Moderne Betriebssystem schirmen den Hauptspeicher ab und stellen jedem Prozess stattdessen
virtuellen Speicher zur Verfügung, der aus Sicht des Prozesses nahezu unbegrenzt ist. Bei
bedarf werden Teile des Hauptspeichers, sogenannte Pages, in den virtuellen Addressraum eines
Prozesses gemapped, wodurch dieser den Speicher lesend, so wie schreibend, nutzen kann.
Ein Invalid-Page-Fault ist eine Fehler bei dem ein Prozess versucht auf einen Speicherbe-
reich zuzugreifen, der nicht durch eine Page gedeckt wird. Ein klassisches Beispiel hierfür
ist die NULL -Pointer-Exception, bei dem innerhalb eines Programms versucht wird einen
NULL -Zeiger zu dereferenzieren. Grund hierfür ist, dass die meisten Betriebssysteme keine
physische Page auf den Speicherbereich mappen, der die Adresse 0x0000000000000000 mit
einschließt. Wird eine Page-Fault durch das Betriebssystem erkannt, so erzeugt der Kernel einen
Segmentation-Fault (Schutzverletzung) für den betroffenen Prozess, welcher diesen abnormal
beendet. Jeder der schon einmal in C programmiert hat wird den entsprechenden Fehler
"sigsegv segmentation fault" schon einmal auf der Kommandozeile gesehen haben.

Use After Free

Bei einem Use-After-Free wird Speicher, nach dem Ende dessen Lifetime, verwendet. Grundsätz-
lich hält Zig sie nicht davon ab, durch einen dangling Pointer, auf Speicher zuzugreifen, nachdem
dieser wieder freigegeben wurde. Eine Möglichkeit das Risiko für Use-After-Free Bugs in Ihrem
Code zu reduzieren, ist durch die Verwendung von optionalen Zeigern ?*T bzw. ?*const T .

81
Zusammenfassung
Bei dem Arbeiten mit Referenzen bzw. Slices sind zwei Fragen von essenzieller Bedeutung:
Umschließt die Lifetime des referenzierten Objekts die der Referenz und wenn nein, habe ich
dafür gesorgt, dass nach dem Ende der Lifetime des Objekts nicht mehr versucht wird auf dieses
zuzugreifen. Fall Sie diese Fragen nicht beantworten können besteht eine hohe Wahrscheinlich-
keit, dass sich Speicherfehler in Ihren Code einschleichen.

82
Zig Basics

Kapitel 4

Hands On: Taschenrechner

Jetzt wird es Zeit, dass wir die ganze Theorie einmal in die Praxis umsetzen. Das Ziel: einen
Taschenrechner programmieren. Am Ende dieses Kapitels werden Sie einen Taschenrechner in
den Händen halten, der die grundlegenden Rechenoperationen Plus, Minus, Mal und Geteilt
unterstützt.

Abbildung 14: Skizze des zu programmierenden Taschenrechners

Für die graphische Benuteroberfläche (GUI) unseres Taschenrechners verwenden wir dvui41, eine
Immediate-Mode-GUI-Library. Vereinfacht ausgedrückt bedeutet Immediate-Mode42, dass dvui
keine Widgets zwischen den Frames speichert. Das heißt graphische Elemente sind nur dann
sichtbar, wenn ein entsprechendes Kommando zum Zeichnen des Elements auch tatsächlich
innerhalb des Frames ausgeführt wurde.
Dvui unterstützt verschiedene Backends, auf denen dvui aufbauen kann. Backends sind Low-
Level-Bibliotheken die Zugriff zu Audio, Tastatur, Maus und Graphikhardware (etwa OpenGL)
bieten. Das Backend, welches wir für dvui verwenden werden werden, heißt SDL43. SDL steht für
die meisten gängigen Betriebssysteme zur Verfügung, darunter Windos, Linux, macOS, iOS und
Android. Wir müssen uns jedoch nicht direkt mit SDL herumschlagen. Dvui bietet eine intuitive
41 [Link]
42 [Link]
43 [Link]

83
API durch die sich GUIs beschreiben lassen ohne sich Gedanken um Low-Level-Konzepte
machen zu müssen.
Dvui befindet sich, genau wie Zig selbst, noch in Entwicklung, weshalb wir für unsren
Taschenrechner einen spezifischen Git-Commit verwenden, der in diesem Buch verwendeten
Zig-Version kompatibel ist.

Projekt anlegen
Erzeugen Sie einen neuen Projektordner mit dem Namen taschenrechner und initialisieren Sie
diesen.

$ cd taschenrechner/
$ zig init
info: created [Link]
info: created [Link]
info: created src/[Link]
info: created src/[Link]
info: see `zig build --help` for a menu of options

Fügen Sie danach dvui als Dependency zu [Link] hinzu.

taschenrechner/[Link]
.dependencies = .{
.dvui = .{
.url = "[Link]
[Link]",
.hash =
"12202bc99ddacde83c39ae59dc29b31b192ea20c9c67f62a4cffb19b2d2a31f0bccb",
},
},

Innerhalb von [Link] können Sie im Anschluss auf die dvui Dependency zugreifen und das
darin enthaltene Modul dvui_sdl importieren. Grundsätzlich kann eine Dependency mehrere
Module und andere Ressourcen exportieren. Wie genau diese zu verwenden sind wird im besten
Fall durch die jeweilige Dokumentation deutlich. Im Fall von dvui gibt es ein eigenständiges
Demoprojekt44, das als Vorlage dient.

taschenrechner/[Link]
pub fn build(b: *[Link]) void {
// ...

44 [Link]

84
Zig Basics

const dvui_dep = [Link]("dvui", .{ .target = target, .optimize

= optimize });

// ...

exe.root_module.addImport("dvui", dvui_dep.module("dvui_sdl"));

// ...
}

Durch addImport importieren wir dvui_sdl unter dem Namen dvui , das heißt wir können
im Anschluss mit @import("dvui") auf das Modul zugreifen.

Hello dvui
Als nächstes brauchen wir ein Fenster, in dem unser Taschenrechner angezeigt werden soll.
Kopieren sie hierfür den folgenden Code in [Link].

taschenrechner/src/[Link]
const std = @import("std");
const dvui = @import("dvui");
comptime {
[Link](dvui.backend_kind == .sdl);
}
const Backend = [Link];

// Definiere einen Allokator für die Speicherallokation.

var gpa_instance = [Link](.{}){};
const gpa = gpa_instance.allocator();

const vsync = true;

var g_backend: ?Backend = null;

pub fn main() !void {

defer _ = gpa_instance.deinit();

// SDL-Backend initialisieren (erzeugt ein eigens Fenster)

var backend = try [Link](.{
.allocator = gpa,
.size = .{ .w = 400.0, .h = 600.0 },
.min_size = .{ .w = 400.0, .h = 600.0 },
.vsync = vsync,
.title = "Taschenrechner",

85
 });
g_backend = backend;
defer [Link]();

// Fenster wird initialisiert

var win = try [Link](
@src(),
gpa,
[Link](),
.{},
);
defer [Link]();

main_loop: while (true) {

// beginWait und waitTime spielen zusammen und rendern Frames

// nur dann, wenn diese auch benötigt werden.
const nstime = [Link]([Link]());

// Dieser Aufruf markiert den Anfang eines Frames. Nach diesem Aufruf
// können dvui-Funktionen verwendet werden.
try [Link](nstime);

// SDL hilft auch bei der Verarbeitung von Events, wie etwa
// Tastatureingaben. Mit diesem Aufruf schicken wir alle SDL
// Events zu dvui, zur Verarbeitung.
const quit = try [Link](&win);
if (quit) break :main_loop;

// Mit dem folgenden Funktionsaufruf wird das Fenster zurückgesetzt.

// Andererseits könnten Artefakte aus vorherigen Frames verbleiben,
// die allgemein störend wirken.
_ = Backend.c.SDL_SetRenderDrawColor([Link], 255, 255,
255, 255);
_ = Backend.c.SDL_RenderClear([Link]);

// An dieser Stelle können wir weitere dvui-Funktionen aufrufen...

// Dieser Funktionsaufruf markiert das Ende eines Frames. Es dürfen

// keine dvui-Funktionen mehr aufgerufen werden!
const end_micros = try [Link](.{});

// Cursor-Management
[Link]([Link]());
[Link]([Link]());

// Render den Frame...

86
Zig Basics

[Link]();

const wait_event_micros = [Link](end_micros, null);

[Link](wait_event_micros);
}
}

Der obige Code besteht aus zwei Hauptteilen: dem Erzeugen eines neuen Fensters und der
Hauptschleife main_loop . Die Funktion initWindow erwartet verschiedene Optionen, wobei
für die meisten Standardwerte definiert sind, die automatisch übernommen werden. Für die
Allokation von dynamischem Speicher verwenden wir einen GeneralPurposeAllocator , als
initiale Fenstergröße geben wir 400 mal 600 Pixel an und der Titel unserer Applikation ist
Taschenrechner.
Innerhalb von main_loop implementieren wir den Hauptteil der Anwendung. Die zu sehenden
Funktionsaufrufe sind dabei Boiler-Plate-Code und bei allen dvui-Anwendungen mehr oder
weniger gleich.
Wenn Sie nun zig build run ausführen, sollten Sie ein leeres Fenster mit dem Titel Taschen-
rechner sehen.

Abbildung 15: Fenster des Taschenrechners ohne weitere Widgets

User Interface

87
 User Interface

Unser Taschenrechner besteht rein konzeptionell aus zwei Teilen: einer Anzeige und einem
Nummernblock, wobei der Block wiederum in einzelne Tasten unterteilt werden kann. Durch
drücken dieser Tasten lässt sich der Zustand des Taschenrechners verändern, welcher über die
Anzeige zurück an den Nutzer gespiegelt wird. Der interne Zustand kann dabei als Zustandsau-
tomat betrachtet werden. Bevor wir uns jedoch um die Logik des Taschenrechners kümmern,
wenden wir uns der Nutzeroberfläche zu.
Als erstes fügen wir einen Puffer für die Nutzereingaben hinzu. Hierfür bietet sich eine
ArrayList(u8) an, welche eine lineare Sequenz an Bytes darstellt. Der Vorteil von ArrayList
gegenüber einem Array ist, dass sich ArrayList s mühelos erweitern lassen, ohne das wir uns
Gedanken über den zu allozierenden Speicher machen müssen.

taschenrechner/src/[Link]
// ...

var display_text: [Link](u8) = [Link](u8).init(gpa);

// ...

pub fn main() !void {

// ...

display_text.deinit();
}

Die Variable display_text , an die unsere ArrayList(u8) gebunden wird, definieren wir im
umschließenden Kontainer der Main-Funktion. Der Grund hierfür ist lediglich, dass wir damit
auch von anderen Funktionen, innerhalb von [Link], auf die Variable zugreifen können.
Da unsere Anwendung mit nur einem Thread auskommt, ist das auch in Ordnung und
wir müssen uns keine Gedanken um etwaige Wettlaufsituationen (Race-Condition/ -Hazard)45
machen. Außerhalb von Funktionen können wir außerdem kein defer verwenden, weshalb wir
display_text am Ende der Main-Funktion deinitialisieren, das heißt den allozierten Speicher
wieder freigeben.
Für das Layout des Taschenrechners definieren wir eine Funktion mit dem Namen
taschenrechner (ja ich weiß… sehr originär), die innerhalb der Hauptschleife aufgerufen wird.

taschenrechner/src/[Link]

pub fn main() !void {

// ...

45 [Link]

88
Zig Basics

main_loop: while (true) {

// ...

// An dieser Stelle können wir weitere dvui-Funktionen aufrufen...

try taschenrechner();

// ...

// ...

pub fn taschenrechner() !void {

var vbox = try [Link](@src(), .vertical, .{});
{
// Display
try [Link](
@src(),
"{s}",
.{display_text.items},
.{ .gravity_y = 0.5 },
);

// Ziffernblock
var block = try [Link](@src(), .vertical, .{});
{
var row1 = try [Link](@src(), .horizontal, .{});
{
if (try [Link](@src(), "7", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('7');
}
if (try [Link](@src(), "8", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('8');
}
if (try [Link](@src(), "9", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('9');
}
if (try [Link](@src(), "/", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('/');
}
}
[Link]();

89
var row2 = try [Link](@src(), .horizontal, .{});
{
if (try [Link](@src(), "4", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('4');
}
if (try [Link](@src(), "5", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('5');
}
if (try [Link](@src(), "6", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('6');
}
if (try [Link](@src(), "*", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('*');
}
}
[Link]();

var row3 = try [Link](@src(), .horizontal, .{});

{
if (try [Link](@src(), "1", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('1');
}
if (try [Link](@src(), "2", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('2');
}
if (try [Link](@src(), "3", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('3');
}
if (try [Link](@src(), "-", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('-');
}
}
[Link]();

var row4 = try [Link](@src(), .horizontal, .{});

{
if (try [Link](@src(), "0", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('0');
}
if (try [Link](@src(), ",", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append(',');
}
if (try [Link](@src(), "=", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('=');
}
if (try [Link](@src(), "+", .{}, .{ .gravity_y = 0.5 })) {
try display_text.append('+');

90
Zig Basics

}
}
[Link]();
}
[Link]();
}
[Link]();
}

Dvui erlaubt es mit einer Box mehrere graphische Elemente entweder horizontal ( .horizontal )
oder vertikal ( .vertical ) anzuordnen. Mit einem Aufruf der Funktion box() wird eine
Container vom Typ Box geöffnet. Wird die deinit() Methode auf einer Box-Variable aufge-
rufen, so ist dies mit dem Schließen des Containers gleichzusetzen. Damit sind alle graphischen
Element, zum Beispiel ein Button der mit der button() Funktion erzeugt wird, die zwischen der
Definition einer Containervariable und dem Aufruf von deinit() erzeugt werden automatisch
Teil des Containers.
Die GUI unseres Taschenrechners besteht aus einer vertikalen Box vbox die zwei Elemente
enthält: das Display, welches die Eingabe anzeigt, und dem Ziffernblock.
Für das Display verwenden wir die Funktion label() mit der Text dargestellt wird. Die Funk-
tion erwartet unter anderem einen Format-String, sowie eine beliebige Anzahl an Ausdrücken,
deren Werte in den Format-String übernommen werden sollen. In unserem Fall soll nur der Inhalt
von display_text angezeigt werden. Aus diesem Grund verwenden wir den Format-String
"{s}" ( {s} steht für ersetze durch String) und übergeben als zugehörigen Ausdruck den in der
ArrayList gespeicherten String.

Der Ziffernblock besteht aus einer vertikalen Box, die insgesamt vier horizontale Boxen
umschließt. Jeder der horizontalen Boxen enthält vier Buttons, die jeweils eine Taste unseres
Taschenrechners darstellen. Der Vorteil von dvui ist, dass wir für Buttons nicht umständlich
Callbacks registrieren müssen (vielleicht erinnern Sie sich noch an das GTK-Beispiel aus Kapitel
1), stattdessen gibt jeder Button direkt true zurück, sollte er gedrückt worden sein. Das heißt
wir können einfach mit if überprüfen ob der jeweilige Button gedrückt wurde und eine
gewünschte Aktion ausführen. Fürs Erste begnügen wir uns damit, das Symbol der jeweiligen
gedrückten Taste an display_text anzufügen.
Nach erneutem kompilieren und starten der Anwendung sollten Sie das folgende sehen.

91
 Abbildung 16: Taschenrechner mit grundlegendem Layout aber ohne Logik

Zustände Bitte
Um die Logik des Taschenrechners zu implementieren gibt es verschiedene Ansätze. Manche
Mathematikbibliotheken besitzen zum Beispiel eine eval() Funktion, mit der sich beliebige
mathematische Ausdrücke evaluieren lassen. Die Logik unseres Taschenrechners implementie-
ren wir jedoch selber. Damit dies nicht komplett ausartet, reduzieren wir die Möglichkeiten des
Taschenrechners auf ein Minimum.
Der in Abbildung 17 abgebildete Taschenrechner akzeptiert Ausdrücke bestehend aus genau
zwei (Fließkomma-)Zahlen, getrennt durch ein mathematisches Symbol sym (Plus + , Minus - ,
Mal * oder Geteilt / )46.
Ausgehen vom initialen Zustand start können wir eine beliebige Folge an Ziffern (Null bis
Neun) eingeben. Danach folgt entweder ein Komma oder eines der erlaubten, mathematischen
Symbole. Nach dem Symbol folgt wieder eine (Fließkomma-)Zahl. Durch Eingabe des Gleich-
heitszeichens = erreichen wir den Endzustand, das heißt der Ausdruck wird ausgewertet und
auf dem Display des Taschenrechners angezeigt. Folgt keine Ziffer hinter einem Komma, so wird
dieses bei der Auswertung ignoriert.
Eingaben für die keine Kante existiert, werden von unserem Taschenrechner ignoriert, das heißt
sie werden nicht an display_text angefügt.

46 Die theoretischen Informatiker mögen mir den verunstalteten Automaten verzeihen.

92
Zig Basics

Abbildung 17: Zustandsautomat eines extrem vereinfachten Taschenrechners

Die einzelnen Zustände können wir als Enum repräsentieren. Fügen sie den folgenden Code an
den Anfang von [Link] hinzu.

taschenrechner/src/[Link]
// ...

const State = enum {

start,
num1,
num2,
sym2,
num3,
num4,
E,
};

// Am Anfang befinden wir uns im `start` Zustand

var state: State = .start;
var display_text: [Link](u8) = [Link](u8).init(gpa);

// ...

Für die Verarbeitung der Nutzereingaben definieren wir eine Funktion addValue , sowie zwei
Hilfsfunktionen isDigit und isSym . Die Funktion addValue bildet den Zustandsautomaten
aus Abbildung 17 ab und fügt die jeweilige Eingabe zu unserem Textbuffer display_text hinzu.

93
Die Funktion isDigit prüft ob die Eingabe eine Zahl zwischen Null und Neun ist, während
isSym überprüft, ob die Eingabe eines der Symbole + , - , * oder / darstellt.

taschenrechner/src/[Link]
fn addValue(v: u8) !void {
switch (state) {
.start => {
if (isDigit(v)) {
try display_text.append(v);
state = .num1;
}
},
.num1 => {
if (isDigit(v)) {
try display_text.append(v);
} else if (isSym(v)) {
// Wir nutzen ein Leerzeichen um Zahlen von +, -, * oder /
// zu trennen. Das erleichtert uns später das Parsen.
try display_text.append(' ');
try display_text.append(v);
state = .sym2;
} else if (v == ',') {
try display_text.append(v);
state = .num2;
}
},
.num2 => {
if (isDigit(v)) {
try display_text.append(v);
} else if (isSym(v)) {
try display_text.append(' ');
try display_text.append(v);
state = .sym2;
}
},
.sym2 => {
if (isDigit(v)) {
try display_text.append(' ');
try display_text.append(v);
state = .num3;
}
},
.num3 => {
if (isDigit(v)) {
try display_text.append(v);
} else if (v == '=') {
state = .E;

94
Zig Basics

} else if (v == ',') {
try display_text.append(v);
state = .num4;
}
},
.num4 => {
if (isDigit(v)) {
try display_text.append(v);
} else if (v == '=') {
state = .E;
}
},
.E => {}, // Nichts zu tun...
}
}

fn isDigit(v: u8) bool {

return v >= 0x30 and v <= 0x39;
}

fn isSym(v: u8) bool {

return v == '+' or v == '-' or v == '*' or v == '/';
}

Die einzige Aufgabe von addValue ist es sicher zu stellen, dass der Nutzer nur (nach unseren
Maßstäben) korrekte Eingaben tätigen kann. Damit die Funktion jedoch auch Anwendung findet
müssen die Aufrufe von display_text.append() , innerhalb von taschenrechner() , durch
einen Aufruf von addValue() ersetzt werden ,zum Beispiel try display_text.append('+');
durch try addValue('+'); .
Danach können Sie mit zig build run die Anwendung neu kompilieren, welche jetzt, je nach
Zustand, nur noch bestimmte Eingaben annimmt.

Ausdruck Evaluieren
Nachdem wir die Regeln für (aus unserer Sicht) korrekte Ausdrücke festgelegt haben, müssen
wir diese nun nur noch Evaluieren. Zum Glück bestehen unsere Ausdrücke jeweils nur aus zwei
Zahlen. Damit müssen wir uns um die Reihenfolge der Auswertung keine Sorgen machen.

taschenrechner/src/[Link]
fn eval() !void {
// Die Auswertung findet nur statt, sollten wir im
// Endzustand sein.
switch (state) {

95
 .E => {
// Wir müssen das Komma durch einen Punkt ersetzen,
// da ansonsten der Parser einen Fehler wirft.
for (display_text.items) |*item| {
if (item.* == ',') item.* = '.';
}

// Als nächstes teilen wir den String an den Leerzeichen.

var iter = [Link](u8, display_text.items, " ");

// Erste Zahl
const n1_ = [Link]().?;
const n1 = if (n1_[n1_.len - 1] == '.') n1_[0 .. n1_.len - 1]
else n1_;
// Symbol
const sym = [Link]().?;
// Zweite Zahl
const n2_ = [Link]().?;
const n2 = if (n2_[n2_.len - 1] == '.') n2_[0 .. n2_.len - 1]
else n2_;

// Nun müssen wir die Zahlenstrings in eine Fließkommazahl

// umwandeln. Hierzu haben wir im Vornhinein die Kommas
// durch Punkte ersetzt.
const num1 = try [Link](f128, n1);
const num2 = try [Link](f128, n2);

// Je nach Symbol führen wir eine andere mathematische

// Operation aus.
const res = switch (sym[0]) {
'+' => num1 + num2,
'-' => num1 - num2,
'*' => num1 * num2,
'/' => num1 / num2,
else => unreachable,
};

// Jetzt schreiben wir das Ergebnis zurück in den `display_text`.

display_text.clearAndFree();
try display_text.writer().print("{d}", .{res});

// Sollte das Ergebnis kein Komma enthalten, sind wir wieder

// in Zustand num1...
state = .num1;
for (display_text.items) |*item| {
if (item.* == '.') {
item.* = ',';

96
Zig Basics

// ...ansonsten sind wir in Zustand num2.

state = .num2;
}
}
},
else => {},
}
}

Die Funktion eval() parsed, falls wir im Endzustand sind, den in display_text enthaltenen
String in drei Bausteine: die erste Zahl, ein Symbol und die zweite Zahl. Da wir alle eingaben
Überprüfen wissen wir beim Parsen, dass der String das erwartete Format hat, wodurch wir beim
Aufruf von next() den null -Fall nicht explizit prüfen müssen.
Das Ergebnis wird zurück in display_text geschrieben. Dadurch können wir mit dem Ergebnis
direkt weiterrechnen. Je nachdem, ob das Ergebnis ein Komma enthält, ist der Taschenrechner
nach der Berechnung entweder in Zustand num1 oder num2 .
Damit das Ergebnis auch berechnet wird, fügen sie einen Aufruf der eval() Funktion an das
Ende der taschenrechner() Funktion hinzu.

taschenrechner/src/[Link]
pub fn taschenrechner() !void {
// ...

try eval();
}

Herzlichen Glückwunsch! Sie haben Ihren ersten, sehr minimalistischen Taschenrechner in Zig
programmiert.

Refactoring
Bevor wir unser kleines Projekt abschließen nutzen wir die Gelegenheit, um den Taschenrechner
etwas aufzubessern. Zum einen kann der Code für den Ziffernblock vereinfacht werden. Zum
anderen haben die Tasten teilweise unterschiedliche Größen.
Anstelle den Ziffernblock manuell zu definieren, bietet es sich an diesen als zweidimensionales
Array abzubilden.

const pad: [4][4][]const u8 = .{

.{ "7", "8", "9", "/" },
.{ "4", "5", "6", "*" },

97
 .{ "1", "2", "3", "-" },
.{ "0", ",", "=", "+" },
};

Im Anschluss könne wir über die einzelnen Elemente iterieren. Dazu verwenden wir zwei
verschachtelte For-Schleifen (eine für jede Dimension des Arrays). Mit der äußeren Schliefen
iterieren wir über die Zeilen und mit der Inneren über die einzelnen Elemente der Zeile.

for (pad, 0..) |row, id1| {

// Äußere Schleife

for (row, 0..) |elem, id2| {

// Innere Schleife
}
}

Jedes Element in dvui, egal ob Box oder Button, wird mit einer Id versehen. Wird die selbe
Funktion, zum Beispiel box() innerhalb einer Schleife, mehrfach verwendet, so kann dvui dem
Element nicht automatisch eine eindeutige Id zuweisen. In solchen Fällen muss die id_extra
Option beim jeweiligen Funktionsaufruf mit übergeben werden. Aus diesem Grund iterieren wir
in den gezeigten For-Schleifen nicht nur über das Array pad sondern parallel auch über die
Reihe 0, 1, 2, … und verwenden den jeweiligen Index als Extra-Id bei den Funtkionsaufrufen zu
box() und button() .

Die gesamte Funktion sieht dementsprechend wie folgt aus:

taschenrechner/src/[Link]
pub fn taschenrechner() !void {
var vbox = try [Link](@src(), .vertical, .{
.expand = .both,
});
{
// Display
try [Link](
@src(),
"{s}",
.{display_text.items},
.{
.expand = .horizontal,
.gravity_y = 0.5,
.gravity_x = 0.5,
},
);

98
Zig Basics

// Ziffernblock
var block = try [Link](@src(), .vertical, .{
.expand = .both,
.gravity_x = 0.5,
});
{
const pad: [4][4][]const u8 = .{
.{ "7", "8", "9", "/" },
.{ "4", "5", "6", "*" },
.{ "1", "2", "3", "-" },
.{ "0", ",", "=", "+" },
};

for (pad, 0..) |row, id1| {

var row_box = try [Link](@src(), .horizontal, .{
.gravity_x = 0.5,
.id_extra = id1,
});

for (row, 0..) |elem, id2| {

if (try [Link](@src(), elem, .{}, .{
.gravity_y = 0.5,
.corner_radius = [Link](0.0),
.min_size_content = [Link](16.0),
.id_extra = id2,
})) {
try addValue(elem[0]);
}
}

row_box.deinit();
}
}
[Link]();
}
[Link]();

try eval();
}

Die restlichen Optionen werden dazu verwendet, die Elemente zu zentrieren. Mit der .expand
Option sagen wir dvui, dass die Boxen das gesamte Fenster (entweder nur in der Horizontalen
.horizontal , in der Vertikalen oder in beide Richtungen .both ) einnehmen sollen. Die
.gravity_x Option definiert, dass das jeweilige Element innerhalb eines Containers zentral
angeordnet werden soll.

99
Für die einzelnen Buttons definieren wir, mittels .min_size_content , eine einheitliche, mini-
male Größe von 16.
Damit sieht unsere Anwendung schlussendlich wie folgt aus.

Abbildung 18: Finaler Zustand des Taschenrechners

Zusammenfassung
In diesem Kapitel haben Sie gelernt, wie Sie graphische Anwendungen mit dvui entwickeln. Wir
haben uns angeschaut, wie ein neues Fenster erzeugt wird und haben dieses mit verschiedenen
graphischen Elementen befüllt. Durch die Interaktion mit Buttons haben wir den Zustand
unserer Anwendung verändert. Im weiteren haben wir gesehen, wie wir mit der Hilfe von Enums
den Zustand unserer Anwendung im Blick behalten und ausgehend von diesem Zustand nur
bestimmte Interaktionen zulassen.
Bei unserem Taschenrechner gibt es noch viel Verbesserungsbedarf. Scheuen Sie sich deshalb
nicht, mit dem bestehenden Code zu experimentieren. Wie wäre es zum Beispiel mit einer
Rücksetzfunktion oder der Möglichkeit negative Zahlen eingeben zu können?

100
Zig Basics

Kapitel 5

Control Flow

Zig bietet eine ganze Reihe an Kontrollstrukturen, mit denen vorgegeben werden kann, in
welcher Reihenfolge die Handlungsschritte eines Algorithmus, beziehungsweise einer Funktion,
abzuarbeiten sind. Hierzu zählen bedingte Anweisungen ( if , else if , else und switch )
mit denen verschiedene Zweige, basierend auf einer Bedingung, ausgeführt werden können,
Schleifen ( while und for ) durch die eine bestimmte Aufgabe mehrere male ausgeführt werde
kann und break , sowie continue , um den Ausführungsfluss an einer anderen Stelle fortzu-
führen. Zigs for -Loops machen es nicht nur einfach über Arrays, Slices und die Elemente von
Many-Item-Pointers zu iterieren, sondern sie erlauben auch das parallele Iterieren über mehrere
Kollektionen.

Bedingte Anweisungen
Eine der grundlegendsten Kontrollstrukturen in der strukturierten Programmierung sind
bedingte Anweisungen. Hierdurch können einzelne Ausdrücke oder Blöcke, basierend auf einer
Bedingung, ausgeführt werden.
Zig bietet zwei Wege, Verzweigungen zu implementieren: If-Statements und Switch-Statements.
Während sich If-Statements vor allem für die Überprüfung einer kleinen Menge an Bedingungen
eignen, machen es switch -Statements einfach, auch auf einer größeren Menge an möglichen
Bedingungen zu agieren.

If
Die einfachste Form eines If-Statements ist eine bedingte Anweisung, bestehend aus einer
Bedingung und einem zugehörigen Code-Abschnitt. Dieser Abschnitt kann entweder eine Block
sein, eingegrenzt durch geschweifte Klammern {} oder eine Ausdruck (engl. Expression).
Jede einfache bedingte Anweisung beginnt mit dem Schlüsselwort if , gefolgt von einer Bedin-
gung in runden Klammern () . Die Bedingung muss ein Ausdruck sein, der zu einem bool
evaluiert, das heißt der Ausdruck ist entweder true oder false . Nach der Bedingung folgt
entweder ein Block oder ein Ausdruck, welcher ausgeführt wird, sollte die Bedingung zu true
evaluieren.

101
 If

const temp = 31;

if (temp < 20) {
[Link]("Es hat {d} Grad! Pack ne Jacke ein!", .{temp});
}

Im obigen Beispiel wird geprüft, ob es weniger als 20 Grad Celsius hat. Ist dies der Fall wird eine
Nachricht ausgegeben, dass es kalt ist und man eine Jacke einpacken soll. Andernfalls wird der
zum if gehörende Block nicht ausgeführt.
Oft ist es nötig, entweder einen bestimmten Fall abzudecken oder falls dieser nicht eintritt,
unabhängig von weiteren möglichen Fällen, auf eine Alternative zurückzufallen. Hierzu werden
Verzweigungen verwendet. Die einfachste Verzweigung ist ein if - else . Ein else ist optional
und kann niemals alleine stehen, es muss immer auf ein if beziehungsweise else if folgen.
Es wird ausgeführt, sollte keiner der zuvorkommenden Bedingungen erfüllt worden sein.

const temp = 31;

if (temp < 20) {
[Link]("Es hat {d} Grad! Pack ne Jacke ein!", .{temp});
} else {
[Link]("Eigentlich ganz schön heute!", .{});
}

Das obige Beispiel bedeutet: falls es weniger als 20 Grad Celsius hat gib die erste Nachricht
aus, ansonsten gib die zweite Nachricht aus. Dabei ist garantiert, dass einer der beiden Zweige
definitiv ausgeführt wird.
Unter der Verwendung von else if können beliebig viele Zweige miteinander verkettet
werden. Genau wie bei if enthält ein else if eine Bedingung die erfüllt sein muss, damit
der zugehörige Zweig ausgeführt wird. Dabei ist zu betonen, dass bei verketteten, bedingten
Anweisung immer nur einer der definierten Fälle zutreffen kann! Die Fälle werden dabei von
oben nach unten abgearbeitet.

chapter04/[Link]
const temp = 31;
if (temp < 20) {
[Link]("Es hat {d} Grad! Pack ne Jacke ein!", .{temp});
} else if (temp > 30) {
[Link]("Wow {d} Grad! Pack die Badehose ein!", .{temp});
} else {
[Link]("Eigentlich ganz schön heute!", .{});
}

Das obige Beispiel liest sich wie folgt. Hat es weniger als 20 Grad Celsius so wird der Nutzer
aufgefordert eine Jacke einzupacken. Hat es mehr als 30 Grad Celsius, so wird er aufgefordert

102
Zig Basics

eine Badehose einzupacken. Ansonsten, falls die Temperatur zwischen 20 und 30 Grad liegt, wird
der else -Block ausgeführt.
if , else if und else können auch dazu verwendet werden, basierend auf einer oder meh-
reren Bedingungen, eine Variable zu initialisieren. Hierzu wird eine If-Expression verwendet.
Der Unterschied ist, dass anstelle eines Blocks ein Ausdruck auf die jeweilige Bedinung bzw.
else folgt. Wie alle anderen Ausdrücke auch, müssen If-Expressions mit einem Semilkolon ;
abgeschlossen werden.

chapter04/[Link]
const nachricht =
if (temp < 20)
"Pack ne Jacke ein!"
else if (temp > 30)
"Pack die Badehose ein!"
else
"Eigentlich ganz schön heute!";

[Link](nachricht, .{});

In diesem Beispiel wird je nachdem welche Bedingung wahr ist, die Konstante nachricht mit
dem entsprechenden String initialisiert. Alle Zweige müssen hierfür einen Wert des selben Typs
zurückgeben, das heißt der Rückgabetyp der If-Expression wird durch die Rückgabewerte aller
zweige bestimmt. Außerdem ist in diesem Fall das else nicht optional, da es sonst zu Fällen
kommen kann, in denen nachricht gar kein Wert zugewiesen wird.
Sollte für bestimmte Fälle kein vernünftiger Rückgabewert angegeben werde können, so kann
innerhalb einer If-Expression auch null verwendet werden. In diesem Fall ist der Rückgabewert
des Ausdrucks ein Optional.

const nachricht: ?[]const u8 =

if (temp < 20)
"Pack ne Jacke ein!"
else if (temp > 30)
"Pack die Badehose ein!"
else
null;

If mit Errors
Mit if kann auch auf Fehler geprüft werden. Hierfür muss die Bedingung eines If-Statements
ein Ausdruck sein, der zu einem Error-Typ evaluiert (zum Beispiel anyerror!u32 ). Das else
ist bei der Prüfung von Fehlern nicht optional und muss immer verwendet werden.

chapter04/[Link]

103
 test "error capture #1" {
const a: anyerror!u32 = 7;
if (a) |value| {
try [Link](value == 7);
} else |err| {
_ = err;
unreachable;
}
}

Die durch || eingerahmten Variablen hinter dem if und else werden als Capture bezeichnet.
Sie „fangen“ jeweils den zum Zweig gehörenden Wert des Error-Typs.
Evaluiert der Ausdruck (im obigen Fall ist dies lediglich die Variable a ) zu einem Error, so wird
der else -Zweig betreten und der Error wird an err gebunden. Andernfalls wird der If-Zweig
betreten und der Wert (in diesem Beispiel 7 vom Typ u32 ) wird an value gebunden. Die
Namen der Captures sind, nach den Syntax-Regeln für Variablen, frei wählbar. Wird ein Capture
nicht benötigt, so kann anstelle eines Namen auch ein _ verwendet werden.
Im Kontrast zu catch entpackt ein if den Wert eines Ausdrucks nicht automatisch, sondern
bindet ihn lediglich an ein Capture. Das Verhalten von catch lässt sich jedoch auch mit if
reproduzieren:

chapter04/[Link]
test "error capture #2" {
const a: anyerror!u32 = 7;
const value = if (a) |value| value else |_| {
unreachable;
};
try [Link](value == 7);
}

Das im obigen Beispiel zu sehende unreachable hilft bei der Code-Optimie-

rung. Es sagt aus, dass der Zweig nicht erreicht werden kann. Wenn Sie
unreachable verwenden müssen Sie sich absolut sicher sein, dass dies auch
zutrifft! Für den gegebenen Fall ist dies trivial, da a immer den Wert 7 hält.

If mit Optionals
Analog zu Errors kann mit if auch auf null getestet werden. Während bei Errors der else -
Zweig Pflicht ist, kann dieser für Optionals auch weggelassen werden.

chapter04/[Link]

104
Zig Basics

test "optionals capture #1" {

const a: ?u32 = 7;
if (a) |value| {
try [Link](value == 7);
} else {
// Mach etwas falls `a == null`
}
}

Evaluiert der gegebene Ausdruck (im obigen Beispiel die Variable a ) zu null , so wird der else
-Zweig ausgeführt, falls dieser vorhanden ist. Andernfalls wird der If-Zweig ausgeführt und der
entpackte Wert an den Capture value gebunden.

Pointer-Capture
Durch Pointer-Capture können, bei der Verwendung von if mit Errors oder Optionals, die
Werte einer Variable modifiziert werden. Dabei ist das Capture ein Zeiger auf die ursprüngliche
Variable.

chapter04/[Link]
test "optionals with pointer-capture #1" {
var a: ?u32 = 7;
if (a) |*value| {
try [Link](value.* == 7);
value.* += 1;
}
try [Link](a == 8);
}

Switch
Während bei If-Statements der Zweig basierend auf einem Boolean ( true ) ausgewählt wird,
verwenden Switch-Statements einen Musterabgleich (engl. Pattern-Matching). Hierfür wird ein
Wert, mit einem oder mehreren Werten des selben Typs, verglichen. So lässt sich zum Beispiel
überprüfen, ob ein Integer in einem bestimmten Wertebereich liegt.
Jedes Switch-Statement beginnt mit dem Schlüsselwort switch gefolgt von einem Ausdruck
in runden Klammern. Der Wert dieses Ausdrucks wird mit einem oder mehreren Mustern
verglichen, die jeweils einen Zweig darstellen. Die Zweige werden in geschweiften Klammern zu-
sammengefasst und bestehen aus Muster => {} oder Muster => Ausdruck , jeweils getrennt
durch ein Komma.

chapter04/[Link]

105
 Switch

const std = @import("std");

test "basic switch statement" {

const a: u64 = 7;
var b: u64 = 5;

switch (b) {
// Jeder Zweig kann aus einem einzigen Wert bestehen.
1 => b += a,
// Mehrere Wert können mit `,` verknüpft werden.
2, 3, 4, 5, 6 => b *= a,
// Auf der Rechten Seite des `=>` kann neben einem
// Ausdruck auch ein Block stehen.
7 => {
b -= a;
},
// Als Muster für einen Zweig können beliebige Ausdrücke
// verwendet werden, solange diese zur Kompilierzeit
// bekannt sind!
blk: {
const x = 5;
const y = 3;
break :blk x + y;
} => b /= a,
// Der `else`-Zweig deckt alles bisher nicht abgedeckte ab.
else => b = a,
}

try [Link](@as(u64, 35), b);

}

Wichtig ist, dass bei einem switch alle möglichen Fälle abgedeckt sein müssen. Ist dies nicht
möglich oder zu aufwendig kann ein else -Zweig verwendet werden, der alle bisher nicht
abgedeckten Möglichkeiten abdeckt. Sollten nicht alle möglichen Fälle abgedeckt werden, so
resultiert dies in einem Fehler während des Kompilierens.

Jeder Fall eines switch steht für sich alleine, das heißt es muss nicht explizit aus
dem switch „ausgebrochen“ werden. Dies steht im Kontrast zu Sprachen, wie
etwa C, bei denen, von oben nach unten, durch die einzelnen Fälle durchgefallen
werden kann, das heißt solange nicht das Ende des switch erreicht ist, wird in
C der nächste Switch-Case ausgeführt.

Genau wie bei else kann auch ein switch als Ausdruck verwendet werden.

chapter04/[Link]

106
Zig Basics

test "basic switch expression" {

const a: u64 = 7;
var b: u64 = 5;

b = switch (b) {
// `b + a` ist ein Ausdruck, dessen Resultat, falls der Zweig
// ausgewählt wird, als Resultat des `switch`-Ausdrucks verwendet
// wird.
1 => b + a,
2, 3, 4, 5, 6 => b * a,
// Durch die Verwendung eines Labels (in diesem Fall `blk`). kann
// das Ergebnis von `b - a` aus dem Block herausgereicht werden.
7 => blk: {
break :blk b - a;
},
blk: {
const x = 5;
const y = 3;
break :blk x + y;
} => b / a,
else => a,
};

try [Link](@as(u64, 35), b);

}

Genau wie alle anderen Ausdrücke auch, wird switch mit einem Semilkolon abgeschlossen. Bei
der Verwendung eines switch als Ausdruck ist wichtig, dass alle Zweige einen Rückgabewert
besitzen und dass die Rückgabewerte aller Zweige vom selben Typ ist, bzw. in einen gemein-
samen Typ konvertiert werden kann. Dies schließt die Verwendung von null mit ein.
Mit Switch-Cases kann ebenfalls überprüft werden, ob ein Wert in einem bestimmten Wertebe-
reich liegt. Wertebereiche werden durch einen Start- und Endwert eingegrenzt, der entweder
inklusive ( start...end ) oder exklusive ( start..end ) angegeben werden kann.

[Link]
fn encode(out: anytype, head: u8, v: u64) !void {
switch (v) {
0x00...0x17 => {
try [Link](head | @as(u8, @intCast(v)));
},
0x18...0xff => {
try [Link](head | 24);
try [Link](@as(u8, @intCast(v)));
},

107
 0x0100...0xffff => try cbor.encode_2(out, head, v),
0x00010000...0xffffffff => try cbor.encode_4(out, head, v),
0x0000000100000000...0xffffffffffffffff => try cbor.encode_8(out,
head, v),
}
}

Das obige Beispiel ist Teil eines CBOR-Parsers47, implementiert in Zig. Der Code ist dafür
verantwortlich, einen Wert v so klein wie möglich zu kodieren. Hierfür wird, anhand des Wer-
tebereichs, geprüft, wie viele Bytes zur Kodierung benötigt werden. Die Wertebereiche werden
in diesem Beispiel inklusive angegeben. Liegt v zum Beispiel zwischen 0 und 23 (beide Werte
eingeschlossen), so wird exakt ein Bytes zur Kodierung verwendet.

While-Schleifen
While-Schleifen führen eine Code-Block wiederholt aus, bis eine Bedingung zu false evaluiert.

For-Schleifen
Es kann äußerst nützlich sein über den Inhalt eines Arrays oder Slices zu iterieren. Eine
Möglichkeit dies zu tun ist mit Hilfe einer For-Schleife.

chapter02/[Link]
const names = [_][]const u8{ "David", "Franziska", "Sarah" };

for (names) |name| {

[Link]("{s}", .{name});
}

Eine for-Schleife beginnt mit dem Schlüsselwort for , gefolgt von einer Sequenz, über die iteriert
werden soll, in runden Klammern. Danach wird ein Bezeichner zwischen zwei | | angegeben.
Dem Bezeichner wird für jede Iteration der aktuelle Wert zugewiesen, d.h. für das obige Beispiel
wird im ersten Schleifendurchlauf name der Wert "David" zugewiesen, im zweiten Durchlauf
"Franziska" und so weiter. Nachdem über alle Elemente iteriert wurde, wird automatisch aus
der Schleife ausgebrochen.
Eine Besonderheit von Zig ist, dass innerhalb einer for-Schleife simultan über mehrere Sequen-
zen iteriert werden kann.

47 [Link]

108
Zig Basics

for (names, 0..) |name, i| {

[Link]("{s} ({d})", .{ name, i });
}

Die Sequenzen werden, getrennt durch ein Komma, innerhalb der runden Klammer angegeben.
Selbes gilt für die Bezeichner, an die die einzelnen Werte der Sequenzen gebunden werden. Im
obigen Beispiel wird als zweite Sequenz 0.. angegeben, d.h. eine Sequenz von Ganzzahlen
beginnend bei 0. Zig sorgt dabei automatisch dafür, dass names und 0.. über die selbe Länge
verfügen, indem das Ende von 0.. automatisch bestimmt wird, d.h. für das gegebene Beispiel
ist 0.. äquivalent zu 0..3 .
Sollten Sie über mehrere Arrays bzw. Slices gleichzeitig iterieren, so müssen sie sicherstellen,
dass alle die selbe Länge besitzen!

const dishes = [_][]const u8{ "Apfelstrudel", "Pasta", "Quiche" };

for (names, dishes) |name, dish| {

[Link]("{s} likes {s}", .{ name, dish });
}

Mit dem Schlüsselwort break kann aus einer umschließenden Schleife ausgebrochen werden,
d.h. das Programm wird unter der Schleife fortgeführt.

for (1..5) |i| {

[Link]("{d}", .{i});
if (i == 2) break;
}

Mit dem Schlüsselwort continue können sie den restlichen Körper der Schleife überspringen
und mit der nächsten Iteration beginnen. Sollten continue in der letzten Iteration der Schleife
ausgeführt werden, so wird aus dieser ausgebrochen.

for (1..5) |i| {

if (i == 2) continue;
[Link]("{d}", .{i});
}

Schleifen können auch geschachtelt werden. Wenn Sie innerhalb einer der inneren Schleifen, aus
einer der Äußeren ausbrechen wollen, müssen Sie sogenannte Label verwenden, mit der sie einer
bestimmten Schleife einen Namen geben können. Labels kommen vor dem for Schlüsselwort
und enden immer mit einem : . Sie können sowohl mit break als auch continue verwendet
werden.

109
 outer: for (names) |name| {
for (dishes) |dish| {
[Link]("({s}, {s})", .{ name, dish });
// Da wir an dieser stelle aus der äußeren Schleife ausbrechen
// ist nur eine Ausgabe auf der Kommandozeile zu sehen.
break :outer;
}
}

Zig erlaubt auch die Verwendung von for-Loops in Ausdrücken.

const pname = outer: for (names) |name| {

if ([Link] > 0 and (name[0] == 'p' or name[0] == 'P'))
break :outer name;
} else blk: {
break :blk "no name starts with p!";
};
[Link]("found: {s}", .{pname});

In diesem Beispiel suchen wir nach einem Namen der mit dem Buchstaben P bzw. p beginnt.
Sollte aus der Schleife mit break ausgebrochen werden, so wird der else Block nicht ausge-
führt. Da names keinen solchen Namen beinhaltet wird der else Block aufgerufen und der
String "no name starts with p!" der Konstanten pname zugewiesen.
Neben Schleifen können auch if / else Blöcken Label zugewiesen werden. Dies erlaubt es,
mittels break , Werte aus dem Block heraus zu reichen, wie oben zu sehen ist.
Sie können das Beispiel mit zig build-exe chapter02/[Link] && ./loop compilieren und
ausführen.

110