chapitre 1 – programmation ccours de programmation c 29/09/2017 lfsi 1 – lari 1 4 les entiers...

Faculté des Sciences de GabesDépartement d’informatiqueCours de Programmation C

29/09/2017

LFSI 1 – LARI 1 1

29/09/2017 1Khaled Hassine

[email protected]

Par :Khaled Hassine

CHAPITRE 1 –PROGRAMMATION C


Opérateurs en C

Affectation

Généralités

Lecture et écriture

PLAN

Types simples en C


Opérateurs en C

Affectation

Généralités


PLAN

Types simples en C



29/09/2017

LFSI 1 – LARI 1 2

Présentation générale du langage C

Le langage C est un langage évolué et structuré, assez proche dulangage machine destiné à des applications de contrôle de processus(gestion d’entrée/sortie, applications temps réel, ...).

Les compilateurs C possèdent les taux d’expansion les plus faibles detous les langages évolués (rapport entre quantité de codes machinegénérée par le compilateur et la quantité de codes machine générée parl’assembleur et ce pour une même application).

Le langage C possède assez peu d’instructions, il fait par contre appelà des bibliothèques, fournies avec le compilateur. On ne sauraitdévelopper efficacement un programme en C sans se munir de ladocumentation concernant ces bibliothèques. A titre d’exemples, nouscitons : math.h : bibliothèque de fonctions mathématiques. stdio.h : bibliothèque d’entrée/sortie standard.

29/09/2017 Khaled Hassine 5

Mots réservés du langage C

Liste ordonnée alphabétiquement des motsréservés du langage C :

auto - break - case - char - 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 -


Structure d’un programme en C

# include <stdio.h> /* Chargement des bibliothèques */#define ............ /* Définition des constantes */void nom_prog() /* Définitions des sous-programmes */{ .........................}...void main() /* Programme Principal */{ int i, j; /* Déclaration des variables */

char n;float résultat;............ ; /* Lignes de programmes (de code)*/............ ; /* Corps du programme */

}


Exemple de programme en C

#define cste 5

void main ()

{ int i ;

i = 10 ;

printf("Bonjour");

}



29/09/2017

LFSI 1 – LARI 1 3

Quelques explications

void main : c'est un mot réservé qui indique qu'il s'agit d'un programmeprincipal et non d'un sous-programme.

() indique que le programme n'admet pas d'argument. Lorsqu'un programmenécessite des paramètres ceux-ci sont placés à la suite du programmeprincipal.

{... } délimitent le début et la fin du programme principale. #define cste 5 ; permet de déclarer une constante nommée "cste" dont la

