ANTIROUILLE

Contenu de cette page :

1	Préface: les langages
2	Aspect pratique
3	Un premier programme
4	Les déclarations Déclarations de variables Déclarations d'entiers Déclarations de réels
5	Les instructions de base Affectations Appels de fonctions ou de procédures Blocs d'instructions Instructions conditionnelles L'expression conditionnelle Instructions itératives Boucle while Boucle for Boucle do  ... while Sélection
6	Le pré-processeur
7	Autres déclarations Les constantes Les énumérations Les booléens Les tableaux Les caractères Les chaînes de caractères Les structures
8	Les fichiers textes
9	Les fonctions et procédures Généralités Arguments variables Tableaux passés en arguments Variables rémanentes Exemple : calcul du pgcd
10	Portée des variables Dans un même fichier Variables externes .... ou sans variables externes ?
11	Les pointeurs et l'allocation programmée Allocation dynamique de structures Allocation dynamique de tableaux Exemple : gestion d'une liste "fifo" Pointeurs et passage d'arguments variables
12	Aspect numérique Conversion entiers/réels Particularité des réels - norme IEEE
13	Organisation des fonctions dans un logiciel
14	Bibliographie
15	Notes

Préface : les langages de programmation

Définition

Les langages

Pour ce cours, on a choisi un sous-ensemble de C++

• Il fallait bien en choisir un. On a rejeté l'idée d'un  pseudo-code neutre, car il vaut mieux pouvoir tester directement ce que l'on programme. Et puis un compilateur est un outil extrêmement précieux pour détecter les fautes de frappe ou les erreurs de programmation les plus évidentes.
• C++ est le plus récent et contient quelques améliorations par rapport au C standard qui permettent de simplifier certains aspects de la programmation.
  
• On s'est bien sûr contenté d'utiliser les instructions les plus simples et les plus standard, en général communes aux autres langages.
  
• On fera néanmoins référence à d'autres langages comme C Ansi, Pascal ou FORTRAN 77.
  
• Vous pourrez aussi bénéficier de la considération de vos ami(e)s en leur faisant croire que vous connaissez le C++, ou que vous "faites" du C++  pour reprendre une expression répandue.

Les exemples qui figurent dans ces pages (fichiers XXX.cpp, ".cpp" étant une des extensions autorisées pour le C++) peuvent être exécutés par l'intermédiaire d'un compilateur C++. Ils ont été testés au moyen de  g++, le compilateur c++ de GNU diffusé gratuitement.  g++ est utilisable sur Linux.

