Subsections

• 1.1 Introduction
• 1.2 Les fichiers include
• 1.3 Les commentaires
• 1.4 Les types de données élémentaires
  • Notation binaire, décimale, hexadécimale, octal
  • Exemple :
  • Représentation des nombres positifs et négatifs
  • Les entiers non signés
  • 1.4.1 Les entiers
  • 1.4.2 Le type char
    • Le caractère impossible.
  • 1.4.3 Les types short, long ou int
  • 1.4.4 Le type réel ou presque
    • Les floats
    • Les doubles
    • Les long doubles
    • L'imprécision des nombres à virgule flottante
• 1.5 Les constantes litérales
  • 1.5.1 Les constantes entières
    • Exemple.
  • 1.5.2 Les constantes flottantes
    • Exemple.
  • 1.5.3 Les constantes de type caractère
  • 1.5.4 Les chaînes de caractères
  • 1.5.5 A propos de booléens
• 1.6 Les variables
  • Définir et déclarer des variables
  • Exemple :
  • Exemples :
  • Portée des variables.
• 1.7 Les entrées-sorties
  • 1.7.1 Les sorties.
    • Sortie formatée avec printf
    • Exemple.
  • 1.7.2 Les entrées.
    • Entrée formatée avec scanf.
    • Exemple.
    • Autre entrée.

  1 Eléments de base

   

  1.1 Introduction

  Un langage de programmation a pour finalité de communiquer avec la machine. Il y a diverses manières de communiquer avec la machine. Le langage << maternel >> de la machine n'utilise que deux symboles (0 et 1): c'est le langage machine. Par exemple le nombre 5 est reconnu par une machine par la succession des symboles 1,0,1 (c'est la représentation du nombre en base 2). De même, les opérations qu'une machine est capable d'exécuter sont codées par des nombres, c'est-à-dire une succession de 0 et 1. Par exemple, l'instruction machine

   
  00011010    0001     0010
   

  demande à la machine d'effectuer l'opération 1+2. A chaque type de machine correspond, un jeu d'instructions spécifique; de même le codage des instructions est également dépendante de la machine utilisée.

  Même si ce langage est le seul qui soit compris par l'ordinateur, il n'est pas le seul moyen de communiquer avec celui-ci. En effet, on a très tôt éprouvé le besoin d'humaniser cette communication et la première tentative en ce sens est l'invention du langage assembleur. Par exemple, l'instruction assembleur

   
  add    $1      $2
   

  demande à la machine d'effectuer l'opération 1+2. Ce langage est très proche du langage machine et se contente de donner des noms mnémotechniques pour les instructions ainsi qu'une manière plus naturelle de désigner des entiers. Le langage assembleur fut suivi par des langages plus sophistiqués. En particulier, on distingue les langages qui permettent
  • la programmation structurée (fortran, pascal, algol, C, perl, tcl),
  • la programmation structurée et modulaire (ada, modula),
  • la programmation fonctionnelle (lisp)
  • la programmation logique (prolog)
  • la programmation objet (smalltalk, eiffel, C++, java).

  Ces langages ont tous pour ambition de faciliter la programmation en la rendant plus proche du << langage humain >>. Tous ces langages de programmation ont besoin d'un traducteur pour être compris de la machine. De tels traducteurs sont généralement appelés interpréteurs ou compilateurs. En ce qui nous concerne, nous nous intéresserons qu'aux compilateurs: ils traduisent le texte écrit par un programmeur en un programme exécutable (compréhensible par la machine).

  Un programme C est un texte écrit avec un éditeur de texte, respectant une certaine syntaxe et stocké sous forme d'un ou plusieurs fichiers (généralement avec l'extension .c). A l'opposé du langage assembleur, les instructions du langage C sont obligatoirement encapsulées dans des fonctions et il existe une fonction privilégiée appelée main   qui est le point de départ de tout programme. Voici, un exemple de programme C  

   
  int main() {
    printf("Bonjour");
    return 1;
  }
   

  qui se contente d'afficher la chaîne de caractères   Bonjour à l'écran. Pour afficher cette chaîne, le programme fait appel à la fonction printf   qui fait partie de l'une des fonctions prédéfinies fournies avec tout compilateur C. L'ensemble de ces fonctions prédéfinies (appelé bibliothèque C)   est stocké dans un ou plusieurs fichier(s). La traduction du fichier texte ci-dessus en un programme exécutable se décompose en deux phases:
  • la compilation   qui est la traduction d'un programme C en une suite d'instructions machine; le résultat produit est un fichier objet   (généralement avec l'extension .o).
  • l'édition des liens   produit, à partir d'un ou de plusieurs fichiers objets et des bibliothèques, un fichier exécutable.

    Outre l'assemblage des divers fichiers objets, l'édition des liens inclut les définitions des fonctions prédéfinies utilisées par le programme.

  

  Chaque fichier texte est appelé module   et est composé (comme nous le verrons plus loin)

  • des définitions de fonctions
  • des définitions de variables
  • des déclarations de variables et fonctions externes
  • des directives du préprocesseur (lignes commençant par #)
  • des définitions de type (struct, union, enum etc...)

  1.2 Les fichiers include

   Pour compiler correctement un fichier, le compilateur a besoin d'informations concernant les déclarations de structures de données et de variables externes ainsi que de l'aspect (on dira prototype) des fonctions prédéfinies. Toutes ces informations sont contenues dans des fichiers avec l'extension .h. Ces fichiers doivent être inclus dans le fichier que l'on veut compiler. Pour ce faire, le langage C offre la directive du préprocesseur

   
  #include nom de fichier
   

  Par exemple, pour utiliser la fonction printf, il faut inclure le fichier stdio.h, stdio.h qui contient les déclaration de variables externes et les protoytpes de fonctions de la bibliothèque d'entrée-sortie standard (standard input output), dans le fichier que l'on veut compiler de la manière suivante:

   
  #include 
   

  Voici la version correcte du programme présenté précédemment (section 1.1 page )

   
  #include 
  int main() {
    printf("Bonjour");
    return 1;
  }
   

  1.3 Les commentaires

    Dès lors que l'on écrit un programme important, il est indispensable d'y inclure des commentaires qui ont pour but d'expliquer ce qu'est sensé faire le programme, les conventions adoptées et tout autre information rendant le programme lisible à soi même et à autrui.

  Un commentaire commence par les caractères /* et se terminent par */. A l'intérieur de ces délimiteurs toute suite de caractères est valide (sauf évidemment */).

   
  /* Ce programme imprime la chaine 
     de caractéres "bonjour" à l'écran 
  */
  #include  
  /* Fichier include pour pouvoir utiliser la fonction printf */
  
  int main() {
    printf("Bonjour");
    return 1;
  }
   

  1.4 Les types de données élémentaires

   Un programme C manipule deux structures de données des base: les entiers et les nombres flottants. Un autre type de donnée élémentaire est le pointeur . Toute autre structure de donnée sera dérivée à partir de ces types fondamentaux. Par exemple, les caractères, les booléens, les constantes symboliques etc..., ne sont rien d'autres que des nombres.

  Notation binaire, décimale, hexadécimale, octal

         

  Rappelons qu'un nombre n en notation décimale est représenté en base b par le nombre a_i a_i-1 ... a₁ a₀

  où

  n = a_m * b^m + a_m-1 * b^m-1 + ... + a₁ * b + a₀ avec 0 < a_i < b.

  Voici une liste des bases habituellement utilisées en informatique
  

   

  Base Notation Symboles

  2 binaire 0, 1

  8 octale 0, 1, ... 7

  10 décimale 0, 1, ... 9

  16 hexadécimale 0, 1, ... 9, a, b, c, d, e, f

  
  

  Exemple :

  Le nombre 70 (en notation décimale) est représenté par 1000110 en notation binaire, 106 en notation octale, 46 en notation hexadécimale.

  Représentation des nombres positifs et négatifs

       

  On appelle bit de signe, le bit le plus élevé (bit de poids fort) de le représentation d'un entier.

  

  Si l'on considère un nombre codé sur un octet, lorsque le bit de signe vaut 0, il s'agit d'un nombre positif. Inversement lorsque ce bit vaut 1, il s'agit d'un nombre négatif.

  Les entiers non signés

  Dans un octet, il est possible de ranger 2⁸ valeurs différentes. Si l'on décide que cet octet est susceptible de contenir des entiers positifs et négatifs (le bit de signe est occupé), on codera les valeurs comprises entre -2⁷. et 2 ⁷ -1. Inversement, si l'on décide que cet octet ne contient que des entiers sans signe (positifs ou nuls), on codera les valeurs comprises entre 0 et 2⁸-1.

  1.4.1 Les entiers

  En C, on dispose de divers types d'entiers qui se distinguent par la place qu'ils occupent en mémoire :

  • sur 1 octet, les entiers signés et non signés (char) et (unsigned char).
  • sur 2 octets, les entiers signés et non signés (short) et (unsigned short).
  • sur 4 octets, les entiers signés et non signés (long) et (unsigned long) .
  • le type int (unsigned int) est selon les machines synonymes de short (unsigned short) ou de long (unsigned long)

  1.4.2 Le type char

       Le type char désigne un entier signé codé sur 1 octet.

  
  

   

  Décimal Caractère NULL

  ... ... 48

  ... ...

  57 9

  ... ...

  65 A

  ... ...

  90 Z

  ... ...

  97 a

  ... ...

  122 z

  ... ... 127

  
  

     

  Comme vous le constatez, le type char n'est qu'un entier codé sur un octet. Il en découle que toutes les opérations autorisées sur les entiers peuvent être utilisées sur les caractères. Aussi surprenant que cela puisse paraître, on peut ajouter ou soustraire deux caractères, ajouter ou soustraire un entier à un caractère.

  Une utilisation classique de cette souplesse d'utilisation est la conversion d'un caractère c désigant un chiffre en sa valeur v correspondante:

  v = c - '0'

  Le caractère impossible.

      Toutes les valeurs que l'on peut ranger dans une donnée de type char sont des caractères valides. Les programmes qui manipulent les caractères doivent disposer d'un caractère (ou pseudo caractère) supplémentaire, distinct de tout caractère valide. Cette valeur particulière sera utilisée pour vérifier qu'on l'on atteint la fin des données. Cette valeur a pour nom EOF et est définie dans le fichier <stdio.h>.

  1.4.3 Les types short, long ou int

       

  Le type short représente un entier signé codé sur 2 octets (de -32768 à 32767) et le type unsigned short représente un entier non signé codé sur 2 octets (de 0 à 65535). Le type long (ou int pour nos machines) représente un entier signé codé sur 4 octets (de -2147843648 à 2147843647) et le type unsigned long (ou unsigned int pour nos machines) représente un entier non signé codé sur 4 octets (de 0 à 4294967295).

  1.4.4 Le type réel ou presque

              Les nombres à virgule flottante (abusivement appelés réels) servent à coder de manière approchée les nombres réels. Un nombre à virgule flottante est composée d'un signe, d'une mantisse et d'un exposant. On dispose de trois types de nombres à virgule flottante, les types float, double et long double.

  Les floats

  Un float est codé sur 4 octets avec 1 bit de signe, 23 bits de mantisse et 8 bits d'exposant (valeurs comprises entre 3.4 * 10^-38 et 3.4 * 10³⁸ ).

  Les doubles

  Un double est codé sur 8 octets avec 1 bit de signe, 52 bits de mantisse et 11 bits d'exposant (valeurs comprises entre 1.7 * 10^-308 et 1.7 * 10³⁰⁸ ).

  Les long doubles

  Un long double est codé sur 10 octets avec 1 bit de signe, 64 bits de mantisse et 15 bits d'exposant (valeurs comprises entre 3.4 * 10^-4932 3.4 * 10⁴⁹³² ).

  L'imprécision des nombres à virgule flottante

  Les nombres à virgule flottante sont des valeurs approchées. En particulier, les opérations sur ces nombres peuvent conduire à des erreurs d'arrondis.

  1.5 Les constantes litérales

     Nous avons présenté les divers types de données élémentaires du langage C sans dire comment écrire une constante de l'un de ces types dans un programme C. Nous allons à présent donner la syntaxe utilisée dans le langage C pour désigner des constantes littérales .

  1.5.1 Les constantes entières

    Les constantes entières peuvent s'exprimer
  • en notation décimale: 123, -123, etc...
  • en notation octale avec un 0 en première position: 0123
  • en notation hexadécimale avec les caractères 0x ou 0X en première position : 0x1b 0X2c, 0X1B, 0X2C, etc...

  Le type d'une constante entière est le << plus petit >> type dans lequel il peut être représenté :

  • notation décimale : int, sinon long, sinon unsigned long
  • notation octale ou décimale : int, sinon unsigned int, sinon unsigned long

  Des suffixes permettent de changer cette classification :

  • U, u : constante de type unsigned
  • L, l : constante de type long

  Exemple.

  1L, 0x7FFU, 16UL, etc...

  1.5.2 Les constantes flottantes

     

  Une constante flottante se présente sous la forme d'une suite de chiffres (partie entière), un point qui joue le rôle de virgule, une suite de chiffres (partie fractionnaire), une des deux lettres e ou E, éventuellement le signe + ou - suivi d'une suite de chiffres (valeur absolue de l'exposant)

  La partie entière ou la partie fractionnaire peut être omise (pas les deux); de même le point ou l'exposant peut être omis (pas les deux).

  Une constante flottante est supposée être de type double. Le suffixe F indique qu'elle est de type float. Le suffixe LF indique qu'elle est de type long double.

  Exemple.

  .5e7, 5.e6, 5e6, 5000

  1.5.3 Les constantes de type caractère

   

  Les constantes de type caractère se note entre apostrophes:
  

  'a' '2' '"'
  
  
  Le caractère ' se note '\'' et le caractère \ se note '\\'. On peut également représenter des caractères non imprimables à l'aide de séquences d'échappement. Voici une liste non exhaustive de caractères non imprimable:
  
   

  \n nouvelle ligne

  \t tabulation horizontale

  \v tabulation verticale

  \b retour d'un caractère en arrière

  \r retour chariot

  \f saut de page

  \a beep

  \' apostrophe

  \" guillemet

  \\ anti-slash

  \ddd code ASCII en notation octale

  \xddd code ASCII en notation hexadécimale

  
  

  1.5.4 Les chaînes de caractères

     Les chaînes de caractères se note entre guillemets:
  
  "coucou"
  "C'est bientot fini !!!"
  
  
  

  Une chaîne de caractères est une suite de caractères (éventuellement vide) entre guillemets. Il en découle que l'on est autorisé à utiliser les séquences d'échappement dans les chaînes.   La fonction suivante

          printf("Bonjour\n\tComment ca va \n");
  

  produit la sortie suivante :

   
  Bonjour
          Comment ca va
   

  En mémoire, une chaîne de caractères est une suite de caractères consécutifs et dont le dernier élément est le caractère nul '\0'.  

  Une chaîne de caractère doit être écrite sur une seule ligne. Lorsqu'il est trop long pour tenir une même ligne, on decoupe celle-ci en plusieurs bouts; chaque bout étant écrite sur une seule ligne et on masque le retour à la ligne par le caractère \. Les deux instructions suivantes sont équivalentes.

  x = "abcdefghijklm\
  nopqrstuvwxyz\
  ABCDEFGHIJKLM\
  NOPQRSTUVWXYZ";
  
  x = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
  

  

  1.5.5 A propos de booléens

    Contrairement à d'autres langages (comme Pascal), il n'y a pas de type booléen en C. Le type booléen est représenté par un entier. Il se comporte comme la valeur booléenne vraie si cette valeur entière est non nulle. L'expression x différent de y se note (x != y) dans le langage C.

  Dans un contexte qui exige une valeur booléenne (comme les tests, par exemple), un entier non nul équivaut à vrai et la valeur zero équivaut à faux: les expressions (expr) et (expr != 0) sont équivalentes. De même, une fonction qui retourne une valeur boolénne pourra retourner une valeur non nulle comme équivalent à vrai et la valeur 0 comme équivalent à faux.

  1.6 Les variables

     

  Une variable possède

  1.

  un nom (un identificateur) composé d'une suite de caractères commençant par un caractère alphabétique et suivi de caractères alphanumériques ou du caractère _.
  Exemple de noms de variables: x, x1, x_1, Var, VarLocal, var_local

  2.

  un type qui permet d'allouer une zone mémoire. On peut considérer la mémoire d'une machine comme une suite d'octets dans laquelle on réserve des octets pour les variables et ce en fonction de leur taille donnée par le type de la variable. Si c , s et l sont respectivement des variables de type char, short et long, la figure 1.4 décrit une configuration possible de la mémoire.

  3.

  une valeur arbitraire (dans beaucoup de cas) si la variable n'est pas explicitement affectée. Une variable, une fois définie, contient toujours une valeur. Ce contenu n'a aucun sens pour nous tant que l'on n'y range pas de façon intentionnelle quelque chose de cohérent. Nous verrons plus loin que selon la nature de la variable, le système range (ou pas) une valeur par défaut. Dans la figure 1.4, la variable c (resp. s et l) représente un variable de type char (resp. short et long).

  

    L'emplacement d'une variable en mémoire est désigné par le terme adresse de la variable. Cette adresse est définie une fois pour toutes et est évidemment invariante tout au long du programme.

  Contrairement aux constantes, le contenu d'une variable peut être modifée à volonté; ce qui ne change pas c'est l'adresse de la variable.

  La notion de variable en informatique n'a strictement rien de commum avec celle de varibale en mathématique. En infomatique, il ne s'agit de rien de plus que d'une adresse en mémoire.

  Définir et déclarer des variables

   En C, toute variable utilisée dans un programme doit auparavant être définie. La définition  d'une variable consiste à la nommer et lui donner un type et éventuellement lui donner une valeur initiale (on dira initialiser). C'est cette définition qui réserve (on dira alloue) la place mémoire nécessaire en fonction du type.

   Initialiser une variable consiste à remplir, avec une constante, la zone mémoire réservée à cette variable. Cette opération s'effectue avec l'opérateur =Il ne faut pas confondre l'initialisation et affectation. Malheuresement, ces deux opérations utilisent le même symbole =.

  Exemple :

   
  int x = 2;
  char c = 'c';
  float f = 1.3;
   

  Il est parfois utile de déclarer une variable sans la définir. Une déclarartion   de variable définit un nom et un type mais n'alloue par la place mémoire. En effet, lorsque le programme que l'on réalise est décomposé en plusieurs modules, une même variable, utilisée dans plusieurs modules, doit être déclarée dans chacun de ces modules. Par contre, on ne définira cette variable que dans un seul de ces modules. C'est au moment de l'édition des liens que l'on mettra en correspondance les variables apparaissant dans plusieurs modules.

  L'intialisation d'une variable ne peut se faire que lors de sa définition. Par contre, il ne faut pas initialiser une variable lors de sa déclaration. Dans ce qui suit, lorsqu'il n'y aura pas d'ambiguïté, on confondra les deux termes : déclaration et définition.

  La syntaxe de la déclaration d'une variable est de la forme suivante:
  

  = expression
  = expression
  = rien

  Nous verrons dans le chapitre refcdd le sens des mots clés auto, extern, static, register, volatile, etc.

  Exemples :

   
  int x, y = 0, z;
  extern float a, b;
  static unsigned short cpt = 1000;
   

  Un certain nombre d'identificateurs sont reservés et ne peuvent être utilisés comme noms de variables. Voici la liste des noms réservés:

  auto break case char const continue default do

  double else enum extern float for goto if

  int long register return short signed sizeof static

  struct switch typedef union unsigned void volatile while

  Portée des variables.

  
         La position de la déclarartion ou de la définition d'une variable détermine sa portée i.e. sa durée de vie et sa visibilié dans le programme (voir le cas particulier des variables static dans la section  5.1.1).        
  • Les variables globales sont déclarées en dehors de toute fonction ,
  • Les variables locales sont déclarées à l'intérieur des fonctions et ne sont pas visibles à l'extérieur de la fonction dans laquelle celle-ci est définie (syntaxe ANSI).
  • Les arguments formels sont déclarées dans les entêtes des fonctions.

  

  Pour plus de précision, se reporter à la page .

  1.7 Les entrées-sorties

     Un programme n'a d'intérêt que dans la mesure où il communique avec l'utilisateur. Il faut donc que l'utilisateur lui << entre >> des données et que le programme, après calcul << sorte >> des résultats. Les fonctions d'entrée-sortie vont permettre de réaliser cette communication. Dans cette section, on propose une rapide présentation des quelques fonctions de base utiles pour commencer à programmer. Le chapitre 8 sera tout entier dédié aux entrées-sorties.

  1.7.1 Les sorties.

  Les résultats caluclés par un programme sont affichés à l'utilisateur soit sur l'écran (sortie standard), soit dans un fichier de resultats.

  Sortie formatée avec printf

      La fonction printf affiche à l'écran les arguments fournis. La syntaxe de cette fonction est de la forme :
  
  printf("format", arg1, arg2, ..., argN);
  
  .
  L'argument format est une chaîne de caractères contenant éventuellement des spécifications. Une spécification de format est donnée par le caractère % suivi d'une ou plusieurs lettres clé. Voici à titre d'exemple, quelques spécifiactions possibles; on trouvera, dans le chapitre 8, une présentation détaillée de ces spécifications.

  %c caractère

  %s chaîne

  %d entier

  %u entier non signé

  %f,%g flottant

  %e,%E flottant avec exposant ...

  Exemple.

  • printf("Coucou") : pas d'arguments, format est constituée uniquement de la chaîne "Coucou".
  • printf("%s", "Coucou") : dans cet appel, il y a un argument de type chaîne (%s) qui est la chaîne "Coucou".
  • printf("%d", 3) : dans cet appel, il y a un argument de type entier et qui vaut 3.
  • printf("la somme de %d et de %d vaut %d", 3, 5, 3+5) : dans cet appel, il y a trois arguments de type entier.

  Il n'y a aucun test de vérification de la cohérence entre le format et le type des arguments fournis. L'appel printf("%s", 333) est parfaitement admis par le compilateur; aucune erreur n'est signalée mais l'exécution de cette instruction produira un résultat curieux. Il convient donc au programmeur de s'assurer de la cohérence entre le format et les arguments founis.

  marginparexemple
  qui cloche

  1.7.2 Les entrées.

  Il s'agit de donner au programme les données nécessaires à son exécution. Par exemple, si l'on veut calculer la somme de deux entiers, le programme attend de l'utilisateur qu'il donne la valeur des entiers. Selon la nature du programme, l'utilisateur aura le choix de fournir ces valeurs de manière interactive (entrée standard), soit en remplissant un fichier contenant ces valeurs.

  Entrée formatée avec scanf.

    La fonction scanf lit à la console des données. La syntaxe de cette fonction est de la forme :
  
  scanf("format", &arg1, &arg2, ..., &argN);
  
  .
  L'argument format est celui décrit plus haut. On notera la présence du symbole & devant chaque argument à imprimer. Nous verrons dans le chapitre 4 le sens de ce symbole.

  Lorsqu'une lecture à la console est faite avec scanf, il est impératif de << rentrer >> quelque chose qui est rigoureusement identique au format que l'on a défini. Nous verrons dans le chapiter 8 les problèmes liés au non respect du formatage.

  Exemple.

  scanf("%d\n", &x) : le contenu de la variable x est rempli avec ce que l'utilisateur founira à la console. Il faut donc << entrer >> un entier suivi d'un retour à la ligne.

  Ici non plus, il n'y a aucune vérification (ni à la compilation, ni à l'exécution) de la cohérence entre le format et le type des arguments founis.

  Autre entrée.

  On dispose également des fonctions

  int getchar(void) et char *gets(char *s)

  qui retourne (voir chapitre 4) un caractère (resp. une chaîne de caractères) lu à la console.