valeur est 5. int i ; permet de déclarer une variable nommée i de type entier. i = 10; permet d'affecter à la variable nommée i la valeur 10. printf est l'ordre (l'instruction) d'affichage à l'écran. Le message est placé

entre deux doubles cotes ("). Cette instruction n'appartient pas au langage C.Elle appartient à la bibliothèque stdio.h.

; indique la fin d'une instruction ou d'une déclaration.


Remarque

On aurait pu écrire le programme de la manièresuivante :

void main () {#define cste 5 ; int i ; i = 10 ; Printf("Bonjour"); }

Il est claire que la première présentation estmeilleure elle est plus aérée et utilise desindentations sensées, c'est qui améliore lalisibilité.


Quelques conseils

Comprendre le problème complètement. Réfléchissez d'abord, vous programmez plus tard. Bien choisir les identificateurs. Employer les commentaires. Soignez la présentation. Fournir une bonne documentation. Tester un programme à la main avant de l'écrire sur machine

et de l'exécuter. Ne vous occupez pas d'une bonne présentation des résultats

avant que le programme soit fonctionnel et correct. N'ayez pas peur de tout recommencer.


Opérateurs en C

Affectation

Généralités


PLAN

Types simples en C



29/09/2017

LFSI 1 – LARI 1 4

Les entiers


En langage C, le type char est un cas particulier du type entier: uncaractère est un entier sur 8 bits

En décimal les nombres s'écrivent tels que, précédés de 0x enhexadécimal.

Exemple: 127 en décimal s'écrit 0x7f en hexadécimal. Le caractère 257 a pour valeur 1 (ce nombre s'écrit sur 9 bits, le bit de

poids fort est perdu).

TYPE DESCRIPTION TAILLE MEMOIRE Valeurs possiblesint entier standard signé 4 octets - 231 ≤ n ≤231-1unsigned int entier positif 4 octets 0 ≤ n ≤ 232-1short entier court signé 2 octets - 215 ≤ n ≤ 215-1unsigned short entier court non signé 2 octets 0 ≤ n ≤ 216-1char caractère signé 1 octet - 27 ≤ n ≤ 27-1unsigned char caractère non signé 1 octet 0 ≤n ≤ 28-1

Quelques constantes caractères


CARACTERE Rôle VALEUR (ASCII) NOM ASCII'\n' interligne 0x0a LF'\t' tabulation horizontale 0x09 HT'\v' tabulation verticale 0x0b VT'\r' retour charriot 0x0d CR'\f' saut de page 0x0c FF'\\' backslash 0x5c \'\'' cote 0x2c ''\"' guillemets 0x22 "

Exemple de programme

#include <stdio.h> /* bibliothèque d'entrées-sorties standard */#include <conio.h>void main(){ int a, b, calcul ; /* déclaration de 3 variables */

char u, v;puts("BONJOUR"); /* utilisation d'une fonction-bibliotheque */a = 10 ; b = 50 ; u = 65 ; v = ‘A’ ; * affectation* /calcul = (a + b)*2 ; /* affectation et opérateurs */printf(" Voici le resultat : %d\n ", calcul) ;

printf(" 1er affichage de u : %d\n 2ème affichage de u : %c\n ",u, u) ;printf(" 1er affichage de v: %d\n 2éme affichage de v: %c\n ",v, v) ;puts("Pour continuer tapper une touche..."); getch(); /* Attente d'une saisie clavier */

}


Représentation interne des réels

Dite aussi représentation scientifique (Floating Point) Principe : on utilise la notation exponentielle :

A = ± M BE

B : la base M est la mantisse E est l'exposant

Mantisse est normalisée selon l’une de deux formes suivantes : B-1 ≤ M < 1 1 ≤ M < B

Le codage revient à évaluer Signe, Mantisse, Exposant.



29/09/2017

LFSI 1 – LARI 1 5

Les réels : 2 types en C

Représentation interne selon la norme IEEEsimple et double précision


TYPE DESCRIPTION TAILLE MEMOIRE Valeurs possiblesfloat réel standard 4 octetsdouble réel double précision 8 octets

Les initialisations

Le langage C permet l'initialisation desvariables dans la partie déclarative. Ceci peuts’appliquer pour les types char, int, float ...


Version 1 Version équivalentechar c;c = 'A';

char c = 'A';

int i;i = 50;

int i = 50;

Opérateurs en C

Affectation

Généralités


PLAN

Types simples en C


Généralités

Le rôle de l'affectation est d'attribuer une valeur,éventuellement calculée à partir d'une expression, à unevariable (un objet quelconque). En algorithmique, onreprésente une affectation par le symbole ←.

En C, pour décrire une affectation, on utilise le symbole =(égale).

Une instruction d'affectation obéit à la syntaxe généralesuivante : <Identificateur de Variable> = <Identificateur de constante> ; ou <Identificateur de Variable> = <Identificateur de variable> ; ou <Identificateur de Variable> = <Expression arithmétique,

logique ou de traitement de bit> ;



29/09/2017

LFSI 1 – LARI 1 6

Remarques

La partie gauche d'une affectation est toujours l'identificateurd'une variable. En particulier, une constante ne peut jamaisêtre la partie gauche d'une affectation.

Une expression est obtenue en utilisant des opérateursarithmétiques, logiques ou de traitement de bits, selon lecontexte d'utilisation.

Une compatibilité de type et de taille entre les partiesgauche et droite d'une affectation est souhaitable. Toutefois,C permet des affectations (et de façon plus générale desopérations arithmétiques) entre variables de types différents.


Conversions automatiques

L'affectation d'un caractère à un entier : le caractère se retrouve dansl'octet le moins significatif de l'entier. Si le caractère est déclaré detype char, son bit du signe est répété huit fois dans l'octet le plussignificatif de l'entier (ceci est appelé propagation ou expansion dusigne). Il n'y a pas d'expansion de signe si le caractère a été déclaréunsigned char.

L'affectation d'un entier à un caractère engendre la perte de l'octet leplus significatif.

Affectation de int à un long engendre une expansion du bit de signe.Ainsi, 0xA234 donne 0xFFFFA234 et 0x1234 donne 0x00001234.

Dans le cas d'affectation d'un long à un entier, le résultat est tronqué(perte de 2 octets les plus significatifs). Le résultat peut donc êtreerroné.


Conversions automatiques …

L'affectation d'un unsigned int à un long met les deux octetsles plus significatifs du long à 0.

L'affectation d'un int à un float est possible sans aucunproblème, l'entier dévient décimal. Par exemple, 100 dévient100.0.

L'affectation d'un float à un int engendre une perte de la partiedécimale. Il faut toutefois prendre précaution de la limite d'unentier de -32768 à 32767 alors qu'un float peut prendre desvaleurs positives plus élevées et négatives plus faibles.

L'affectation d'un float à un double ne pose aucun problèmealors que l'affectation inverse engendre une perte deprécision.


Exemple

#include <stdio.h>void main (){ char C=0XF2;

int i;long L;float R = 5.4;i = C ;printf("\nLe caractère C : %c\n",C);printf("\ni en décimal est : %d \t\ten Hexadécimal est : %X",i,i);i = 3500;C=i;printf("\ni en décimal est : %d \t\ten Hexadécimal est : %X",i,i);printf("\nC en décimal est : %d \t\ten Hexadécimal est : %X",C,C);i = 0xA234;L==i;printf("\ni en décimal est : %d \t\ten Hexadécimal est : %X",i,i);printf("\nL en décimal est : %d \t\ten Hexadécimal est : %X",L,L);i = R;printf("\ni en décimal est : %d \t\ten Hexadécimal est : %X",i,i);

}



