Kant1/French_Wikibooks_articles · Datasets at Hugging Face

text stringlengths 0 211k
int main(void)
unsigned char c = 300;
/* %hhu sert à dire à printf() qu'on veut afficher un unsigned char */
printf("La variable c vaut %hhu.\n", c);
c = -5;
printf("La variable c vaut %hhu.\n", c);
return 0;
Le résultat du programme est :
La variable c vaut 44.
La variable c vaut 251.
En effet, on a 300 - 256 = 44 et -5 + 256 = 251.
De même :
int main(void)
signed char c = 300;
/* %hhd sert à dire à printf() qu'on veut afficher un signed char */
printf("La variable c vaut %hhd.\n", c);
c = -300;
printf("La variable c vaut %hhd.\n", c);
return 0;
Le résultat du programme peut alors être :
La variable c vaut 44.
La variable c vaut -44.
Sur une telle machine, les types signés sont traités de la même manière que les types non signés.
Si vous essayez de compiler ces deux programmes, votre compilateur pourra détecter les débordements et vous en avertir (GCC le fait).
Réels.
Les nombres réels ne pouvant tous être représentés, sont approximés par des nombres à virgule flottante. Comme dans le cas des entiers, il existe plusieurs types de nombre à virgule flottante. En voici la liste triée par précision croissante :
La norme C90 était assez floue concernant les nombres à virgule flottante, leurs représentations, la précision des opérations, etc., ce qui fait que c'était un des domaines où la conception de programmes utilisant les nombres flottants était chose peu aisée. Le C99 a clarifié les choses en précisant qu'une implémentation C devait respecter la norme IEC 60559:1989 "Arithmétique binaire en virgule flottante pour systèmes à microprocesseur". Cette norme (dérivée de ) définit des formats de données pour les nombres à virgule flottante, ainsi que des opérations et fonctions sur ces nombres. Elle garantit, entre autres :
Elle définit de plus comment sont gérés les cas exceptionnels, comme les infinis, les "NaN" (pour "Not a Number", résultant par exemple de la division 0/0), etc.
Les types flottants du C correspondent aux type IEC 60559 de la manière suivante :
Constantes réelles.
Une suite de caractères représente une constante à virgule flottante si :
Dans le deuxième cas, le "nombre" peut être soit un entier, soit un réel du premier cas.
Les constantes sont de type codice_51 par défaut. Pour demander le type codice_53, il faut la suffixer par codice_54 ou codice_55, et pour le type codice_56 par codice_57 ou codice_34.
Arithmétique.
Une attention particulière doit être portée sur la précision des types réels. Ces différents types ne font qu'approximer l'ensemble des nombres réels, avec une précision finie. Des erreurs d'arrondis sont à prévoir, ce qui est très problématique pour des domaines qui n'en tolèrent pas (notamment pour les applications financières, il est conseillé de ne pas utiliser de calcul en virgule flottante).
Le type codice_53 en particulier a une précision minimale, qui est bien souvent insuffisante. Voici un exemple classique d'erreur à ne pas faire qui illustre les problèmes liés à la précision des types flottants :
int main(void)
float i = 0;
int j;
for (j = 0; j < 1000; j ++)
i += 0.1;
printf("i = %f\n", i);
return 0;
Le résultat est 99,999046, ce qui montre que la précision du type codice_53 est en général mauvaise, d'autant plus que le nombre 0,1 n'est pas représentable de manière exacte en binaire. Il est ainsi conseillé d'utiliser le type codice_51 à la place de codice_53 autant que possible. Dans ce cas de figure, il est préférable d'éviter les accumulations d'erreurs infinitésimales, en réécrivant le code de la manière suivante :
int main(void)
float i;
int j = 1000;
i = j * 0.1;
printf("i = %f\n", i);
return 0;
Le résultat est alors 100.0, sans aucune erreur d'accumulation et d'arrondis.
Pour plus d'informations sur ce domaine, un wikilivre Arithmétique flottante est disponible.
Caractères.
À l'origine, le type permettant de représenter un caractère est codice_1. Même si un codice_1 n'est plus toujours suffisant aujourd'hui pour représenter un caractère quelconque.
Ce type est un peu plus particulier que les autres, d'une part parce que sa taille définit l'unité de calcul pour les quantités de mémoire (et donc pour les tailles des autres types du langage) et d'autre part son domaine de valeur peut grandement varier de manière relativement inattendue.
Par définition, la taille du type codice_1, notée codice_66, vaut toujours 1. Cependant, il faut faire attention : contrairement à ce qu'on pense souvent, un codice_1 au sens du C ne vaut pas toujours un octet. Il occupera au minimum 8 bits, mais il existe des architectures, relativement spécialisées il est vrai, ayant des codice_1 de 9 bits, de 16 bits, voire plus. Même si, dans une large majorité des cas, les compilateurs utilisent des codice_1 de 8 bits, à la fois par simplicité (les machines modernes fonctionnent généralement en 8, 16, 32 ou 64 bits) et pour éviter des problèmes de portabilité de code (beaucoup de codes C existants reposent sur l'hypothèse que les codice_1 font 8 bits, et risqueraient de ne pas marcher sur une autre architecture). Par simplification, nous utiliserons donc le terme "octet" la plupart du temps dans la suite de ce wikilivre.
Un autre piège de ce type est qu'il peut être de base (c'est-à-dire implicitement) codice_10 ou codice_11, au choix du compilateur, ce qui peut s'avérer dangereux (c'est-à-dire difficile à maitriser). Considérez le code suivant :
/* Ce code peut ne pas fonctionner avec certains compilateurs */
char i;
for (i = 100; i >= 0; i --)
/* ... */
Dans cet exemple, l'instruction codice_73 permet de faire itérer les valeurs entières de codice_74 de 100 à 0, incluses. On pourrait naïvement penser optimiser en utilisant un type codice_1. Sauf que si ce type est implicitement codice_11, la condition codice_77 sera toujours vraie, et tout ce que vous obtiendrez est une boucle infinie. Normalement, tout bon compilateur devrait vous avertir que la condition est toujours vraie et donc vous permettre de corriger en conséquence, plutôt que perdre des heures en débugage.
Constantes représentant un caractère.
Une constante représentant un caractère (de type char) est délimitée par des apostrophes, comme par exemple codice_78. En fait le langage C n'a initialement pas été conçu pour utiliser tous les caractères. Le type char permet de représenter ni plus ni moins que des nombres entiers (ils sont de type codice_4, mais leur valeur tiendra dans un type codice_1), les deux étant parfaitement interchangeables. Cependant, comme dit plus haut, il ne s'agit généralement pas là des caractères Unicode que nous manipulons tous les jours, mais de caractère-octet dont la portée est réduite.
Un petit exemple :
int main(void)
printf("Sur votre machine, la lettre 'a' a pour code %d.\n", 'a');
return 0;
Le programme précédent donnera le résultat suivant dans un environnement ASCII :
Il est tout à fait autorisé d'écrire codice_81 ou codice_82.
Cette soustraction permet de convertir une minuscule ASCII en majuscule si le codage ASCII est utilisé, mais ne le permet pas si un autre codage est utilisé (comme ISO-8859-1 ou UTF-8).
Valeur des caractères-octets.
La valeur représentée par cette constante est néanmoins dépendante des conventions de codages de caractères employées. À l'origine ces conventions étaient connues du système ; aujourd'hui, même si dans une écrasante majorité des cas, on se retrouvera avec un jeu de caractères augmentant l'ASCII et donc l'ISO-646.
Le code ASCII définit 96 glyphes de caractères portant les numéros 32 à 126, bien loin des milliers de caractères nécessaires pour les logiciels fonctionnant sur la planète entière et dans de nombreuses langues. Cet ensemble est à peine suffisant pour couvrir l'anglais alors que plusieurs langues latines étaient visées à l'époque où l'ASCII et l'ISO-646 ont été définis, si bien que de nombreuses extensions sont par la suite apparues.
Par exemple le caractère « œ » (ligature du o et du e) a pour valeur :
Retenons simplement qu'Unicode est omniprésent sur Internet, mais que des logiciels plus anciens ou embarqués peuvent fonctionner avec des jeux de caractères huit bits, plus limités. Il s'agit en fait d'une problématique concernant des sujets plus vastes, comme l' "internationalisation", la "portabilité" et l' "interopérabilité".
Le langage C reste relativement abstrait à ce niveau : le type char contient généralement un octet et les chaînes, une simple suite d'octets terminée par 0. Il laisse au système et au développeur le soin d'interpréter et de traiter les octets comme il se doit. Ceci peut être fait à l'aide de bibliothèques appropriées. Si on trouve ici ou là de telles listes de bibliothèques , il est préférable de connaître le langage C avant de les utiliser.
Cet abstraction du langage C lui a permis de s'adapter aux nombreuses évolutions des conventions de codages des caractères.
Caractères non graphiques.
Certains caractères ne sont pas graphiques. Par définition, on ne peut pas donc les écrire dans un code source de manière visible.
Le langage C adopte la convention suivant pour désigner certains d'entre eux de manière littérale :
De plus, on peut écrire n'importe quelle valeur de caractère avec les expressions suivantes :
Trigramme.
Le langage C date d'une époque où le standard de codage des caractères était l'ISO-646, un standard encore plus ancien et plus incomplet que l'ASCII. Les caractères absent de l'ISO-646 pouvaient être simulés par une séquence de trois caractères.
L'ASCII s'étant répandu, cette fonctionnalité tombée en désuétude est en général à éviter, car très souvent inutile, et peut causer des bugs incompréhensibles au programmeur non averti. Néanmoins, de très rares programmes peuvent utiliser ce genre de fonctionnalités. Un trigramme est simplement une suite de trois caractères dans le code source qui sera remplacée par un seul.
Cette fonctionnalité a été ajoutée au C pour supporter les architectures (systèmes) dont l'alphabet ne dispose pas de certains caractères qui sont nécessaires dans la syntaxe du C, comme les dièses ou les accolades.
Les substitutions suivantes sont faites partout dans le code source (y compris les chaînes de caractères) :
Voici une manière de rendre illisible un programme utilisant les trigrammes :
??=include <stdio.h>
int main(void)
puts("Bonjour !");
return 0;
Par défaut, la plupart des compilateurs désactivent les trigrammes, au cas où vous ne seriez pas encore dissuadé de les utiliser.
Chaîne de caractères.
Une chaîne de caractère, comme son nom l'indique, est une suite de caractères avec la particularité d'avoir un caractère nul (0) à la fin. Une chaîne de caractère est en fait implémentée en C avec un tableau de type codice_1.
Ce chapitre vous donne les rudiments sur les chaînes de caractère pour une première approche.
Pour en savoir plus sur
Programmation_C/Tableaux#Chaînes_de_caractères
Structure.
En mémoire, une chaîne de caractère est représenté dans le langage C comme un tableau d'octet dont les valeurs dépendent de l'encodage utilisé ici, Unicode.

