Comportement indéfini en C

En langage C,« comportement indéfini » (undefined behavior)désigne un comportement qui n'est pas clairement défini dans la norme du langage C, il peut donc se manifester par n'importe quel résultat.

Cela signifie que lorsqu'un programme présente un comportement indéfini, il peut produire des résultats imprévisibles, notamment des plantages de programme, une corruption de données, des vulnérabilités de sécurité, et peut même sembler s'exécuter normalement.

Le comportement indéfini est un concept important dans le langage C car il est lié à l'exactitude et à la sûreté des programmes.

Voici quelques situations courantes qui peuvent conduire à un comportement indéfini :

dépassement de tableau

Lorsque nous tentons d'accéder à un élément hors limites d'un tableau, c'est-à-dire d'accéder à un élément avant l'élément d'indice 0 ou au-delà de la longueur du tableau, le compilateur ne peut pas déterminer ce qui est stocké dans l'espace mémoire auquel on accède, ce qui provoque un comportement indéfini. Par exemple :

int arr[3] = {1, 2, 3};
printf("%d\n", arr[5]); // 越界访问，结果未定义

Déréférencement d'un pointeur nul

Lorsque nous tentons de déréférencer un pointeur nul, le compilateur ne peut pas déterminer le contenu stocké dans l'espace mémoire auquel on accède, ce qui provoque un comportement indéfini. Par exemple :

int *ptr = NULL;
printf("%d\n", *ptr); // 解引用空指针，结果未定义

Variables locales non initialisées

Lorsque nous utilisons une variable locale non initialisée, sa valeur est indéfinie, ce qui conduit à un comportement indéfini. Par exemple :

int x;
printf("%d\n", x); // x 未初始化，结果未定义

Division d'un nombre à virgule flottante par zéro

Lorsque nous tentons de diviser un nombre à virgule flottante par zéro, le résultat est indéfini. Par exemple :

float x = 1.0;
float y = x / 0.0; // 浮点数除以零，结果未定义

division entière par zéro

Lorsque nous tentons de diviser un entier par zéro, le résultat est indéfini. Par exemple :

int x = 10;
int y = x / 0; // 整数除以零，结果未定义

dépassement signé

Lorsqu'une opération sur un entier entraîne un résultat dépassant la plage représentable par le type entier, le résultat est indéfini. Par exemple :

signed char x = 127;
x = x + 1; // signed char 溢出，结果未定义

Opérande de décalage trop grand

Lors de l'exécution d'une opération de décalage, si le nombre de bits décalés est supérieur ou égal au nombre de bits de l'opérande, le résultat est indéfini. Par exemple :

int x = 1;
int y = x << 32; // 位移操作数太大，结果未定义

Conversion de type incorrecte

Lorsque nous effectuons une conversion de type non sûre, le résultat est indéfini. Par exemple :

int *ptr = (int *)malloc(sizeof(int));
float *fptr = (float *)ptr; // 错误的类型转换，结果未定义

accès mémoire hors limites

Lorsque nous écrivons des données dans une mémoire déjà libérée ou non allouée, le résultat est indéfini. Par exemple :

int *ptr = (int *)malloc(sizeof(int));
free(ptr);
*ptr = 10; // 内存越界，结果未定义

Comportement indéfini en virgule flottante

Par exemple, comparer deux valeurs NaN (Not a Number) pour vérifier leur égalité est un comportement indéfini. Par exemple :

float x = sqrt(-1);
float y = sqrt(-1);
if (x == y) {
    printf("NaN values are equal\n");
}

Autre

Il existe également d'autres comportements indéfinis :

Utilisation de fonctionnalités à virgule flottante non définies :Comportement des nombres à virgule flottante qui dépend d’un matériel ou d’une implémentation spécifique, comme la précision ou le comportement d’arrondi des nombres à virgule flottante.
Nombre d’arguments de fonction non concordant :Le nombre d’arguments fournis lors de l’appel d’une fonction ne correspond pas à la définition de la fonction, commeprintf("%s %d", "Name")。
Modification de littéraux de chaîne :Tentative de modification du contenu d’un littéral de chaîne, commechar *str = "Hello"; str[0] = 'h';。
Utilisation d’un état de programme indéfini :Dépendre d’un état de programme indéfini, comme les valeurs initiales des variables globales.
Violation des règles de syntaxe strictes :Violer les règles de grammaire strictes du langage C, comme l’utilisation d’identificateurs non déclarés.
Conditions de concurrence en multithreading :Dans un environnement multithread, l’accès non synchronisé à des ressources partagées peut entraîner un comportement indéfini.
Utilisation du comportement indéfini de fonctions de la bibliothèque standard :Le comportement de certaines fonctions de la bibliothèque standard dans des conditions spécifiques peut être indéfini, comme le comportement de fscanf() lorsqu’elle ne parvient pas à faire correspondre une entrée.

Ce sont toutes des situations qu’il faut éviter lors de la programmation, car elles peuvent amener le programme à produire un comportement imprévisible dans différents environnements, rendre le code non portable et potentiellement entraîner des erreurs de programme.

comment éviter

Pour éviter un comportement indéfini, lors du processus de développement, nous devons :

Lire attentivement et suivre la norme du langage C: Comprendre quelles opérations peuvent entraîner un comportement indéfini, et éviter ces opérations.
Utiliser des outils d’analyse statique: Ces outils peuvent aider à détecter un comportement indéfini potentiel.
Effectuez des tests approfondis: Testez différents chemins d'exécution du programme pour vous assurer qu'il s'exécute correctement dans diverses conditions.
Évitez de vous fier au comportement indéfini: Ne présumez pas qu'un comportement indéfini produira des résultats spécifiques.
Utilisez des fonctions et des bibliothèques sûres: Utilisez des fonctions bien définies fournies par la bibliothèque standard, et évitez les fonctions non standard ou dangereuses qui peuvent mener à un comportement indéfini.

Le comportement indéfini est un concept complexe et dangereux du langage C. Il exige que les développeurs comprennent en profondeur les règles du C et prennent des mesures appropriées pour l'éviter. En suivant les bonnes pratiques et en utilisant des outils appropriés, le risque de comportement indéfini peut être minimisé, ce qui améliore la fiabilité et la sécurité du programme.

autres extensions

C Bibliothèque standard