29/09/2017

LFSI 1 – LARI 1 7

Les conversions de types : l'opérateur cast

Le langage C permet d’effectuer des opérations deconversion de type. Pour cela, on utilise l’opérateurde "cast" ( ).

On peut, en effet, demander explicitement laconversion d’une valeur (ou d'une expression) enun type donné.

Cette possibilité est faite en respectant la syntaxeest la suivante :

(<type de conversion>) <expression>


Exemple

#include <Stdio.h>void main (){ int i = 10 , j = 4;

float x ;x = i/j ;/* x = 2.000000 */printf("\nx = %10.3f",x);x = (float) i/j ; /* x = 2.500000 */printf("\nx = %10.3f",x);

}


Incrémentation et décrémentation

L'incrémentation (respectivement décrémentation) d'une variable entièreconsiste à lui rajouter (respectivement lui retrancher) 1. Par exemple, soit iune variable entière, son incrémentation consiste en l'affectation i = i + 1 ; etsa décrémentation en i = i - 1;. Le langage C autorise des écritures simplifiéespour l’incrémentation et la décrémentation des variables. La valeur retournéedépend de la position de l'opérande par rapport à l'opérateur. Il existeessentiellement deux formes : L’opérateur est en suffixe : i++; (respectivement i--) est dite post incrémentation

(respectivement post décrémentation) où l'opération d'affectation est d'abordeffectuée et l'incrémentation (respectivement décrémentation) est ensuiteeffectuée. La valeur retournée est celle avant l'incrémentation (respectivement ladécrémentation).

l'opérateur est en préfixe : ++i; (respectivement --i; ) est dite pré-incrémentation(respectivement pré-décrémentation) où la variable est d'abord incrémentée(respectivement décrémentée) et l'opération d'affectation est ensuite effectuée.


Exemple post incrémentation#include <stdio.h>void main (){ int x, i = 10;

printf("\nAvantincrémentation i : %10d",i);x = i++; /* x = 10 et i =11 */printf("\nApresincrémentation i : %10d\tx: %10d",i,x);}

#include <stdio.h>void main (){ int x, i = 10;

printf("\nAvantincrémentation i :%10d",i);x = i; i = i+1 ;printf("\nApres

incrémentation i :%10d\tx : %10d",i,x);}



29/09/2017

LFSI 1 – LARI 1 8

Exemple pré incrémentation#include <stdio.h>void main (){ int x, i = 10;

printf("\nAvantincrémentation i : %10d",i);

x = ++i; /* i = 11 etx = 11 */

printf("\nApresincrémentation i : %10d\tx: %10d",i,x);}

#include <stdio.h>void main (){ int x, i = 10;

printf("\nAvantincrémentation i :%10d",i);