int main(void)

unsigned char c = 300;

/* %hhu sert à dire à printf() qu'on veut afficher un unsigned char */

printf("La variable c vaut %hhu.\n", c);

c = -5;

printf("La variable c vaut %hhu.\n", c);

return 0;

Le résultat du programme est :

La variable c vaut 44.

La variable c vaut 251.

En effet, on a 300 - 256 = 44 et -5 + 256 = 251.

De même :

int main(void)

signed char c = 300;

/* %hhd sert à dire à printf() qu'on veut afficher un signed char */

printf("La variable c vaut %hhd.\n", c);

c = -300;

printf("La variable c vaut %hhd.\n", c);

return 0;

Le résultat du programme peut alors être :

La variable c vaut 44.

La variable c vaut -44.

Sur une telle machine, les types signés sont traités de la même manière que les types non signés.

Si vous essayez de compiler ces deux programmes, votre compilateur pourra détecter les débordements et vous en avertir (GCC le fait).

Réels.

Les nombres réels ne pouvant tous être représentés, sont approximés par des nombres à virgule flottante. Comme dans le cas des entiers, il existe plusieurs types de nombre à virgule flottante. En voici la liste triée par précision croissante :

La norme C90 était assez floue concernant les nombres à virgule flottante, leurs représentations, la précision des opérations, etc., ce qui fait que c'était un des domaines où la conception de programmes utilisant les nombres flottants était chose peu aisée. Le C99 a clarifié les choses en précisant qu'une implémentation C devait respecter la norme IEC 60559:1989 "Arithmétique binaire en virgule flottante pour systèmes à microprocesseur". Cette norme (dérivée de ) définit des formats de données pour les nombres à virgule flottante, ainsi que des opérations et fonctions sur ces nombres. Elle garantit, entre autres :