Si vous êtes sous WINDOWS, vous pouvez  utiliser l'émulateur d'UNIX CygWin ( http://www.cygwin.com) : CygWin crée une fenêtre alphanumérique sur votre ordinateur, et vous pouvez travailler comme si vous étiez sur UNIX.  On peut aussi utiliser Turbo C ou Visual C++, produit payant de Microsoft. Le choix et l'utilisation du compilateur ne font pas partie des objectifs de ce cours. Même si nous avons une idée précise de ce que sont les produits Microsoft.

Tous les exemples du cours peuvent être téléchargés.  En appuyant sur la touche "shift" de votre clavier,  cliquez  avec le bouton gauche votre souris le nom du fichier incriminé (par exemple hello.cpp )  . Votre navigateur vous propose alors de copier le fichier quelque part sur votre ordinateur. Si vous cliquez sans shifter c'est le contenu du fichier qui apparaît.

Une solution plus rapide consiste à télécharger tous les programmes en une seule fois au moyen du fichier compressé antirouille.tgz .

Vous pouver télécharger les fichiers sources : hello.cpp et definitions.h .

Le programme suivant  écrit une phrase sur votre écran.

• L'exécution d'un programme commence par l'appel du programme principal, qui en C/C++ est une fonction nommée main. (ligne 5). Les instructions (lignes 1 et 3) qui se trouvent avant contiennent de l'information qui complète le programme qui suit.
  
• Le corps du programme, c'est à dire les instructions de la fonction "main",  est délimité par les accollades ouvrantes et fermantes (lignes 6 et 8). On aussi parle de bloc d'instructions.
  
• Les instructions se terminent par un point virgule. Ici la seule instruction (ligne 7) est un appel à la fonction Print. 
• L'argument de la fonction Print est une chaîne de caractères, délimitée par des doubles quotes.
  
• Avant le corps du programme (ligne 3), on trouve une directive d'inclusion. Cette instruction revient à copier le contenu du fichier inclus à l'endroit indiqué. Ce fichier (definitions.h) contient des informations nécessaires au programme. Comme par exemple lui indiquer que la fonction Print est utilisable et  possède un argument.
  
• Pour le moment on ne détaillera pas le fichier definitions.h. Cela fait partie aussi de l'apprentissage de la programmation  : c'est un travail d'équipe qui s'appuie sur des connaissances acquises, que l'on masque pour ne pas encombrer le programme en cours d'écriture.
  
• En ligne 1, on trouve un commentaire délimité par les 2 slashes : // et par la fin de la ligne.
  
• En ligne 6, on trouve une autre forme de commentaire délimité par /* et par */. Un tel commentaire peut donc tenir sur plusieurs lignes.
  

Retour au début

Les déclarations
 

    Déclaration de variables

Un programme est une liste d'instructions permettant de manipuler des variables. Une variable est nommée au moyen d'un identifieur. Un identifieur est une suite de lettres ou de chiffres ou du caractère "_" (nommé underscore ou blanc souligné). Un identifieur doit commencer par une lettre. Dans les langages les plus anciens, (Fortran et Pascal), les majuscules et les minuscules sont équivalentes. En C/C++/Java les mots-clés du langage sont en minuscules.  On se sert du blanc souligné ou de l'alternance majuscule/minuscules pour définir des noms composés. Les caractères accentués sont interdits. 

Identifieurs corrects       :  n, nombre_de_trucs, NomDuTruc, a386, OM, PSG.
Identifieurs incorrects     :  2be3 (commence par un chiffre) , nombre_d'éléphants (à cause des accents et de l'apostrophe)

Une variable possède un type. Ce type est défini lors de la déclaration.

Avant d'être utilisée, une variable doit préalablement être déclarée. C'est lors de la déclaration que l'on nomme les variables qui vont être utilisées, que l'on leur associe un type et éventuellement une valeur initiale.

    Déclarations d'entiers

• Le compilateur oblige de déclarer une variable avant son utilisation. Il est recommandé de l'initialiser aussi. Par exemple si la variable rayon n'est pas initialisée, l'initialisation de la variable diametre est incorrecte. 
  
• On peut initialiser les variables au moyen d'une expression (par exemple diametre=2*rayon). C++ et Java l'autorisent. C Ansi n'autorise que les constantes numériques.
• On peut déclarer les variables à n'importe quel endroit du programme, pourvu que ce soit  avant leur usage. En C, Pascal, et FORTRAN, les déclarations doivent se trouver en début de programme.
  
• En général, pour un entier est implémenté sur un mot de 4 octets, ce qui permet de stocker une valeur de -2147483648 à l2147483647. Il existe d'autres variantes d'entiers en C/C++/Java. Selon que vous souhaitez stocker de plus grandes valeurs ou gagner de la place (stocker sur 2 octets) : short, long, unsigned long et même parfois long long. Les curieux pourront consulter un manuel C. Pour ce cours, on se contentera du type int.

    Déclarations de réels

Il s'agit  d'implémenter des nombre réels, (plus exactement un sous-ensemble des rationnels) sous a forme classique (mantise, exposant). On utilisera le type standard C float. Au niveau de la constante réelle, le point sert à délimiter la partie décimale. L'exposant (puissance de 10) se note au moyen de la lettre "e".  Ainsi 2e+3 correspond à deux dix puissance 3 et vaut 3000.