i = i+1; x=I;printf("\nApres

incrémentation i :%10d\tx : %10d",i,x);}


Les formes abrégées d'affectation : lesopérateurs combinés

Le langage C autorise des écritures simplifiées lorsqu’une mêmevariable est utilisée de chaque côté du signe = d’une affectation.D’une manière générale, l’instruction de la forme :

<id de variable> = <id de la même variable> <opérateur> <expression>; est équivalente à l’instruction

<id de variable><opérateur>= <expression>; Ces écritures sont à éviter lorsque l’on débute l’étude du langage C car

elles nuisent à la lisibilité du programme. Exemple :

a = a + b; est équivalent à a+= b;


Cas particuliers de l'affectation en C.

Il est possible d'enchaîner plusieursassignations, par exemple, i = j = 3 ; où j prendla valeur 3 puis i prend la valeur de j.

Il est possible de définir des blocs d'instructions(avec { et } comme délimiteurs de blocs} et dedéclarer des variables qui n'existent qu'àl'intérieur de ce bloc.


Cas particuliers de l'affectation en C :exemple

#include <stdio.h>void main (){ int i = 10;

{ int i = 2, j = 3 ;printf ("i du bloc : %d \n", i);

}printf("i du main : %d \n", i);

}Le résultat relatif à cet exemple est :

i du bloc : 2i du main : 10



29/09/2017

LFSI 1 – LARI 1 9

Opérateurs en C

Affectation

Généralités


PLAN

Types simples en C


Les expressions et les opérateurs en C

C offre un riche éventail d'opérations qui permettentd'écrire des expressions simples ou complexes. Ondistingue les opérateurs arithmétiques, les opérateurs decomparaison ou relationnels, les opérateurs logiques, lesopérateurs de traitement de bits.

Avant de présenter ces différents opérateurs, soulignonsque l'opérateur sizeof(type) retourne le nombre d’octetsréservés en mémoire pour chaque type d’objet.

Par exemple, n = sizeof(char), n est un entier qui contientalors 1.


Opérateurs arithmétiques.

Les opérateurs arithmétiques permettent de calculer une valeurnumérique à partir d'une expression. Outre les opérateurs décritsdans le tableau 6, C permet l'incrémentation (++), ladécrémentation (--) et la négation unaire (-) qui inverse le signede l'opérande.


Exemple

#include <stdio.h>void main (){ int i = 10 , j = 4 , k; float x ;

k = i+j; /* k = 14*/ printf ("k : %6d \n", k);x = i ; /* x = 10.000000 */ printf ("x : %6.2f \n", x);x = i/j; /* x = 2.000000 */ printf ("x : %6.2f \n", x);x = (float) i/j ; /* x = 2.500000, impose de traiter i comme float*/printf ("x : %6.2f \n", x);k = i%j ; /* k =2*/ printf ("k : %6d \n", k);x = i+x; /* x = 12.500000*/ printf ("x : %6.2f \n", x);

}



29/09/2017

LFSI 1 – LARI 1 10

Remarques

Des opérandes de types différents peuvent apparaître dans une expression arithmétique.Le compilateur C suit les règles suivantes : Les réels de type float sont toujours convertis en double pour assurer une bonne

précision lors du calcul arithmétique. Lorsque les opérandes de la partie droite d'une affectation ont le même type, le

résultat hérite de ce type. Lorsqu'une expression arithmétique comprend des opérandes de types différents, le

compilateur effectue des conversions temporaires automatiques (appelées"promotions") : Les char sont convertis en int (exemple : i = i + '0' ; '0' est convertie en 48 = ox30, son

correspondant en ASCII). Si l'un des opérandes est un double, les autres sont convertis en double et le résultat est un double. sinon si l'un des opérandes est un long signé, les autres sont convertis en long et le résultat est un

long signé. sinon si l'un des opérandes est un unsigned, les autres sont convertis en unsigned et le résultat est

unsigned.

Le programmeur peut néanmoins imposer lui-même une conversion en utilisantl'opérateur de casting ().


Opérateurs de comparaison

Les opérateurs de comparaison (relationnels) s'appliquent à desvariables (ou constantes) numériques ou caractères.


Opérateur Fonction Exemple

! Négation ! (a==b)== Égalité (a==b)!= Différence (a!=b)< Inférieur (a<b)<= Inférieur ou égal (a<=b)> Supérieur (a>b)>= Supérieur ou égal (a>=b)

Opérateurs logiques

Les opérateurs logiques requièrent des opérandesbooléens (vrai ou faux) résultat d'une comparaison etretournent 0 ou 1.

Ces opérateurs sont : && pour ET logique, || (alt gr 6) pour OU logique ! pour négation logique.

Toutes les combinaisons sont possibles entre cesopérateurs.

Ces opérateurs ainsi que les opérateurs relationnels sontutilisés dans les instructions conditionnelle.


Exemple

#include <stdio.h>void main (){ int i, j ;

