Présentation du langage C

C (ANSI C99 / C11) — langage système | durée d'exécution minimale | mémoire manuelle | contrôle maximal

Paradigme

Impératif, procédural. Typage statique avec système de types faible (conversions implicites, void*). Compilation via préprocesseur → compilateur → assembleur → éditeur de liens. Compilation en un seul passage, basée sur les unités de traduction.

Espèces

Catégorie Espèces Taille (typique)
char char 1 octet
Signé en entier signed char short int long long long 1, 2, 4, 8, 8 octets
Entier non signé unsigned char unsigned short unsigned int unsigned long unsigned long long 1, 2, 4, 8, 8 octets
Flotteur float double long double 4, 8, 8-16 octets
Booléen (C99) _Bool / bool (via <stdbool.h>) 1 octet
Vide void 0 (incomplet)
Pointeur T* 8 octets (64 bits)
Tableau T[N] T[] N * taille de (T)
Structure struct Name { ... } Somme des champs + remplissage
Syndicat union Name { ... } Max de champs
Énumération enum Name { ... } taille de (int)
Pointeur de fonction T (*)(args) 8 octets

Modificateurs de type

const volatile restrict (C99) inline (C99)

Spécificateurs de classe de stockage

auto register static extern _Thread_local (C11)

Déclarations

Construire Syntaxe Remarques
Fonction T name(params) { body }
Prototype T name(params); Déclaration sans corps
Variable T x = expr;
Plusieurs T x, y, z;
Constante const T x = expr;
Constante d'énumération enum { VAL = expr };
Typedef typedef T Alias;
Structure struct Name { T field; };
Syndicat union Name { T field; };
Externe extern T name; Défini dans une autre UT
Statique static T name; Lien interne

Flux de contrôle

Construire Syntaxe Remarques
Si if (cond) { ... } else { ... } Une déclaration, pas une expression
Tandis que while (cond) { ... }
Faire pendant do { ... } while (cond);
Pour for (init; cond; incr) { ... }
Changer switch (expr) { case N: ... break; } Chute par défaut
Pause break; Quitter loop/switch
Continuer continue; Passer à l'itération suivante
Aller à goto label; Dans la fonction uniquement
Retour return expr;

Opérateurs (priorité, du plus haut au plus bas)

Priorité Opérateurs Association
1 () [] . -> ++ -- (suffixe) Gauche
2 ++ -- (préfixe) + - ! ~ * & sizeof _Alignof À droite
3 (type) (moulage) À droite
4 * / % Gauche
5 + - Gauche
6 << >> Gauche
7 < > <= >= Gauche
8 == != Gauche
9 & Gauche
10 ^ Gauche
11 | Gauche
12 && Gauche
13 || Gauche
14 ? : (ternaire) À droite
15 = += -= *= /= %= &= ^= |= <<= >>= À droite
16 , (opérateur virgule) Gauche

Préprocesseur

Directive Objectif
#include "file" / <file> Inclusion textuelle
#define MACRO body Macro de type objet
#define MACRO(args) body Macro de type fonction
#undef MACRO Supprimer la macro
#if expr / #ifdef MACRO / #ifndef MACRO Compilation conditionnelle
#elif expr / #else / #endif Autres succursales
#error "message" Erreur de compilation
#pragma Défini par l'implémentation
#line N "file" Contrôle de ligne
## (collage de jeton) Concaténer des jetons
# (stringifier) Convertir en chaîne littérale

Macros prédéfinies (C99)

__LINE__ __FILE__ __DATE__ __TIME__ __STDC__ __STDC_VERSION__ __func__

Mémoire

Fonctionnement Syntaxe En-tête
Allouer malloc(n) <stdlib.h>
Allocation alignée (C11) aligned_alloc(a, n) <stdlib.h>
Calloc calloc(n, size) <stdlib.h>
Réaffectation realloc(p, n) <stdlib.h>
Gratuit free(p) <stdlib.h>
Copier memcpy(dst, src, n) <string.h>
Déplacer (sans chevauchement) memmove(dst, src, n) <string.h>
Ensemble memset(p, c, n) <string.h>
Comparez memcmp(a, b, n) <string.h>
Pile alloca(n) (non standard) <alloca.h>

Bibliothèque standard (sélectionnée)

<stdio.h>

printf scanf fopen fclose fread fwrite fprintf sprintf fgets fputs feof ferror remove rename tmpfile

<stdlib.h>

atoi atof strtol strtod rand srand abs qsort bsearch system getenv exit abort atexit

<string.h>

strlen strcpy strncpy strcat strncat strcmp strncmp strchr strrchr strstr strtok memset memcpy memmove memcmp

<math.h>

sin cos tan asin acos atan atan2 sqrt pow exp log log10 fabs ceil floor fmod fma

<time.h>

time clock difftime mktime strftime localtime gmtime

<assert.h>

assert(expr)

<stdint.h> (C99)

int8_t int16_t int32_t int64_t uint8_t uint16_t uint32_t uint64_t intptr_t uintptr_t size_t

<stdbool.h> (C99)

bool true false

Compilation

Étape Commande Sortie
Prétraitement cpp file.c > file.i Source étendue
Compiler cc -S file.c Assemblage (file.s)
Assembler cc -c file.c Objet (file.o)
Lien cc file.o -o prog Exécutable (prog)
Tout-en-un cc file.c -o prog Exécutable direct

Drapeaux communs

-O0 -O1 -O2 -O3 -Os -g -Wall -Wextra -Wpedantic -std=c99 -std=c11 -DNAME=val -Ipath -Lpath -llib

Chaîne d'outils

GCC (GNU), Clang/LLVM, MSVC (Windows), TinyCC, CompCert

Durée de stockage

Durée Allocation Durée de vie
Automatique Pile Portée
Statique Segment de données Durée de vie du programme
Thread-local (C11) TLS Durée de vie du fil
Alloué Tas (malloc/free) Manuel

Lien

Mot clé Lien Visibilité
(aucun, portée du fichier) Externe Programme complet
static (portée du fichier) Interne Unité de traduction actuelle
extern Externe Programme complet
static inline (C99) Interne TU actuelle (pas de hors-ligne)

Comportement non défini (pièges sélectionnés)

C99 contre C11 contre C17 contre C23

Norme Ajouts clés
C89/ANSI C Norme d'origine
C99 // commentaires, stdint.h, bool, restrict, inline, macros variadiques, initialiseurs désignés, littéraux composés, for-déclarations de portée
C11 _Generic, _Static_assert, _Alignas, _Alignof, _Atomic, _Thread_local, anonyme structs/unions, noreturn, interfaces à limites vérifiées (Annexe K)
C17 Version de correction de bugs (pas de nouvelles fonctionnalités)
C23 (projet) typeof, nullptr, #embed, bool comme mot-clé, static_assert sans _, constexpr, auto pour l'inférence de type

Expressions idiomatiques courantes en C

Pointeur opaque (encapsulation)

// header
typedef struct Handle Handle;
Handle* handle_create(void);
void handle_destroy(Handle*);

// implementation
struct Handle { int fd; };

Rappel (pointeur de fonction)

void sort(int* arr, int n, int (*cmp)(int, int));

Orienté objet (vtable manuelle)

struct Vtable { void (*draw)(void*); };
struct Shape { struct Vtable* vtable; };

Générique (void* + pointeur de fonction)

void qsort(void* base, size_t n, size_t size,
           int (*cmp)(const void*, const void*));