Retour au début

Les instructions de base
 

    Les affectations

• L'expression est une succession d'opérandes et d'opérateurs (+, _, *, /). Les opérandes peuvent être des constantes, des variables, des appels de fonction, ou des sous expressions entre parenthèses.
• Les variables utilisées dans la partie droite de l'expression doivent être initialisées. Une variable non déclarée est immédiatement détectée par le compilateur. Ce qui n'est pas le cas d'une variable non initialisée. Le problème est qu'on risque une erreur à l'exécution.  Le programmeur doit donc être vigilant.

• Les opérateurs multiplicatifs sont plus prioritaires que les opérateurs additifs. Ainsi dans l'expression  y = a+b*x; la multiplication est effectuée avant l'addition, bien que l'opérateur + soit situé avant le *.
• A priorité égale, c'est le premier opérateur rencontré qui est effectué. Ainsi a/b*c vaut (a/b)*c et non pas a/(b*c).
• En cas de doute, ne pas hésiter à utiliser des parenthèses.

• Il arrive que se produisent des dépassements de capacité. En cas de valeur entière excédant la taille de la variable (par exemple pour un entier "ordinaire" implémenté sur 4 octets, le maximum est de 2147483647) ou  de suite à une division par zéro, le programme s'interrompt brutalement.
  

• La division (opérateur /)  est euclidienne si les 2 opérandes sont entiers, réelle sinon.
• Voir le paragraphe consacré aux conversions entiers /réels et aux dépassements de capacité.
  
• En FORTRAN on trouve l'opérateur puissance noté **. Alors qu'en C/C++/Java, on dispose à cet usage de la fonction pow (power). Dans certains dialectes, on utilise le caractère ^.
  

    Appels de fonctions et de procédures

    Blocs d'instructions

    Instructions conditionnelles

    L'expression conditonnelle

• Dans l'expression E = C1 And C2, si C1 est fausse, E est forcément fausse, mais dans ce cas C2 n'est pas évaluée;
• Dans l'expression E = C1 Or  C2,  si C1 est vraie,   E est forcément vraie,  mais dans ce cas C2 n'est pas évaluée;

    Instructions itératives

    Boucle "while"

    Boucle "for"

    Boucle "do ... while"

    Sélection

• On peut associer un même traitement à plusieurs valeurs. Il suffit de placer plusieurs "case val :" cote à cote.
• Si on ne place pas de break, le traitement se poursuit au "case" suivant.  Sinon on sort du bloc "switch". Comme ce cas de figure est relativement rare, penser à placer un commentaire d'explication.
  
• Ne pas oublier un traitement en cas de valeur non prévue (default).

Retour au début

Le pré-processeur