printf ("introduire i et j ") ;scanf ("%d %d", &i, &j);if (i == j) printf ("égalité entre i et j ");if (i!=j) printf("\ni est différent de j");if ((i>=2) && (i<=10))

printf ("\ni est compris entre 2 et 10 inclus");if ((i>=2) || (i<=10)) printf ("\nC'est toujours vrai");

}



29/09/2017


Opérateurs sur les bits

Les opérateurs de traitement des bits se trouventplus dans les langages d'assemblage que dansles langages de haut niveau. Ces opérateurspermettent la manipulation des informations auniveau bit (test d'un bit, mise à zéro ou à un d'unbit, ...). Ils ne s'appliquent pas aux réels (float etdouble).


Opérateurs binaires …


Opérateur Fonction Exemple& Et binaire (bit/bit) 0x0F & 0X0A retourne 0x0A"!" Ou binaire 0x05 ! 0x0A = 0x0F^ Ou exclusif 0x0f ^ 0x0a donne 0x05<< Décalage à gauche 0x0f <<2 renvoie 0x3c>> Décalage à droite 10 >> 2 renvoie 2 et -10 >> 2 renvoie -2~ Complément à 1 0x05 donne 0xFA

Utilisation particulière des opérateursbinaires

L'opérateur de traitement de bit ET (&) sur chaque paire de bits en même positionpermet de forcer à 0 des bits particuliers d'une donnée. Il permet aussi de tester si unbit ou un groupe de bits est à 1.

L'opérateur de traitement de bit Ou ("!") sur chaque paire de bits en même positionpermet de forcer à 1 des bits particuliers d'une donnée.

L'opérateur ou exclusif (^) permet particulièrement de tester l'égalité entre deuxtermes.

Le décalage à gauche (<<) ou à droite (>>) provoque un décalage (shift) des bits versla gauche ou vers la droite en fonction du nombre spécifié à droite de l'opérateur. Lesbits trop décalés à gauche ou à droite sont éliminés tandis que des bits à zéro arriventpar la droite ou la gauche.

Comme en assembleur, C distingue : Les décalages arithmétiques : ils portent sur desint et préservent le bit de signe (la position binaire d'extrême gauche) lors de décalageà droite, c'est à dire que ce bit se propage de façon à garder le signe de la donnée,même une fois décalée. Ce principe s'applique pour le décalage à droite uniquement.Les décalages logiques qui ne font jouer aucun rôle particulier au bit de signe. Ce typede décalage s'applique au unsigned.


Exemple

#include <stdio.h>main (){ int i = 579, j; /* en binaire 0000 0010 0101 0101 ou 0255H */

unsigned int u, v;printf ("i en hexadécimal : %x - en décimal : %d\n", i, i) ;i= i & 0xFFFE; /* met à 0 le bit de poids faible */printf ("Après ET binaire avec FFFEH \n") ;printf ("i en hexadécimal : %X - en décimal : %d\n", i, i) ;i = 5 ; /* en binaire 0000 0000 0000 0101 ou 0005H */if (i & 0x01) printf ("Le bit de poids faible de %d est à 1\n", i);



29/09/2017


Exemple

j = i<<2; /* décalage à gauche, j = 20 = 14H */printf ("Après décalage à gauche de 2 positions \n") ;printf ("i en hexadécimal : %X - en décimal : %d\n", j, j) ;/* j en binaire 0000 0000 0001 0100 = 20*/i = -3 ; /* en binaire 1111 1111 1111 1101*/printf ("Affectation d'un nombre négatif \n") ;printf ("i en hexadécimal : %X - en décimal : %d\n", i, i) ;j = i<<2; /* décalage à gauche *//* j en binaire 1111 1111 1111 0100 = FFF4H = -12*/printf ("Après décalage à gauche de 2 positions \n") ;printf ("i en hexadécimal : %X - en décimal : %d\n", j, j) ;


Exemple

j = i<<2; /* décalage à gauche *//* j en binaire 1111 1111 1111 0100 = FFF4H = -12*/printf ("Après décalage à gauche de 2 positions \n") ;printf ("i en hexadécimal : %X - en décimal : %d\n", j, j) ;i = -32768; /*1000 0000 0000 0000 */printf ("Affectation de -32768 \n") ;printf ("i en hexadécimal : %X - en décimal : %d\n", i, i) ;j = i >>2 ; /* décalage à droite *//* j en binaire 1110 0000 0000 0000 = E000H = -8192*/printf ("Après décalage à gauche de 2 positions \n") ;printf ("i en hexadécimal : %X - en décimal : %d\n", j, j) ;


Exemple

u = 32768; /*1000 0000 0000 0000 */printf ("Nombre non signé \n") ;printf ("u en hexadécimal : %X - en décimal : %u\n", u,

u) ;v = u >>2 ; /* décalage logique */printf ("Après décalage à gauche de 2 positions \n") ;printf ("u en hexadécimal : %X - en décimal : %u\n", v,

v) ;/* v en binaire 0010 0000 0000 0000 = 2000H = 3192*/

}