Elle définit de plus comment sont gérés les cas exceptionnels, comme les infinis, les "NaN" (pour "Not a Number", résultant par exemple de la division 0/0), etc.

Les types flottants du C correspondent aux type IEC 60559 de la manière suivante :

Constantes réelles.

Une suite de caractères représente une constante à virgule flottante si :

Dans le deuxième cas, le "nombre" peut être soit un entier, soit un réel du premier cas.

Les constantes sont de type codice_51 par défaut. Pour demander le type codice_53, il faut la suffixer par codice_54 ou codice_55, et pour le type codice_56 par codice_57 ou codice_34.

Arithmétique.

Une attention particulière doit être portée sur la précision des types réels. Ces différents types ne font qu'approximer l'ensemble des nombres réels, avec une précision finie. Des erreurs d'arrondis sont à prévoir, ce qui est très problématique pour des domaines qui n'en tolèrent pas (notamment pour les applications financières, il est conseillé de ne pas utiliser de calcul en virgule flottante).

Le type codice_53 en particulier a une précision minimale, qui est bien souvent insuffisante. Voici un exemple classique d'erreur à ne pas faire qui illustre les problèmes liés à la précision des types flottants :

int main(void)

float i = 0;

int j;

for (j = 0; j < 1000; j ++)

i += 0.1;

