Datasets:
Kant1
/
French_Wikibooks_articles

Dataset card Data Studio Files Community
1
text
stringlengths
0
211k
À noter que l'instruction vide étant valide en C, on peut donc pratiquement rajouter autant de point-virgules que l'on veut. Le point-virgule ne sert pas uniquement à marquer la fin des instructions, les compilateurs l'utilisent généralement comme caractère de synchronisation, suite à une erreur dans un programme source. En fait, en général, lorsqu'une erreur est détectée, les compilateurs ignorent tout jusqu'au prochain point-virgule. Ce qui peut avoir des conséquences assez dramatiques, comme dans l'exemple suivant :
int traite_arguments(int nb, char * argv[])
/* ... */
return 0
int main(int nb, char * argv[])
int retour;
retour = traite_arguments(nb, argv);
On notera l'absence de point-virgule à la fin de l'instruction codice_31 à la fin de la fonction codice_32. Ce que la plupart des compilateurs feront dans ce cas sera d'ignorer tout jusqu'au prochain point-virgule. On se rend compte du problème : on a sauté une déclaration de fonction (avec ses deux paramètres) et une déclaration de variable. Ce qui veut dire qu'une cascade d'erreurs va suivre suite à l'oubli... d'un seul caractère (codice_28) !
Déclarations de variables.
T var1, var2, ..., varN;
Cette ligne déclare les variables "var1", "var2", ..., "varN" de type "T". Une variable est dite "locale", si elle est définie à l'intérieur d'une fonction et "globale" si définie en-dehors.
Par exemple :
int jour; /* 'jour' est une variable globale, de type entier */
int main(void)
double prix; /* 'prix' est une variable locale à la fonction 'main', de type réel */
return 0;
Variables locales.
Les variables locales (aussi appelées "automatiques") ne sont visibles que dans le bloc dans lequel elles sont définies, et n'existent que durant ce bloc. Par exemple :
int fonction(int n)
int i; /* i est visible dans toute la fonction */
i = n + 1;
{ /* début d'un nouveau bloc */
int j; /* j est visible dans le nouveau bloc *seulement* */
j = 2 * i; /* i est accessible ici */
i = j; /* ERREUR : j n'est plus accessible */
return i;
Le code précédent accède à codice_34 depuis un bloc contenu dans le bloc où codice_34 a été défini, ce qui est normal. Puis il essaye d'accéder à la valeur de la variable codice_36 "en-dehors" du bloc où elle à été définie, ce qui est une erreur.
Les variables locales ne sont pas initialisées automatiquement et contiennent donc, après leur déclaration, une valeur aléatoire. Utiliser une telle valeur peut causer un comportement aléatoire du programme. Le programme suivant essaye d'afficher la valeur d'une telle variable, et on ne peut savoir à l'avance ce qu'il va afficher. Si on le lance plusieurs fois, il peut afficher plusieurs fois la même valeur aussi bien qu'il peut afficher une valeur différente à chaque exécution :
int main(void)
int n;
printf("La variable n vaut %d\n", n);
return 0;
Avant la normalisation ISO C99, les déclarations de variables locales devaient obligatoirement être placées juste au début d'un bloc et s'arrêtaient à la première instruction rencontrée. Si une déclaration est faite au-delà, une erreur sera retournée. Suivant la norme C99, les déclarations peuvent se trouver n'importe où dans un bloc.
Par exemple, le code suivant est correct suivant la norme C99, mais pas suivant la norme C90, car la variable codice_22 est définie après l'instruction codice_38 :
int ma_fonction(int n)
puts("Bonjour !");
int a; /* Valide en C99, invalide en C90 */
/* autre chose... */
return a;
Variables globales.
Une attention particulière doit être portée aux variables globales, souvent source de confusion et d'erreur. Utilisez des noms explicites, longs si besoin et limitez leur usage au seul fichier où elles sont déclarées, en les déclarants statiques.
Les variables globales sont initialisées avant que la fonction codice_1 s'exécute. Si le programmeur ne fournit pas de valeur initiale explicitement, chaque variable reçoit une valeur par défaut suivant son type :
Pour initialiser explicitement une variable globale, on ne peut utiliser que des constantes ; en particulier, on ne peut appeler de fonction, contrairement à d'autres langages.
int jour_courant(void)
/* retourne le n° du jour courant */
int jour = jour_courant(); /* ERREUR ! */
int main(void)
/* ... */
return 0;
Le code précédent ne pourra pas compiler, car on ne peut appeler directement codice_41 pour initialiser codice_42. Si vous avez besoin d'un tel comportement, une solution est de faire l’initialisation explicite dans codice_1 :
int jour_courant(void)
/* retourne le n° du jour courant */
int jour; /* 'jour' est initialisé à 0 *avant* le début de 'main' */
int main(void)
jour = jour_courant();
return 0;
Traitements des ambiguïtés.
Le C utilise un mécanisme élégant pour lever des constructions syntaxiques en apparence ambiguës. L'analyse des mots (lexèmes, "token" en anglais) se fait systématiquement de la gauche vers la droite. Si plusieurs lexèmes peuvent correspondre à une certaine position, le plus grand aura priorité. Considérez l'expression valide suivante :
a+++b;
Ce genre de construction hautement illisible et absconse est bien évidemment à éviter, mais illustre parfaitement bien ce mécanisme. Dans cet exemple, le premier lexème trouvé est bien sûr l'identificateur 'codice_22' puis le compilateur a le choix entre l'opérateur unaire 'codice_45', ou l'opérateur binaire 'codice_46'. Le plus grand étant le premier, c'est celui-ci qui aura priorité. L'instruction se décompose donc en :
(a ++) + b;
Programmation C/Types de base
Le C est un langage typé statiquement : chaque variable, chaque constante et chaque expression, a un type défini à la compilation. Le langage lui-même fournit des types permettant de manipuler des nombres (entiers, réels ou complexes) ou des caractères (eux-mêmes étant manipulés comme des entiers spéciaux), et permet de construire des types plus complexes à partir de ces premiers, par exemple en groupant des données de même type en tableaux, ou des données de types différents dans des structures. Dans ce chapitre, nous étudierons les types de base fournis par le C, l'étude des types complexes étant faite dans la suite du livre.
Entiers.
Il y a cinq types de variables entières (« integer » en anglais) :
Comme évoqué en introduction, le type caractère codice_1 est particulier, et sera étudié en détail plus bas.
Les types entiers peuvent prendre les modificateurs codice_10 et codice_11 qui permettent respectivement d'obtenir un type signé ou non signé. Ces modificateurs ne changent pas la taille des types. Le langage ne définit pas exactement leur taille, mais définit un domaine de valeurs minimal pour chacun.
Représentation des entiers signés.
La norme C tient compte des anciennes représentations des nombres signés telles que le signe+valeur absolue et le complément à 1. Ces deux représentations sont brièvement expliquées ci-dessous :
Ces deux représentations peuvent représenter la valeur nulle de deux manières différentes.
La représentation moderne des nombres négatifs utilise le complément à 2 (CPL2) qui consiste à représenter les nombres négatifs comme le complément à 1 et en ajoutant 1. Sur un nombre fixe de bits, la valeur 0 n'a qu'une seule représentation : +0 (000...000) et -0 (111...111 + 1 = (1)000...000) ont deux représentations identiques. Sur N bits on peut donc représenter tout nombre entre -(2N-1) "(100...000)" et +(2N-1-1) "(011...111)". Cette représentation possède donc un domaine plus large.
Le tableau ci-dessous donne le domaine des valeurs quelle que soit la représentation utilisée (SVA, CPL1 ou CPL2) :
Cette table signifie qu'un programme peut utiliser sans problème une variable de type codice_4 pour stocker la valeur 215-1, quel que soit le compilateur ou la machine sur laquelle va tourner le programme.
Par contre, une implémentation C peut fournir des domaines de valeurs plus larges que ceux indiqués au-dessus :
Les processeurs modernes supportent un grand nombre de bits, pouvant autoriser les compilateurs à fournir des types stockés sur un plus grand nombre de bits que le nombre minimal indiqué par la norme. Cependant des processeurs plus anciens sont encore utilisés de nos jours (coût réduit) sur des systèmes embarqués.
Il est donc important de vérifier que les valeurs utilisées puissent être stockées dans les variables.
Par exemple, cela permet l'utilisation d'une bibliothèque C (exemple : un décodeur vidéo) sur un système embarqué.
Dans le cas où une bibliothèque assume une taille des types plus grande que supporté par le compilateur pour le processeur, il faudra effectuer des modifications du code source pour que la bibliothèque soit utilisable sur le système embarqué.
Par ailleurs, une relation d'ordre entre ces domaines de valeurs est garantie ; qui peut être exprimée ainsi :
domaine(char) ≤ domaine(short) ≤ domaine(int) ≤ domaine(long) ≤ domaine(long long)
Cela signifie que toutes les valeurs possibles pour une variable du type codice_1 sont aussi utilisables pour les autres types ; mais aussi que, par exemple, une valeur valide pour le type codice_4 peut ne pas être représentable dans une variable de type codice_3.
Si vous ne savez pas quel type donner à une variable de type entier, le type codice_4 est par défaut le meilleur choix (à condition que votre donnée ne dépasse pas 215-1) : ce type est la plupart du temps représenté au niveau matériel par un « mot machine », c'est-à-dire qu'il est adapté à la taille que la machine peut traiter directement (il fait usuellement 32 bits sur un PC 32 bits, par exemple). Cela permet un traitement plus rapide par le matériel. De plus, beaucoup de bibliothèques (que ce soit celle fournie par le langage C ou d'autres) utilisent ce type pour passer des entiers, ce qui fait que l'utilisation de ces bibliothèques sera plus aisée.
Par ailleurs, un utilisateur peut connaître les domaines de valeurs exacts de sa machine en utilisant l'en-tête codice_19.
Portabilité apportée par C99.
L'incertitude sur l'intervalle de valeur de chaque type en fonction de la machine peut s'avérer extrêmement gênante, pour ne pas dire rédhibitoire. En effet, certains programmes peuvent nécessiter un type de données de taille fixe et cependant être destinés à être portables. Pour ces programmes, les types entiers du C ne sont pas suffisants. "Beaucoup" d'extensions ont été rajoutées pour définir explicitement des types entiers à intervalle fixe (8, 16, 32 bits...) à partir des types de base, avec une nomenclature loin d'être homogène d'un compilateur à l'autre (ce qui, loin de résoudre le problème, ne faisait que le déplacer).
La norme ISO C99 décide une bonne fois pour toute de définir, dans l'en-tête <stdint.h>, plusieurs nouveaux types où codice_20 représente un nombre entier définissant la taille requise en bit :
Cet en-tête définit aussi des constantes pour les valeurs minimales et maximales de chaque type.
L'include <inttypes.h> définit les constantes symboliques à utiliser pour imprimer ces nouveaux types avec les fonctions de la famille de printf (PRIxxx) et les lire avec celles de scanf (SCNxxx).
Constantes numériques entières.
Il existe différentes suites de caractères qui sont reconnues comme étant des constantes numériques entières :
Par défaut, une constante numérique entière est de type codice_4 et, si sa valeur est trop grande pour le type codice_4, elle prend celle du type « plus grand » suffisant. Comme les domaines de valeurs des types peuvent varier suivant la machine, le type effectif d'une constante peut lui aussi varier. Cela peut s'avérer problématique lors de passage de paramètres à des fonctions à nombre variable d'arguments, par exemple. À cause de cela, il est recommandé de forcer le type de la constante en le postfixant des attributs suivants :
codice_33 peut être combiné à codice_34 et codice_37 pour obtenir les types codice_42 et codice_43, respectivement. Lorsqu'une constante est suffixée, mais que sa valeur est trop grande pour le type demandé, le même processus de recherche de type « assez grand » est utilisé.
Débordement.
Sur une machine donnée, un type entier a un domaine de valeurs fixe. Considérons qu'on travaille sur un PC en 32 bits, en complément à deux : sur un tel ordinateur, le type codice_4 varie souvent de -231 à 231-1. Cela permet de manipuler sans problème des valeurs dans ce domaine. Par contre, si on utilise des valeurs hors du domaine, par exemple 232, et qu'on essaye de la stocker dans une variable de type codice_4 sur une telle machine, que se passe-t-il ?
La réponse dépend du type:
Exemples : On suppose que le type codice_47 est codé sur 8 bits. Alors une valeur de ce type peut aller de 0 à 28-1, soit 255. Par la règle précédente, les conversions se feront donc modulo 255 + 1, soit 256. On considère le programme suivant :