Résultat de l’exécution



29/09/2017


Ordre de préséance

Dans les expressions complexes qui impliquentplus d'un opérande, la présence de cesopérateurs détermine l'ordre dans lequel se feral'évaluation. En utilisant les parenthèses, leprogrammeur peut forcer l'ordre de préséance.


Priorité des opérateurs


Fonction OpérateurAffectation = += -= /= %= <<= >>= &= ^= !=Or logique !!Et logique &&Ou sur les bits !Xor sur les bits ^Et sur les bits &Égalité et différence == !=Inégalité < <= > >=Décalage des bits << >>Addition/soustraction + -Multiplication/division * / %Négation/incrément ! ~ -- ++ (type) sizeofAppel de, membre de () []

Arbre d’évaluation

Une expression peut être représentée par unarbre d'évaluation. C'est le résultat de l'analysed'une expression. Les parenthèses permettent depréciser l'ordre d'évaluation des opérations.


Exemple d’arbre d’évaluation

X = A * B + C / (D -F) - G

Cette affectation correspond aux parenthèses suivantes :

X = (((A * B) + (C / (D -F))) - G)

Ceci correspond à l'arbre d'évaluation suivant :



29/09/2017


Opérateurs en C

Affectation

Généralités


PLAN

Types simples en C


Entrées sorties standards