printf("i = %f\n", i);

return 0;

Le résultat est 99,999046, ce qui montre que la précision du type codice_53 est en général mauvaise, d'autant plus que le nombre 0,1 n'est pas représentable de manière exacte en binaire. Il est ainsi conseillé d'utiliser le type codice_51 à la place de codice_53 autant que possible. Dans ce cas de figure, il est préférable d'éviter les accumulations d'erreurs infinitésimales, en réécrivant le code de la manière suivante :

int main(void)

float i;

int j = 1000;

i = j * 0.1;

printf("i = %f\n", i);

return 0;

Le résultat est alors 100.0, sans aucune erreur d'accumulation et d'arrondis.

Pour plus d'informations sur ce domaine, un wikilivre Arithmétique flottante est disponible.

Caractères.

À l'origine, le type permettant de représenter un caractère est codice_1. Même si un codice_1 n'est plus toujours suffisant aujourd'hui pour représenter un caractère quelconque.

Ce type est un peu plus particulier que les autres, d'une part parce que sa taille définit l'unité de calcul pour les quantités de mémoire (et donc pour les tailles des autres types du langage) et d'autre part son domaine de valeur peut grandement varier de manière relativement inattendue.

Par définition, la taille du type codice_1, notée codice_66, vaut toujours 1. Cependant, il faut faire attention : contrairement à ce qu'on pense souvent, un codice_1 au sens du C ne vaut pas toujours un octet. Il occupera au minimum 8 bits, mais il existe des architectures, relativement spécialisées il est vrai, ayant des codice_1 de 9 bits, de 16 bits, voire plus. Même si, dans une large majorité des cas, les compilateurs utilisent des codice_1 de 8 bits, à la fois par simplicité (les machines modernes fonctionnent généralement en 8, 16, 32 ou 64 bits) et pour éviter des problèmes de portabilité de code (beaucoup de codes C existants reposent sur l'hypothèse que les codice_1 font 8 bits, et risqueraient de ne pas marcher sur une autre architecture). Par simplification, nous utiliserons donc le terme "octet" la plupart du temps dans la suite de ce wikilivre.

Un autre piège de ce type est qu'il peut être de base (c'est-à-dire implicitement) codice_10 ou codice_11, au choix du compilateur, ce qui peut s'avérer dangereux (c'est-à-dire difficile à maitriser). Considérez le code suivant :

/* Ce code peut ne pas fonctionner avec certains compilateurs */

char i;

for (i = 100; i >= 0; i --)

/* ... */

Dans cet exemple, l'instruction codice_73 permet de faire itérer les valeurs entières de codice_74 de 100 à 0, incluses. On pourrait naïvement penser optimiser en utilisant un type codice_1. Sauf que si ce type est implicitement codice_11, la condition codice_77 sera toujours vraie, et tout ce que vous obtiendrez est une boucle infinie. Normalement, tout bon compilateur devrait vous avertir que la condition est toujours vraie et donc vous permettre de corriger en conséquence, plutôt que perdre des heures en débugage.

Constantes représentant un caractère.

Une constante représentant un caractère (de type char) est délimitée par des apostrophes, comme par exemple codice_78. En fait le langage C n'a initialement pas été conçu pour utiliser tous les caractères. Le type char permet de représenter ni plus ni moins que des nombres entiers (ils sont de type codice_4, mais leur valeur tiendra dans un type codice_1), les deux étant parfaitement interchangeables. Cependant, comme dit plus haut, il ne s'agit généralement pas là des caractères Unicode que nous manipulons tous les jours, mais de caractère-octet dont la portée est réduite.

