# Chapitre 1 — Normes du langage C

## 1.1 Qu’est-ce qu’une norme

Une norme est un document officiel.  
Elle définit comment un langage doit fonctionner.  

Dans le cas du C, la norme décrit :
- la syntaxe  
- les types  
- le comportement des instructions  
- la bibliothèque standard  

Une norme permet d’assurer la compatibilité.  

Un programme conforme à la norme doit fonctionner sur plusieurs plateformes.  

Sans norme, chaque compilateur ferait différemment.  

---

### Exemple 1 — Code conforme à la norme

```c
#include <stdio.h>

int main(void)
{
    // Code standard, portable
    printf("Hello\n");

    return 0;
}
```

---

### Exemple 2 — Code non portable

```c
#include <stdlib.h>

int main(void)
{
    // Fonction dépendante du système
    system("pause");

    return 0;
}
```

---

### Exemple 3 — Extension compilateur

```c
int main(void)
{
    // Extension GCC non standard
    int x = ({ int a = 5; a + 2; });

    return x;
}
```

---

## 1.2 ANSI C / C89 / C90

Première norme officielle en 1989.  

Elle pose les bases du langage.  

---

### Exemple — Style C89

```c
#include <stdio.h>

int main(void)
{
    int a; // Déclaration en début de bloc obligatoire en C89
    a = 5;

    printf("%d\n", a);

    return 0;
}
```

---

## 1.3 C95

C95 est une mise à jour mineure.  

Elle ajoute :
- support des caractères larges  
- améliorations de la bibliothèque  

Peu d’impact direct pour un débutant.  

---

## 1.4 C99

C99 est une évolution importante.  

Elle apporte :
- déclaration de variables n’importe où  
- nouveaux types (`long long`)  
- type booléen (`_Bool`)  
- tableaux de taille variable (VLA)  

---

### Exemple — Déclaration flexible (C99)

```c
#include <stdio.h>

int main(void)
{
    int a = 5;

    // Déclaration autorisée au milieu du code
    int b = 10;

    printf("%d\n", a + b);

    return 0;
}
```

---

### Exemple — Booléen

```c
#include <stdio.h>
#include <stdbool.h>

int main(void)
{
    bool ok = true;

    if (ok)
    {
        printf("OK\n");
    }

    return 0;
}
```

---

## 1.5 C11

C11 introduit des fonctionnalités modernes.  

Par exemple :
- threads standard  
- opérations atomiques  
- alignement mémoire  
- assertions à la compilation  

---

### Exemple — Static assert

```c
_Static_assert(sizeof(int) >= 2, "int trop petit");
```

---

### Notion d’atomiques

Une opération atomique est indivisible.  

Elle ne peut pas être interrompue.  

Sans atomique, deux threads peuvent modifier une variable en même temps.  

---

### Exemple — problème sans atomique

```c
int compteur = 0;

// Deux threads
compteur = compteur + 1;
```

---

### Exemple — avec atomique

```c
#include <stdatomic.h>

int main(void)
{
    atomic_int compteur = 0;

    compteur++;

    return 0;
}
```

---

## 1.6 C17 / C18

Version corrective.  

Corrige des défauts de la norme précédente.  

Pas de nouvelles fonctionnalités majeures.  

---

## 1.7 C23

C23 est la version la plus récente.  

Elle modernise le langage et corrige des incohérences.  

---

### Nouveautés importantes

- nouveaux mots-clés  
- amélioration des types  
- nettoyage de comportements historiques  
- amélioration des attributs  

---

### Exemple — nullptr

```c
int main(void)
{
    int *p = nullptr; // C23

    return 0;
}
```

---

### Exemple — attribut

```c
[[maybe_unused]] int x;
```

---

### Remarque

C23 ne change pas la philosophie du C.  
Il améliore la cohérence et la sécurité.  

---

## 1.8 Différences entre versions

- C89 → base  
- C99 → modernisation  
- C11 → concurrence  
- C17 → corrections  
- C23 → nettoyage  

---

## 1.9 Choisir une norme

```bash
gcc -std=c89 main.c
gcc -std=c99 main.c
gcc -std=c11 main.c
gcc -std=c17 main.c
```

---

## 1.10 Extensions de compilateur

Les extensions ne font pas partie du standard.  

Elles peuvent être utiles.  
Mais elles réduisent la portabilité.  

---

### Exemple — extension GNU

```c
int main(void)
{
    int x = ({ int a = 10; a * 2; });

    return x;
}
```