On sous-entend par entrée : lecture, par sortie : écriture etpar standards : clavier et écran. Les opérations de lectureet d'écriture standards correspondent en effet, auxtransferts d'informations entre la mémoire centrale (siègedu programme et des données) et les organespériphériques standards (le clavier et l'écran). Cesopérations sont indispensables pour vérifier qu'unprogramme donne les résultats attendus.

En C, les fonctions printf et scanf permettentrespectivement l'écriture et la lecture.


L'écriture : la fonction printf

L'action d'écriture affiche sur l'écran, les valeurs des variables, desconstantes ou des expressions arithmétiques indiquées dans l'ordre dela liste de paramètres. Cette action élémentaire ne modifie pas lecontenu des objets passés en paramètre. En C, la fonction printftraduit l'action de lecture. Cette fonction n’est pas une instruction delangage C, mais elle est décrite dans la bibliothèque stdio.h. Ellepermet l’affichage des nombres et/ou du texte sur l’écran. La syntaxegénérale de la fonction printf est :

printf (<format de contrôle>, <Objet 1> , <Objet 2>, ... , <Objet N>) ; La partie <format de contrôle> peut inclure un texte

d'accompagnement à afficher intercalé par des formats d'affichage(entier, décimal, représentation scientifique, nombre de positionsd'affichage, etc.).


Format d’affichage

Chaque format d'affichage introduit dans la zone decontrôle doit être précédé du caractère % suivi d'uncaractère indiquant le type de contrôle.

Les caractères de contrôle (par exemple \n pour saut deligne) présentés précédemment peuvent être utilisés dansla partie contrôle.

Ainsi, le format d'affichage pour un objet est le suivant :printf(" %<format>", <nom de variable>);

Les formats %x, %X, %o sont applicables sur tous lestypes. L’affichage en hexadécimal est en minuscule pourx et en majuscule pour X.



29/09/2017


Le formatage en sortie des entiers


Contrôle Type des entrées Format des sorties%d int signed decimal integer%o int unsigned octal integer%i int signed decimal integer%x ou %X int unsigned hexadecimal int%u unsigned int unsigned decimal integer%D long%U unsigned long

Formatage en écriture

On peut aussi placer entre le % et le caractère de contrôled'affichage : le caractère + pour faire précéder l'entier de son signe, un espace pour le faire précéder du signe - s'il est négatif et

d'un espace s'il est positif, un chiffre qui indique le nombre de caractères d'affichage

(des blancs sont éventuellement insérés en tête). Si on précède le nombre par un 0 en tête, on remplit les positions non

occupées par des 0. Si ce chiffre est précède du signe -, on obtient un cadrage à gauche

suivi des blancs pour les positions non occupées (des blancs sontéventuellement insérés en fin).

Si le dimensionnement est insuffisant, il est ignoré.


Exemple (int i = 1234)

Instructions Affichageprintf ("ZZ%dZZ", i); ZZ1234ZZ

printf ("ZZ%3dZZ", i); ZZ1234ZZ

printf ("ZZ%5dZZ", i); ZZ 1234ZZ

printf ("ZZ%07dZZ", i); ZZ0001234ZZ

printf ("ZZ%-7dZZ", i); ZZ1234 ZZ

printf ("ZZ%+7dZZ", i); ZZ +1234ZZ


Le formatage en sortie des caractères

Les caractères de formatage des caractères sont : cpour un caractère simple et s pour les chaînes decaractères.

Un caractère peut aussi être affiché en décimal(%d), en octal (%o) ou en hexadécimal (%x ou%X).

Les caractères de contrôle sont affichés en lesfaisant précéder du caractère slash(\).

Dans le cas où on veut afficher un %, il faut ledédoubler (%%).



29/09/2017


Formatage des caractères - Exemple : charc = ‘A’

Instructions Affichageprintf ("ZZ%dZZ",c); ZZ65ZZprintf ("ZZ%4xZZ", c); ZZ 41ZZprintf ("ZZ%cZZ", c); ZZAZZprintf ("ZZ%3cZZ",c); ZZ AZZprintf ("ZZ%-3cZZ", c); ZZA ZZprintf("Guillemets : \" " Guillemets : "printf(" Pourcents : %% " Pourcents : %


Le formatage en sortie des réels

Pour la représentation en virgule fixe, le caractère de contrôle est %f. Si onsouhaite un positionnement, le format est le suivant :

%<nombre de places>.<nombre de chiffres après la virgule>fPar exemple, %6.2f : indique qu'il faut afficher le réel sur 6 places réservées(dont 1 pour le signe s'il est négatif) et 2 après la virgule.Si le dimensionnement est insuffisant, il est ignoré.Il est également possible de spécifier dynamiquement le nombre de caractèresd'affichage en remplaçant les constantes par des étoiles (*) dans la zone decontrôle et en passant ces valeurs en arguments.

Pour la représentation scientifique, le caractère de contrôle est %e ou %E (lecaractère de contrôle sera affiché en minuscule pour e et en majuscule E).Dans le cas où le réel à afficher serait un double, il faut précéder le caractèrede contrôle de la lettre l.


Exemple : float x = 1.5 ; int i = 6, j=3

Instructions Affichageprintf ("ZZ%eZZ", x); ZZ1.500000e+000ZZ

printf ("ZZ%EZZ", x); ZZ1.500000E+000ZZ

printf ("ZZ%fZZ", x); ZZ1.500000ZZ

printf ("ZZ%6.3fZZ", x); ZZ 1.500ZZ

printf ("ZZ%-6.3fZZ", x); ZZ1.500 ZZ

printf ("ZZ%3.0fZZ", x); ZZ 1ZZ

printf ("ZZ%*.*fZZ", i,j,x); ZZ 1.500ZZ


Autres fonctions de sorties

Pour l'affichage d’un caractère, on peut utiliser la fonctionputchar qui permet d’afficher un seul caractère. Si c’est unevariable de type char alors l’écriture putchar(c); estéquivalente à printf("%c",c);

Pour l'affichage d’un texte, on peut utiliser la fonction putsqui permet d’afficher une chaîne de caractères. Par exemple,puts("Bonjour"); est équivalente à printf("Bonjour\n");

Remarque : Il vaut mieux utiliser les fonctions puts et putcharsi cela est possible. Ces fonctions non formatées sontd’exécution plus rapide et occupe moins de place enmémoire.



29/09/2017


La lecture

L'action de lecture affecte successivement lesvaleurs lues à partir du clavier aux objets passés enparamètre (aux variables indiquées).

Ceci permet de fournir des données au moment del'exécution du programme.

En effet, lors de l'exécution d'une action de lecture,l'ordinateur est en attente que toutes les valeursnécessaires soient fournies sur le dispositif d'entréepour les affecter aux variables de la liste enrespectant l'ordre indiqué.


La fonction scanf

En C, la fonction scanf est l'analogue de printf en entrée. Elle effectueune conversion entre le format utilisé lors de la saisie (sous forme decaractères ASCII) et la représentation en interne de la variable.L'opération de conversion s'arrête au premier caractère qui necorrespond pas au type spécifié (par exemple une lettre ou un espacepour un entier).

La syntaxe C de scanf est la suivante :scanf (<format de contrôle>, <Objet 1> , <Objet 2>, ... , <Objet N>) ;

La fonction scanf, appartenant à la bibliothèque stdio.h, permet lasaisie au clavier de n’importe quel type de variable. Les variables àsaisir sont formatées. Chaque identificateur d'une variable scalaire doitêtre précédé du symbole & (et commercial ou ampersand) désignantl’adresse de la variable. La saisie s’arrête avec l'appui sur la touche devalidation “RETURN” (LF).


Flux d’entrée

Lorsqu’on saisit au clavier une suite de caractères terminés par“ RETURN ”, ces caractères sont rangés dans un tampon de typeFIFO (First In First Out). Le dernier caractère rangé dans le tamponest RETURN (code ASCII 0x0A). Cette suite de caractères est appeléflux d’entrée.

La taille de tampon dépend de la machine et du compilateur utilisés.Sur un PC et en Turbo C, la taille du tampon est de 127 caractères.Une compilation du programme vide le tampon. Ceci permet de saisirplusieurs données (séparées au moins par un blanc) sur une mêmeligne (un seul retour de chariot).

Les éléments saisis s’affichent à l’écran (saisie avec écho). scanf va chercher les données dans flux d'entrée sans le vider (c'est le

cas où on introduit plus de données que n'en s'attend).


Formats de contrôle

Les formats de contrôle sont identique à ceux de la fonctionprintf (sauf que * permet de sauter un objet, par exemple %*dpermet de sauter un entier dans la chaîne saisie).

Les blancs en tête d'une chaîne saisie sont ignorés sauf pour leformat %c.

Pour une chaîne de caractères, la recherche s'arrête au premiercaractère blanc ou au retour chariot.

Les caractères espace et tabulation sont considérés commedes séparateurs.



29/09/2017


Exemple

#include <stdio.h>void main (){ int i;

float x ;printf ("introduire i et x ") ;scanf ("%d %f", &i, &x);printf("\ni : %d \t\tx :

%f",i,x);}


Exemple 2

#include <stdio.h>void main (){ int i, j; float x ; char nom[50];

printf ("introduire i , x, nom : ") ;scanf ("%2d %f %*d %x %2s", &i, &x, &j,

nom);printf(" i : %d \n x : %f\n j : %d\n nom : %s \n",

i, x,j, nom);}


0123 est l'entier ignoré et la fin de lachaîne est aussi ignorée.

Remarques Si l’utilisateur ne respecte pas le format indiqué dans scanf, la

saisie est ignorée et aucune erreur n’est générée. Exemple :#include <stdio.h>main (){ char car;

scanf (" %d " , &car);} Dans ce cas, si l’utilisateur saisi 97 tout va bien car c’est le