Un petit exemple :

int main(void)

printf("Sur votre machine, la lettre 'a' a pour code %d.\n", 'a');

return 0;

Le programme précédent donnera le résultat suivant dans un environnement ASCII :

Il est tout à fait autorisé d'écrire codice_81 ou codice_82.

Cette soustraction permet de convertir une minuscule ASCII en majuscule si le codage ASCII est utilisé, mais ne le permet pas si un autre codage est utilisé (comme ISO-8859-1 ou UTF-8).

Valeur des caractères-octets.

La valeur représentée par cette constante est néanmoins dépendante des conventions de codages de caractères employées. À l'origine ces conventions étaient connues du système ; aujourd'hui, même si dans une écrasante majorité des cas, on se retrouvera avec un jeu de caractères augmentant l'ASCII et donc l'ISO-646.

Le code ASCII définit 96 glyphes de caractères portant les numéros 32 à 126, bien loin des milliers de caractères nécessaires pour les logiciels fonctionnant sur la planète entière et dans de nombreuses langues. Cet ensemble est à peine suffisant pour couvrir l'anglais alors que plusieurs langues latines étaient visées à l'époque où l'ASCII et l'ISO-646 ont été définis, si bien que de nombreuses extensions sont par la suite apparues.

Par exemple le caractère « œ » (ligature du o et du e) a pour valeur :

Retenons simplement qu'Unicode est omniprésent sur Internet, mais que des logiciels plus anciens ou embarqués peuvent fonctionner avec des jeux de caractères huit bits, plus limités. Il s'agit en fait d'une problématique concernant des sujets plus vastes, comme l' "internationalisation", la "portabilité" et l' "interopérabilité".

Le langage C reste relativement abstrait à ce niveau : le type char contient généralement un octet et les chaînes, une simple suite d'octets terminée par 0. Il laisse au système et au développeur le soin d'interpréter et de traiter les octets comme il se doit. Ceci peut être fait à l'aide de bibliothèques appropriées. Si on trouve ici ou là de telles listes de bibliothèques , il est préférable de connaître le langage C avant de les utiliser.

Cet abstraction du langage C lui a permis de s'adapter aux nombreuses évolutions des conventions de codages des caractères.

Caractères non graphiques.

Certains caractères ne sont pas graphiques. Par définition, on ne peut pas donc les écrire dans un code source de manière visible.

Le langage C adopte la convention suivant pour désigner certains d'entre eux de manière littérale :

De plus, on peut écrire n'importe quelle valeur de caractère avec les expressions suivantes :

Trigramme.

Le langage C date d'une époque où le standard de codage des caractères était l'ISO-646, un standard encore plus ancien et plus incomplet que l'ASCII. Les caractères absent de l'ISO-646 pouvaient être simulés par une séquence de trois caractères.

L'ASCII s'étant répandu, cette fonctionnalité tombée en désuétude est en général à éviter, car très souvent inutile, et peut causer des bugs incompréhensibles au programmeur non averti. Néanmoins, de très rares programmes peuvent utiliser ce genre de fonctionnalités. Un trigramme est simplement une suite de trois caractères dans le code source qui sera remplacée par un seul.

Cette fonctionnalité a été ajoutée au C pour supporter les architectures (systèmes) dont l'alphabet ne dispose pas de certains caractères qui sont nécessaires dans la syntaxe du C, comme les dièses ou les accolades.

Les substitutions suivantes sont faites partout dans le code source (y compris les chaînes de caractères) :

Voici une manière de rendre illisible un programme utilisant les trigrammes :

??=include <stdio.h>

int main(void)

puts("Bonjour !");

return 0;

Par défaut, la plupart des compilateurs désactivent les trigrammes, au cas où vous ne seriez pas encore dissuadé de les utiliser.

Chaîne de caractères.

Une chaîne de caractère, comme son nom l'indique, est une suite de caractères avec la particularité d'avoir un caractère nul (0) à la fin. Une chaîne de caractère est en fait implémentée en C avec un tableau de type codice_1.

Ce chapitre vous donne les rudiments sur les chaînes de caractère pour une première approche.

Pour en savoir plus sur

Programmation_C/Tableaux#Chaînes_de_caractères

Structure.

En mémoire, une chaîne de caractère est représenté dans le langage C comme un tableau d'octet dont les valeurs dépendent de l'encodage utilisé ici, Unicode.