Cours de programmation Zig

Leçon 1 • Les bases du système de construction Zig

Présente la commande zig build, les fichiers build.zig et les cibles de compilation. Relie les connaissances de la chaîne d'outils à la création pratique de projets.

Leçon 2 • Installation et configuration de Zig

Guide l'installation de la chaîne d'outils Zig sur les principaux systèmes d'exploitation et configure la prise en charge des éditeurs. Assure un environnement de construction reproductible dès le premier jour.

Leçon 3 • Philosophie de conception et objectifs de Zig

Couvre les principes fondamentaux de Zig : aucun flux de contrôle caché, aucune allocation cachée et une conception privilégiant la compilation à la compilation. Donne le contexte de chaque décision prise tout au long du cours.

Leçon 1 • Opérateurs et expressions

Passe en revue les opérateurs arithmétiques, binaires, de comparaison et logiques avec leur comportement de débordement. Relie la sémantique des opérateurs à la garantie de comportement défini de Zig.

Leçon 2 • Types primitifs et inférence de types

Couvre les entiers, les flottants, les booléens et les types comptime_int/comptime_float. Explique comment Zig infère les types et quand une annotation explicite est requise.

Leçon 3 • Optionnels et unions d'erreurs

Présente les types optionnels ?T et les types d'union d'erreurs !T comme outils de flux de contrôle de première classe. Prépare les étudiants au modèle de gestion des erreurs de Zig présenté au chapitre suivant.

Leçon 4 • Variables, constantes et mutabilité

Distingue var de const et explique l'approche de Zig par défaut pour l'immuabilité. Renforce le contrôle explicite sur la mutation des données.

Leçon 1 • Structures et méthodes

Définit les types de structure, l'accès aux champs et la syntaxe des méthodes en utilisant la convention du paramètre self. Montre comment les structures servent de mécanisme d'encapsulation principal de Zig.

Leçon 2 • Définir et appeler des fonctions

Couvre la syntaxe des fonctions, le passage de paramètres, les types de retour et les fonctions inline. Établit la base de toute abstraction dans les chapitres suivants.

Leçon 3 • Énumérations et unions étiquetées

Enseigne la déclaration d'énumération, les méthodes sur les énumérations et les unions étiquetées pour les types somme. Se connecte à la correspondance exhaustive switch couverte au chapitre précédent.

Leçon 1 • Slices et tableaux

Distingue les tableaux de taille fixe des slices dynamiques et explique la sémantique des pointeurs larges. Se connecte aux modèles d'itération sécurisée présentés au chapitre 2.

Leçon 2 • Modèles de sécurité mémoire

Couvre defer pour le nettoyage, les conventions de propriété et l'évitement des utilisations après libération. Renforce la philosophie de Zig d'une gestion de mémoire explicite et vérifiable.

Leçon 3 • Pointeurs et types de pointeurs

Couvre les pointeurs sur un élément, les pointeurs sur plusieurs éléments et les pointeurs const avec leur syntaxe. Construit des modèles mentaux précis avant d'introduire l'allocation sur le tas.

Leçon 4 • L'interface d'allocateur

Explique l'interface std.mem.Allocator et pourquoi Zig passe les allocateurs explicitement. Établit le modèle utilisé par toutes les structures de données de la bibliothèque standard.

Leçon 1 • Plongée approfondie dans l'évaluation comptime

Explore comment Zig évalue les blocs comptime, les variables comptime et les boucles comptime. Développe l'intuition sur ce qui s'exécute à la compilation par rapport à l'exécution.

Leçon 2 • Réflexion de type avec @typeInfo

Utilise @typeInfo, @TypeOf et @typeName pour inspecter les types à la compilation. Permet d'écrire du code qui s'adapte à des dispositions arbitraires de structures ou d'énumérations.

Leçon 3 • Fonctions et types génériques

Montre comment écrire des fonctions et des structures paramétrées par des arguments de type comptime. Se connecte aux connaissances sur les structures et les fonctions du chapitre 3.

Leçon 4 • Chaînes comptime et génération de code

Utilise comptime pour générer des champs de structure, des tables de répartition et des API basées sur des chaînes. Présente des modèles de métaprogrammation courants dans les bibliothèques de sérialisation et RPC.

Leçon 1 • try, catch et errdefer

Présente try pour la propagation, catch pour la gestion locale et errdefer pour le nettoyage en cas d'échec. Relie la gestion des erreurs aux modèles de sécurité mémoire du chapitre 4.

Leçon 2 • Paniques, assertions et code inaccessible

Explique @panic, std.debug.assert et unreachable pour l'application des invariants. Distingue les erreurs récupérables des bogues de programmation.

Leçon 3 • Ensembles d'erreurs et unions d'erreurs

Définit des ensembles d'erreurs nommés, des ensembles d'erreurs inférés et des types de retour d'union d'erreurs. Établit le vocabulaire pour tous les modèles de gestion des erreurs de ce chapitre.

Leçon 1 • Tests avec std.testing

Utilise std.testing.expect, expectEqual et expectError pour écrire des tests unitaires. Établit un flux de travail piloté par les tests pour tout le travail de projet ultérieur.

Leçon 2 • Concurrence avec threads et atomiques

Présente std.Thread, les mutex et les opérations atomiques pour la concurrence à état partagé. Prépare les étudiants aux tâches de programmation système nécessitant du parallélisme.

Leçon 3 • Gestion des chaînes et Unicode

Explique le modèle de chaîne en slice d'octets de Zig, l'itération UTF-8 et le formatage std.fmt. Aborde les pièges courants lors du travail avec des données textuelles.

Leçon 4 • Opérations E/S et système de fichiers

Couvre les lecteurs et rédacteurs std.io, l'ouverture, la lecture et l'écriture de fichiers. Relie les modèles d'allocateur du chapitre 4 aux flux E/S tamponnés.

Leçon 1 • Cibles embarquées et autonomes

Configure Zig pour les cibles autonomes, désactive la bibliothèque standard et écrit le code de démarrage. Montre l'adéquation de Zig pour le développement bare-metal et embarqué.

Leçon 2 • Appel de C depuis Zig

Couvre @cImport, la traduction d'en-têtes C et la liaison avec des bibliothèques C. Permet la réutilisation du vaste écosystème C à partir de projets Zig.

Leçon 3 • Exposition de Zig à C

Enseigne export, extern et la compatibilité ABI C pour la construction de bibliothèques Zig consommées par C. Complète le tableau de l'interopérabilité bidirectionnelle.

Leçon 4 • Compilation croisée et déploiement

Utilise le compilateur croisé intégré de Zig pour cibler plusieurs architectures à partir d'un seul hôte. Produit des binaires optimisés et liés statiquement prêts pour le déploiement.