CUne ABI est le contrat binaire entre parties compilées séparément : convention d’appel, taille et alignement des types, disposition des structures et représentation des données. La norme C ne fixe aucune ABI unique ; des options, empaquetages ou conventions incompatibles peuvent corrompre arguments et mémoire.
Intermédiaire · C23CL’architecture sépare les responsabilités entre interfaces d’en-tête, implémentations par unités de traduction et règles explicites de propriété des données. Les frontières doivent limiter les dépendances et masquer l’état ; état global et cycles compliquent tests, initialisation et libération sûre.
Intermédiaire · C23CLa concurrence en C repose sur threads, mutex, variables de condition et objets atomiques, tandis qu’un gestionnaire de signal asynchrone ne peut effectuer qu’un ensemble bien plus restreint d’opérations. Il y a course de données lorsque deux actions conflictuelles appartiennent à des threads différents, qu’au moins l’une n’est pas atomique et qu’aucune ne happens-before l’autre ; le comportement est indéfini. `volatile` ne remplace ni atomique ni verrou.
Intermédiaire · C23CLa recherche binaire réduit de moitié, à chaque étape, une plage de recherche triée. L’exemple implémente la lower bound : l’indice du premier élément qui n’est pas inférieur à la clé, ou n s’il n’y en a pas. Il aborde les doublons, l’entrée vide et le calcul sûr du milieu.
Intermédiaire · C23; repository compiler flag, production runtime not attestedCLes opérations bit à bit portent sur les représentations entières ; les types non signés sont les plus sûrs pour les masques. `CHAR_BIT` donne le nombre de bits d’un octet ; un décalage négatif ou au moins égal à la largeur de l’opérande gauche promu est indéfini, et décaler une valeur signée négative exige aussi de la prudence.
Intermédiaire · C23CC ne possède pas de conteneurs dynamiques standard : une collection se construit avec tableaux, structures, pointeurs et longueur ou capacité stockée explicitement. Toute opération doit préserver `length <= capacity`, les bornes d’indice et la propriété du tampon ; une croissance par `realloc` exige un pointeur temporaire pour ne pas perdre l’allocation initiale en cas d’échec.
Intermédiaire · C23CC accepte les commentaires de bloc `/* ... */` et de ligne `// ...` ; ils disparaissent lors d’une phase précoce de traduction et les blocs ne s’imbriquent pas. La documentation doit décrire contrats et raisons plutôt que répéter le code évident.
Intermédiaire · C23C`if` choisit une branche selon une valeur scalaire : zéro et pointeur nul sont faux, les autres valeurs vraies ; `switch` compare une valeur entière promue aux étiquettes `case`. `&&` et `||` court-circuitent, mais les effets de bord dans les conditions masquent le séquencement.
Intermédiaire · C23CUn pipeline de données C est une suite explicite de lecture, validation, transformation, agrégation et écriture, avec tampons et codes d’erreur entre fonctions. Chaque étape doit préciser propriété mémoire, tailles admises et résultats partiels afin qu’un échec ne laisse pas d’état incohérent.
Intermédiaire · C23CUne déclaration associe identificateur, type, portée et liaison ; une définition fournit en plus l’objet ou le corps de fonction. `extern` peut viser une définition d’une autre unité, `static` au niveau fichier donne une liaison interne, et un déclarateur complexe se lit depuis le nom vers l’extérieur.
Intermédiaire · C23CLa recherche en profondeur (DFS) explore la branche suivante d’un graphe avant de revenir aux autres voisins. L’exemple présente un parcours récursif, le marquage des sommets visités et un ordre d’affichage déterministe.
Intermédiaire · C23; repository compiler flag, production runtime not attestedCC n’a pas d’exceptions : une fonction signale l’échec par retour, paramètre de sortie, état de flux ou `errno` seulement si son contrat le prévoit. Il faut tester ce signal avant le résultat, préserver `errno` si nécessaire, libérer les ressources partielles et ne pas confondre toute valeur limite avec une erreur.
Intermédiaire · C23CUne expression calcule une valeur et peut produire des effets de bord ; priorité et associativité fixent le groupement, pas en général l’ordre d’évaluation. Promotions entières, conversions arithmétiques usuelles et séquencement comptent, car des modifications non séquencées du même objet peuvent être indéfinies.
Intermédiaire · C23CLe filtrage conserve les éléments satisfaisant un prédicat et la transformation produit une nouvelle valeur par élément ; en C, il s’agit généralement de boucles explicites ou de fonctions à rappel. Taille de sortie, traitement en place, chevauchement et échec doivent appartenir au contrat.
Intermédiaire · C23CUn automate modélise les états permis par un `enum` et les événements par des transitions validées ; chaque paire état-événement doit donner un état suivant ou une erreur. Valeur non traitée, chute involontaire dans `switch` ou changement avant réussite d’un effet produit une transition invalide.
Intermédiaire · C23CUne fonction possède un type de résultat et des paramètres typés ; les arguments passent par valeur, donc modifier l’objet appelant exige un pointeur valide. Un prototype compatible doit être visible, la récursion exige un cas terminal et un pointeur renvoyé ne doit pas viser un objet automatique expiré.
Intermédiaire · C23CUne expression `_Generic` choisit une association selon le type de l’expression de contrôle sans évaluer celle-ci ; valeur et type viennent de l’expression choisie. La liste ne peut contenir deux types compatibles, une seule association peut correspondre et l’absence de correspondance exige `default` ; vérifier les règles de qualification et conversion de la version C.
Intermédiaire · C23CLes E/S standard utilisent des objets `FILE` avec mode, position et indicateurs d’erreur/fin ; le nombre d’éléments traités fait partie du résultat. Sérialisation texte ou binaire exige contrôle de taille, codage, ordre des octets et E/S courtes ; une donnée externe ne doit jamais devenir chaîne de format.
Intermédiaire · C23CC ne définit ni générateur ni protocole d’itérateur ; on modélise donc l’itération par une paire pointeur-fin ou une structure curseur avec fonction `next`. Le contrat doit distinguer fin et erreur, garder la collection vivante pendant le parcours et interdire le déréférencement du curseur final.
Intermédiaire · C23CLa recherche linéaire examine les éléments dans l’ordre et s’arrête au premier résultat ; pour `n` éléments, elle effectue au plus `n` comparaisons, soit O(n) et un espace constant. Le résultat doit distinguer l’indice zéro de l’absence, et la comparaison respecter type et validité.
Intermédiaire · C23CUne LIS est la plus longue sous-séquence strictement croissante qui conserve l’ordre d’entrée sans exiger que les éléments soient adjacents. L’exemple en C calcule sa longueur par programmation dynamique en O(n²) temps et avec O(n) mémoire auxiliaire.
Intermédiaire · C23; repository compiler flag, production runtime not attestedCLes boucles `for`, `while` et `do` répètent une instruction tant qu’une condition scalaire est vraie ; `break` quitte la boucle la plus proche et `continue` passe à l’itération suivante. Les bornes doivent éviter dépassement de tableau et compteur, et la condition garantir un progrès même avec une entrée vide.
Intermédiaire · C23CC exige une propriété explicite : objet automatique jusqu’à la fin du bloc, statique pendant le programme, allocation dynamique du succès jusqu’à un unique `free`. Copier les octets ne copie pas les ressources pointées, un chevauchement exige `memmove`, et utilisation après libération, double libération ou hors objet sont indéfinies.
Intermédiaire · C23CC23 organise encore surtout les programmes avec en-têtes et fichiers sources traduits séparément : l’en-tête expose les déclarations et une unité fournit chaque définition externe. Les gardes évitent les répétitions, `static` cache les détails et des déclarations incompatibles entre unités violent le contrat.
Intermédiaire · C23