Si le compilateur analyse le contenu d'un programme, il existe un mécanisme activé avant la compilation proprement dite. Ce mécanisme permet de définir des symboles (directive #define)  ou d'inclure (directive #include) le contenu de fichiers sources à un endroit donné. On peut aussi tester la définition de symboles (#ifdef ou #ifndef ...#endif).

Le mécanisme d'inclusion est très utile, voir indispensable en C/C++, Fortran 77, Pascal,  pour partager de l'information entre plusieurs programmes. Et aussi pour condenser en une seule ligne une grande quantité d'informations. Par exemple l'ensemble des déclarations (fonctions, constantes, ...) système ou communes à un projet ou à un thème donné.

Par exemple en C/C++, si vous utilisez des fonctions de lecture/ écriture sur des fichiers texte, vous devez inclure le fichier stdio.h. Pour ce cours, qui n'est pas un cours de C, les fichiers systèmes utiles sont déjà inclus dans le fichier definitions.h.  Vous pouvez donc ignorer ce genre de détail d'implémentation.

Attentions ce ne sont pas des "instructions" du C, mais des directives lues par un programme qui travaille avant le compilateur. Il n'y a donc pas lieu de les terminer par un point-virgule.

En Java, il n'existe pas de pre-processeur. Comme en FORTRAN 90, le compilateur accède directement à des fichiers compilés pour effectuer ses vérifications. C++ a décidé de remplacer autant que faire se peut les instructions #define par des constantes ou des fonctions en ligne.

En C/C++, il est possible que les includes soient imbriqués. Aussi lorsqu'on crée un include, il est indispensable de mettre en place un mécanisme de "double inclusion"  qui a la forme suivante (voir le fichier  definitions.h)  :

#ifndef _DEFINITIONS_H
#define _DEFINITIONS_H

#include <stdio.h>
#include <string.h>

. . . . . . . . . . . 

Retour au début

Autres déclarations

     Les Constantes (const)

    Les Enumérations (enum)

Il s'agit de définir un type qui  associe à une variable un nombre fini de valeurs.  La syntaxe est la suivante :

    Les booléens (bool)

    Les tableaux

• Si matrix[i][j] est un entier, matrix[i] est un tableau de nbr_cols=3 entiers, et matrix un tableau de nbr_ligs=2 tableaux.
• Les éléments désignés par le dernier indice sont les éléments de plus bas niveau contigus.
• Les éléments matrix[i][j] et matrix[i][j+1] sont contigus.
• On dit aussi que : " le dernier indice varie le plus vite".
• Finalement la disposition des valeurs d'une matrice [ligne] [colonne] correspond à la fois à l'ordre traditionnel mathématique (ligne puis colonne)  et à la disposition écrite  : deux lignes de 3 nombres.
  
•  En Fortran, il existe des tableaux à 2 (voire 3) indices. On écrit directement integer  matrix (nbr_ligs,  nbr_cols),  Mais l'ordre des éléments est différents : ce sont les éléments repérés par le premier indice qui sont contigus.
• Si vous avez un doute sur l'ordre ligne/colonne, faites un programme test.
  

    Les caractères (char)

    Les chaînes de caractères (Cstring)

On notera ce type Cstring (notation propre à ce cours, définie dans le fichier definitions.h). On peut affecter une Cstring au moyen d'une constante de type chaîne de caractères. Une telle constante est constituée d'un ensemble de caractères délimitée par deux doubles quotes. Si une double quote ou un antislash figurent dans la chaîne, on les fait précéder d'un antislash ("/").
.
On peut aussi affecter une chaîne de caractères avec l'adresse nulle : NULL.

C/C++/Java permettent de gérer les chaînes trop longues grâce au mécanisme des "chaînes adjacentes". Si deux chaînes ne sont séparées que par par des "espaces" (blancs, tabulations ou sauts de ligne), elles sont fusionnées.

En C/C++, le contenu d'une chaîne de caractères est équivalent à un tableau de caractères qui se termine par le caractère nul. On peut donc aussi affecter une Cstring au moyen d'un tableau de caractères. On peut aussi appliquer à ce tableau, en plus des opérations classiques des tableaux,  toutes les fonctions dédiées aux chaînes de caractères.  Réciproquement on peut accéder au ième caractère d'une chaîne au moyen de l'opérateur "crochets". Notons que l'on ne peut modifier le contenu d'une chaîne de caractères définie par une constante.

En Fortran le délimiteur est la simple quote et il n'existe pas de distinction entre caractère et chaîne de caractères. Un caractère est une chaîne de longueur 1.

• Les débordements de tableaux de caractères (lors des copies et concaténations).
• L'écrasement du caractère nul.
  
• L'interdiction de modifier une chaîne constante.

    Les structures (struct)

Retour au début

Les fichiers texte (Filetext)

• Un format est une chaîne de caractères contenant quelques caractères spéciaux.
• Le  programme recopie la chaîne caractère par caractère jusqu'à rencontrer un de ces caractères :
• Un % permet d'insérer une valeur figurant dans les arguments de la fonction.

Retour au début

    Généralités

L'entête de la fonction, contrairement au prototypene se termine pas par un point-virgule, mais est immédiatement suivie du corps de la fonction.

Lors d'un appel de fonction  (ligne 14) la démarche est la suivante :

• Les arguments effectifs ( x est y) du programme principal  sont copiés, aprés une éventuelle conversion,  à  la place des  arguments formels (a et b) de la fonction.
• On déroule les instructions de la fonction  (ligne 4) et la valeur calculée est retournée au programme appelant.
•  Les différentes fonctions d'un logiciel peuvent être dans des fichiers séparés. Il est nécessaire qu'un programme appelant connaisse les entêtes des fonctions utilisées. En général on les regroupe dans des includes.
  
• Si la fonction est définie dans le même fichier avant la fonction appelante, il n'est pas nécessaire d'utiliser un prototype.
  

    Arguments variables

En C/C++, les arguments sont copiés. On parle de passage d'argument par valeur. Aussi, si l'on modifie l'un d'entre eux, c'est leur copie qui est modifiée. Alors que les arguments effectifs du programme appelant sont inchangés.Pour pouvoir modifier les arguments, on doit effectuer un passage d'argument par adresse (ou par référence) au moyen de l'opérateur & :

// C++ : Passage d'arguments par référence #include "definitions.h" // ====================================   permuter Procedure permuter (float &gauche, float &droite) {     float   tampon = gauche;     gauche  = droite;     droite    = tampon; } // ====================================  Programme principal main () {                                       float   x =10;     float   y = 15;     permuter (x, y);     Display (x);     Display (y); }

Hormis l'opérateur & devant les arguments formels, rien ne change. Le compilateur gère les adresses des variables dans le programme appelant et le programme appelé. Contrainte : On ne peut passer des constantes ou des expressions par adresse, et on ne peut effectuer de conversion d'argument. Si un argument passé par adresse est de type réel, on ne peut lui fournir une variable entière.  Exemples :

// C++ : Passage d'arguments par référence : erreurs #include "definitions.h" Procedure permuter (float &gauche, float &droite); main () {     float             x = 10;     const float   x = 12;     int                n =  15;     permuter (x,  n);          //  Incorrect, n est une variable entière     permuter (x,  y);          //  Incorrect, y est une constante     permuter (x, 3.14);      //  Idem     permuter (x,  x+1);      //  Incorrect, x+1 est une expression }

En Fortran 77, tous les passages d'argument se font par adresse. en C Ansi, le passage par adresse se fait au moyen de pointeurs, ce qui alourdit un peu les notations. En Pascal, c'est le mot clé var qui remplace l'opérateur &.

    Tableaux passés en argument

En C/C++ (dans les autres langages aussi d'ailleurs) un tableau est équivalent à l'adresse du premier élément de ce tableau.
L'opérateur & n'est donc pas utile. L'instruction  appel_fonction(table)  est équivalente à appel_fonction(&table[0]).
 Il n'est pas non plus nécessaire de préciser sa dimension.. En effet, si le tableau  est déclaré dans le programme appelant et dans la fonction, il n'est défini (associé à un emplacement mémoire) que dans le programme appelant.  Exemple :

// C++ : Exemple de boucle #include "definitions.h" // ========================== main int remplir (int nombre, int table[]) {    for (int ii=0; ii<nombre; ii++)        {        table[ii] = ii*ii;        } } // ========================== main int main () {    const int size = 10;    int table [size];    remplir (size, table);    Display (table[5]); }

.

    Variables rémanentes (static)

    Exemple de fonctions : calcul du pgcd

Retour au début

    Dans un même fichier

• Chaque fonction dispose de ses propres variables et ne peut accéder aux variables locales des autres fonctions que par passage d'arguments.
• On peut déclarer des variables à l'intérieur des blocs. On acccède aux variables du bloc courant et des blocs englobants.
• Il est possible cependant de définir des données globales à plusieurs fonctions. On l'a vu lors des déclarations de types (structures ou énumérations) ou de constantes en tête de fichier.  On peut aussi déclarer des variables globales. On leur attribue le qualificatif Global (notation spécifique à ce cours). En C/C++ c'est l'attribut static qui est utilisé.
  

    Dans plusieurs fichiers (variables externes)

• La variable son_nom est déclarée à la ligne 4 du 1er et du 2ème fichier.
• Elle est définie à la ligne 4 du second fichier.

    Les variables externes ne sont pas indispensables

Retour au début

• déclarer une adresse de variable, aussi nommée pointeur,
• lui fournir un emplacement mémoire disponible, c'est à dire définir ce pointeur,
  
• manipuler la variable référencée par de pointeur.
  

Allocation dynamique de structures

• L'instruction 1 est une déclaration de structure. Ce qui suit est néanmoins valable pour tout type de donnée.
  
• L'instruction 6 est la déclaration du pointeur adrz. Un pointeur est typé. A tout pointeur, on peut associer la valeur particulière NULL qui signifie que l'adresse n'est pas renseignée.
• L'instruction 8 associe à cette adresse (opérateur new) un emplacement mémoire disponible fourni par le système. En C c'est la fonction malloc() qui remplit ce rôle.
• L'instruction 10 montre comment on accède à la valeur dédignée par l'adresse.
• L'instruction 13 est équivalente à l'instruction 10 sous une forme allégée.
• Enfin, une fois que la variable allouée a rempli son rôle dans un logiciel, on la libère (instruction 15) au moyen de l'opérateur delete. Le système considère alors que la  mémoire désignée par l'adresse est disponible. En Java L'opérateur delete n'existe pas. C'est le système qui libère automatiquement la mémoire allouée devenue inaccessible. On appelle ce mécanisme garbage collector ou ramasse miettes.
  
• Après une libération, le pointeur adrz n'a plus de sens : la mémoire désignée n'est plus disponible et peut être attribuée lors du prochaine allocation. On peut donc associer à adrz la valeur NULL.
  

  Allocation dynamique de tableaux

Quelques commentaires :

• Instruction 2 : une adresse de tableau est équivalente à l'adresse du premier élément de ce tableau. 
  
• Instruction 7 :par rapport à l'allocation simple, on indique à  l'opérateur new le nombre d'éléments à allouer.
• Instruction 9 : il n'y a pas de différence entre la manipulation d'un tableau alloué statiquement ou dynamiquement .
• Instruction 12 : Il est important de rappeler les [] lors de la libération de la mémoire.

Remarques :

• En C/C++, un tableau est équivalent au pointeur désignant le premier élément du tableau.
• Le type Cstring, utilisé dans le paragraphe des chaînes de caractères est en fait équivalent à char*
• En C les opérateurs new/delete sont remplacés par deux fonctions : malloc et free.
  

Exemple : gestion d'une liste chaînée

Ce programme (liste_fifo.cpp) est une application directe de l'allocation dynamique. Il s'agit de créer une liste "fifo" ( First In, First Out, c'est à dire qu'on place le dernier arrivé en fin de liste).

// C++ : Gestion d'une liste chaînée #include "definitions.h" struct str_maillon        {        Cstring nom;        str_maillon* suivant;        }; // =========================================== creer_liste str_maillon* creer_liste () {    const int  size_rep = 63;    char reponse [size_rep+1];    str_maillon* tete    = NULL;   str_maillon* queue  = NULL;    while (ReadString (reponse, "Entrez un nom : ", size_rep)>0)          {                                        // Creation d'une copie de chaine          int lg = strlen (reponse);          Cstring name = new char [lg];          strcpy (name, reponse);          str_maillon* elt = new str_maillon;          elt->nom     = name;          elt->suivant = NULL;          if ( tete==NULL) tete              = elt;             else                   queue->next = elt;          queue = elt;          }    return tete; } // ========================================== imprimer_liste Procedure imprimer_liste (str_maillon* tete) {    Print (".... Impression de la liste");    for (str_maillon* elt=tete; elt!=NULL; elt=elt->suivant)        Print (elt-> nom); } // ========================================== detruire_liste Procedure detruire_liste (str_maillon* tete) {    Print ("....Destruction de la liste");    str_maillon* next = NULL;    for (str_maillon* elt=tete; elt!=NULL; elt=next)        {        next = elt->suivant;        delete elt-> nom;        delete elt;        } } // ========================================== Main int main () {    str_maillon* tete = creer_liste ();    imprimer_liste (tete);    detruire_liste  (tete); }

  Utilisation de pointeurs dans la passage d'arguments  variables

On a vu que pour pouvoir modifier un argument d'une procédure, il fallait indiquer dans l'en-tête de la procédure que l'on effectuait un passage par adresse au moyen de l'opérateur & (ligne 4).

// C++ : Exemple de fonction récursive #include "definitions.h" // ======================================== motif_value Procedure motif_value (int &value) {   value = 1515; } // ======================================== main int main () {    int v1 = 0;    modif_value (v1);    Display (v1); }

On peut obtenir un effet équivalent au moyen d'un pointeur.

// C++ : Exemple de fonction récursive #include "definitions.h" // ======================================== motif_value Procedure motif_value (int* value) {   *value = 1515; } // ======================================== main int main () {    int v1 = 0;    modif_value (&v1);    Display (v1); }

Quelques commentaires :

• En ligne 4 on déclare un pointeur sur le type concerné.
• Ligne 6 : on modifie la variable référencée par le pointeur;
• Ligne 12 : l'argument de la fonction étant uun pointeur, on passe en argument l'adresse de la variable au moyen de l'opérateur &.

Cela nécessite plus de manipulations que la technique précédente. C'était cependant la seule disponible en C.

Vous pouvez toujours définir des symboles :

#define Pointerof(type)    type* #define Valueof(addr)     *addr #define Addrof(var)        &var

Retour au début

---

Aspect numérique

    Conversion de types (entiers et réels)

Quand des opérandes de types différents interviennent dans une expression, elles sont toutes converties en un seul type suivant les principes suivants :

• Les types sont ordonnés : par exemple le type réel est considéré comme plus élevé que le type entier.
  
• La conversion d'un réel en entier provoque une troncature de la partie décimale du réel. Il y a dégradation de l'information. Il est possible que le compilateur place un avertissement sur la ligne incriminée.
  
• Pour éviter que le compilateur ne réagisse, utiliser la fonction de conversion n = Integer(x).
  
• Avant l'exécution d'une opération, les deux opérandes sont converties dans le type le plus élevé le résultat étant calculé dans ce type.
• A la fin du calcul de l'expression, le résultat est converti dans le type de la variable de gauche.
  

Exemples :

	Resultat	Commentaire
int valeur = 3.14;	3	Le réel est tronqué.
float valeur = 3;	3.0	L'entier est converti en réel.
float a=6; float b = 16; float valeur = a/10 + b/10;	2.2	a/10 vaut 0.6, b/10 vaut 1.6. La somme vaut 2.2.
float a=6; float b = 16; int valeur = a/10 + b/10;	2	La somme précédente est tronquée à l'entier inférieur. .
int    a = 6; float b = 16; float valeur = a/10 + b/10;	1.6	a/10 est tronqué à 0 (division entière), b/10 vaut 1.6 ;
int    a = 6; float b = 16; int valeur = a/10 + b/10;	1	La somme précédente est tronquée à l'entier inférieur le plus proche.
int a = 6; int b = 16; int valeur = a/10 + b/10;	1	a/10 est tronqué à0, b/10 est tronqué à1 ; ce sont des divisions entières.

    Particularité des réels

Le traitement spécifique des nombre flottants occupe une grande partie du cours d'Analyse numérique.

Si un dépassement de capacité ou une division par zéro provoquent une erreur fatale pour les nombres entiers, ce n'est pas le cas pour les nombres réels. Une norme (IEEE) a associé au type flottant certaines valeurs particulières (+Infini, -Infini, Indeterminé (ou Undefined ou Not a number ou NaN)).  On a défini une arithmétique spécifique qui permet de poursuivre le calcul. Par exemple Infini+infini = Infini, Infini-Infini=NaN, 1/Infini = 0, .... Charge au programmeur de vérifier si le résultat final est un nombre réel ou l'une de ces 3 pseudo valeurs.

L'addition de réels peut provoquer des troncatures. Soit y = a + b. Si a est très grand par rapport à b, la valeur de b est ignorée, et à l'arrivée y et a ont la même valeur.

Les égalités de réels se ramènent souvent à un encadrement : x <= y + epsilon et x >= y - epsilon.

Retour au début

---

Organisation des fonctions dans un logiciel

On le redit : l'appel de fonction est l'instruction la plus importante. Elle permet en une ligne d'effectuer un traitement qui pourrait éventuellement avoir été réalisé en une ou plusieurs milliers de lignes. L'appel de fonction permet (devrait permettre) de regrouper les instructions d'un logiciel en des programmes de taille raisonnable qui devraient donc rester clairs et lisibles.

Si l'on développe un logiciel au sein d'une équipe, ou si l'on souhaite réutiliser certains développements, ou tout simplement si l'on souhaite être capable de relire ce que l'on a écrit avant son départ en vacances, il convient de réfléchir à l'organisation des fonctions

Les différentes fonctions d'un logiciel sont le plus souvent regroupées par catégorie dans des fichiers séparés. Chaque composante concerne un thème particulier et agit sur des données spécifiques. On parle de programmation modulaire.

Chaque composante du logiciel agit sur une autre au moyen de fonctions. Les prototypes de ces fonctions sont contenus dans un include.  Les spécifications de ces fonctions  constituent la partie "visible" ou "publique" d'une composante. Les données internes d'une composante sont "privées" et inaccessibles aux autres composantes. On parle aussi d'encapsulation des données.

La programation dite "objet" n'est que le prolongement de la programmation modulaire. On y ajoute le concept d'"héritage", et on y regroupe fonctions et données dans des "classes".

C++ et Java permettent la mise en oeuvre des concepts objet. Dans ce cours, même si on utilise des syntaxes C++, on n'abordera pas la programmation dite "objet" Pour cela on pourra se référer à l'(excellent) ouvrage de Claude Delanoy. "Programmer en C++". (Editions Eyrolles).

Néanmoins les principes de modularité et d'encapsulation sonr réalisables dans n'importe quel langage. Y compris en Fortran 77. Le but est d'écrire des programmes plus faciles à maintenir, et de confier leur développement à des spéialistes.

Retour au début

  Le Langage C ANSI.                    Philippe Drix.       Editions Dunod.
            Philippe Drix part de Pascal et arrive à C

  Programmer en langage C++.     Claude Delanoy     Editions Eyrolles.
           Claude Delanoy part de C et arrive à C++

  Programmer en langage Java.     Claude Delanoy     Editions Eyrolles.
           Cette fois-ci le point de comparaison est C++

Claude Delanoy a écrit d'autres ouvrages sur le C, Fortran 90. N'hésitez pas à les consulter.

Mais le plus important n'est pas tant de connaître totalement les subtilités d'un langage. C'est même secondaire par rapport à  la connaissance des algorithmes les plus fréquents.

  Algorithmes en langage C    Robert Sedgewick    Editions Dunod    .