code ASCII de 'a'. Par contre, si on tappe le caractère 'a', lasaisie est ignorée.


Remarque s…

Comme signalé précédemment, la fonctionscanf permet la saisie simultanée de plusieursvariables séparées par un caractère séparateur.Ce caractère est précisé lors du formatage de lafonction. Les caractères séparateurs sont tous lescaractères ASCII à l’exception %.



29/09/2017


Exemple 1 : Saisie de deux entiers séparéspar une virgule

#include <stdio.h>void main(){ int a=1111,b=2222 ;

printf("Enter deux entiers séparés par une virgule : ");scanf ("%d,%d" , &a , &b );printf("\na : %d\t\tb : %d",a, b);

} La saisie s’achève sur retour chariot. Si l’utilisateur ne saisit qu’un

nombre, la deuxième spécification de format est ignorée et aucuneerreur n’est générée. Aussi, si on ne respecte pas le format demandé,l’entier n’est pas modifié. Dans ce qui suit deux exécutions différenteavec et sans respect du format exigé (le point virgule).


Résultat de l’exécution


La fonction getchar

La fonction getchar, appartient à la bibliothèque stdio.h. Elle permetla saisie à partir du clavier d’un caractère (char

#include <stdio.h>void main(){ char c;

printf("Introduire un caractère : ");c = getchar();printf ("\nVoici le caractère saisi : %c " , c);

} La fonction getchar est moins gourmande en place mémoire que scanf

car elle est non formatée. Il vaut mieux l’utiliser quand cela estpossible. getchar utilise le flux d’entrée comme scanf.

29/09/2017 Khaled Hassine 75 29/09/2017 76Khaled Hassine

chapitre 1 – programmation ccours de programmation c 29/09/2017 lfsi 1 – lari 1 4 les entiers...

Documents