Cours C++ Saisie de nombres et de caractères au clavier
...
1.3 Identificateurs
Un identificateur se définit comme un nom donné à un élément du programme tels que les variables, les types, fonctions et les labels.
L’identificateur est crée en le spécifiant dans la déclaration d’une variable, type ou d’une fonction. Dans l’exemple suivant, Valeur1, Valeur 2 et Somme sont des identificateurs de variables entières, et main() et printf() sont des identificateurs de fonctions.
#include<stdio.h>
void main()
{
int Valeur 1 , Valeur 2, Somme ;
Valeur 1 = 10
Valeur 2 = 20
Somme = Valeur 1 + Valeur 2 ;
Printf (“ Somme = %d”, Somme) ;
}
Une fois déclaré, on peut utiliser l’identificateur, plus tard, dans une instruction de programme pour se référer à la valeur associé à cet identificateur.
Les identificateurs se composent de lettres, de chiffres ou du caractère souligné dans n’importe quel ordre, pourvu que le premier caractère soit une lettre ou le caractère souligné. Le compilateur C fait une distinction entre les majuscules et les minuscules, par exemple valeur et Valeur sont deux identificateurs différents.
J, nombre_jour, ENTIER sont des identificateurs valides
Valeur 1 : invalide contient la caractère espace
7 somme : invalide car le premier caractère est un chiffre
1.4 Constantes
Il est souvent commode d’associer un élément de donnée simple, tel qu’une valeur numérique, un caractère ou une chaîne de caractère, à un identificateur, attribuant ainsi un nom à l’élément de donnée. On appelle l’identifcateur une constante si on lui attribue l’élément de donnée de manière définitive (la valeur reste inchangée tout au long du programme)
1.5 Le commentaire
Les commentaires sont des textes servant à annoter un programme. Ils ne présentent d’utilité que pour le programmeur, et ils sont supprimés logiquement du fichier source avant la compilation.
Il y’ a deux façons de délimiter les commentaires, soit par la paire ** lorsque le commentaire est écrit sur plusieurs lignes, soit // pour débuter une ligne de commentaire jusqu’à la fin de la ligne.
1.6 Les séparateurs
Crochets [] : les crochets ouvrants et fermants [ ] servant à spécifier un indice d’accès à un tableau mono ou multi-dimensios.
Char Ch, Str[]= “ Bonjour ” ;
Int Mat[3] [4] ; //matrice 3x4
Ch=Str[3] ; //ch=’n’
Parenthèses () : Les parenthèses permettent de grouper des expressions, d’isoler des expressions conditionnelles et d’indiquer des appels de fonctions et des paramètres :
X = (a+b)/c ; // remplace la priorité normal
if (a= =0) ; // utilisation dans une instruction conditionnelle
Fonc() ; // appel d’une fonction
Accolades {} : Le couple d’accolades permet d’indiquer le début et la fin d’un bloc d’instruction.
if (x !=5)
{
x++ ;
fonct(x) ;
}
Virgule : La virgule sépare les éléments d’une liste d’arguments d’une fonction :
Int somme (intx, int y) ;
Point-virgule ; Le point-virgule est le terminateur d’instruction. Toute expression légale en C (y compris l’expression vide) qui est suivie par le signe ; est interprétée en tant qu’instruction.
Deux-points : Le signe deux-points permet une instruction avec label :
Debut : x=0 ;
goto Debut ;
Les deux principales parties des programmes C++ sont les fichiers sources et les fichiers en-tête. Les fichiers sources contiennent les paries principales du programme. C’est dans les fichiers sources qu’on définit les routines, les données et les instructions.
Parfois, les fichiers sources empruntent les routines et fonctions d’autres fichiers sources ou de bibliothèque. Pour que ces routines soient reconnues par le compilateur, on doit déclarer dans le fichier principal des fichiers d’en-tête. Le fichier d’en-tête indique au compilateur les noms et caractéristiques des routines. Par exemple pour calculer 510 , on doit faire appel à la fonction pow qui est déclarée dans le fichier à inclure math.h
2.1 Structure de base des programmes C++
L’exemple suivant est un programme C++
/*
*PROGRAMME 1
*Fichier : affichev.cpp
*Auteur : Mustapha AIT MAHJOUB
*Date : 10/09/1999
*Description : Ce programme affiche un message sur l’écran
*/
#include<stdio.h>
void main()
{
// Affichage d’une chaîne
printf(’’Ce ci est un programme C++/n’’) ;
}
Regardons sa structure. Le texte entre /* et */ est un commentaire. Main() est une fonction. Tout programme C++ est un ensemble de fonctions dont une et une seule doit s’appeler main(). Le mot clé void indique au compilateur que la fonction main ne renvoie aucune valeur.
Si la programme doit renvoyer une valeur au système d’exploitation. Le programme précédent s’écrira :
/*
*PROGRAMME 2
*Fichier : affichei.cpp
*Auteur : Mustapha AIT MAHJOUB
*Date : 10/09/1999
*Description : Ce programme affiche un message sur l’écran et retourne une valeur au dos
*/
#include<stdio.h>
int main()
{
// Affichage d’une chaîne
printf(’’Ce ci est un programme C++/n’’) ;
return(0) ;
}
En effet, il se peut que le système d’exploitation s’intéresse à la valeur renvoyée par main(). Par convention, 0 signifie succès, et toute valeur de retour non nulle désigne une erreur rencontrée durant l’execution du programme.
Les accolades { } marquent le début et la fin de la fonction main (). Les chaînes de caractères comme ’’Ce ci est un programme C++\n ’’ sont délimitées par des guillemets. \n est le caractère retour à la ligne. La fonction printf ( )affichera la chaîne de caractères sur l’écran. // débute une zone de commentaire qui s’étendra jusqu’à la fin de la ligne. En fin, #include <stdio.h> donnera au préprocesseur l’ordre d’inclure les lignes présentes dans le fichier d’en-tête stdio.h à l’intention du compilateur. Ce fichier contient, entre beaucoup d’autre, la déclaration de la fonction printf ().
Le type de données caractérisent des variables et des constantes en définissant leurs plages de valeurs et les opérations que l’on peut faire dessus. Le type indique en plus le nombre d’octets consécutifs sur les quelle s’étale la valeur. Une variable de type int (entier), par exemple occupe un mot de 2 octets sous DOS.
Les types de données se décomposent en deux catégories : les types prédéfinis et les types personnalisés. Les principaux types de C++ sont :
- type entier
- type réel
- type structuré
- type énumératifs
3.1 Données de type entier
Les données de type entier sont des objets avec un nombre complet (entier).Ces catégories incluent les constantes de type entier, les variables, les fonctions et expression.
Le tableau suivant donne les types entiers prédéfinis de C++, avec leurs tailles et leurs plages de valeurs relatives à l’environnement 16 bits.
Type Plage de valeurs Taille
char -128 à127 1 octet
unsigned char 0 à 255 1 octet
short -215 à +215-1 2 octets
unsigned short 0 à216 2octets
int -215 à215 –1 2 octets
unsigned int 0 à 216 –1 2 octets
long -231 à +231 4 octets
TABLEAU 2 : Types entiers
C++ permet de spécifier des valeurs octales ou hexadécimales.
- Constante octale : elle commence par ‘0’’ (Zéro)
- Constante Hexadécimale : elle commence par ‘0x’’
I = 20 // 20 en décimal
I = 024 // 20 en octal
I = 0x14 // 20 en hexadécimal
3.2 Données de type réel
Les données de type réel se rapportent aux éléments de données qui représentent des objets numériques réels. Ceci inclut les constantes de type réel. Les variables, fonctions et expressions. Les types réels standards de C++ sont les suivants :
Type Taille
Float
Double
Long double 4 octets
8 octets
10 octets
TABLEAU 3 : Types réels
Les nombres réels peuvent s’écrire soit sous la forme classique (par exemple 3.14), soit sous la forme scientifique (par exemple 2.45 E-5).
4.1 Variables
Une variable est un identificateur qui permet de représenter une valeur modifiable. Une variable possède un nom qui doit être unique dans un certain domaine (portée). Outre le nom, une variable doit posséder un type de donnée précisant au compilateur, le nombre d’octets à allouer à la variable.
Une variable doit être déclarée, n’importe où dans le code, avant son utilisation dans le programme.
Int Somme ; //déclaration d’une variable qui a pour nom somme et
//comme type, le type entier
float x, Delta; // déclaration de deux variables de typ réel.
Char c ; // déclaration d’une variable de type caractère
L’écriture des noms de variable doit respecter les règles d’écriture des identificateurs. Lorsqqu’on définit une variable, on peut lui fournir en même temps une valeur initiale. C’est cette valeur que la variable aura lors de sa première utilisation.
Int Somme =0 ; // déclaration et initialisation des variables
Float x=10, Delta=12.3 ;
Char c=’’0’’ ;
4.2 Constantes
Il est souvent commode d’associer un élément de donnée simple, tel qu’une valeur numérique, à un identificateur, attribuant ainsi un nom à l’élément de donnée. On appelle l’identificateur une constante si on lui attribue un élément de donnée de manière définitive (la valeur reste inchangée tout au long du programme).
On pourrait considérer une constante comme une variable qui, une fois, initialisée, peut être lue mais non modifiée.
Les déclarations des variables et des constantes se ressemblent. La seule différence consiste en la présence du mot clé const.
Const int NombreMax= 100 ;
Const float SalaireMin= 1500.00 ;
/*
*PROGRAMME 3
*Fichier : surface.cpp
*Auteur : Mustapha AIT MAHJOUB
*Date : 10/09/1999
*Description : Ce programme calcule et affiche la surface d’un cercle
*/
#include<stdio.h>
void main()
{
const Pi = 3.14 ; //Pi est une constante
float Rayon = 10.0 ; //Rayon est une variable initialisée à 10
printf (‘’surface = %.2f’’, Pi*Rayon) ; //affiche la surface du cercle
}
5.1 Fonction printf ()
On utilise la fonction printf() pour afficher des données sur l’écran. Les éléments de données de sortie peuvent être des chaînes de caractères, des constantes numériques ou les valeurs de variables et d’expressions.
5.1.1 Sortie formatée
Le spécificateur de format ou formateur (comme %d ou %c) sont utilisés pour contrôler le format qui sera utilisé par printf() pour afficher une variable particulière. En général, le formateur doit correspondre au type de la variable à afficher. Nous utilisons, par exemple, le formateur %d pour afficher un entier et %c pour afficher un caractère. La liste suivante fournit les formateurs pour printf() et scanf() ;
Formateur Description Printf() Scan()
%c Un seul caractère X X
%s Chaîne de caractères X X
%d Entier signé X X
%f Réel (notation décimale) X X
%e Réel (notation exponentielle) X
%g Réel (notation décimale) X
%u Entier non signé (décimal) X
%x Entier non signé (hexadécimal) X
%o Entier non signé (octal) X
1 Préfixe utilisé avec %d, %u, %x, %o pour spécifier un entier long X
TABLEAU 4 : Caractères formateurs
Le programme suivant affiche l’entier i et le réel x avec les différents formats
/*
*PROGRAMME 4
*Fichier : format.cpp
*Auteur : Mustapha AIT MAHJOUB
*Date : 10/09/1999
*Description : Ce programme affiche un entier et un réel sous différents formats
*/
#include<stdio.h>
void main()
{
int i = 255 ;
float x = 10.0 ;
printf (‘’%d %u %x %o\n’’,i,i,i,i) ; //affichage d’un entier sous différents formats
printf (‘’%f %e %g \n’’,x,x,x) ; //affichage d’un réel sous différents formats
}
5.1.2 Largeur du champ
Considérons le programme suivant :
/*
*PROGRAMME 5
*Fichier : champ.cpp
*Auteur : Mustapha AIT MAHJOUB
*Date : 10/09/1999
*Description : Ce programme affiche un réel sous différents longueur de champs
*/
#include<stdio.h>
void main()
{
float x = 10.56 ;
printf (‘’x = %f\n’’ ,x) ; //affiche 10.560000
printf (‘’x = %5.2f\n’’,x) ; //affiche 10.56
printf (‘’x = %8.3f\n’’ ,x) ; //affiche 10.560
}
Nous remarquons que la variable x est affichée, avec la première fonction printf (), avec 6 chiffres après la virgule alors que deux seulement de ces chiffres sont significatifs. Pour supprimer les zéros insignifiants, nous avons inséré la chaîne 5.2 entre le caractère % et f (seconde fonction printf()). Le nombre après le point décimal précise le nombre de caractères qui seront affichés après le point décimal. Le nombre qui précède la point spécifie l’espace à utiliser pour contenir le nombre lorsqu’il sera affiché.
5.1.3 Séquences d’échappement
Dans les exemples précédents, nous avons utilisé le caractère “/n” dans la chaîne de format pour insérer un retour à la ligne suivante. Le caractère nouvelle ligne /n est un exemple de séquence d’échappement. La liste suivante montre les principales séquences d’échapppement :
Séquence Description
\n Nouvelle ligne
\t Tabulation
\b Retour en arrière avec effacement
\r Retour chariot
\’ Caractère apostrophe
\’’ Caractère guillemet
\\ Caractère anti-slash
\xdd Code ASCII Hexadécimal
\ddd Code ASCII décimal
TABLEAU 5 : Séquences d’échappement
5.2 Fonction scanf()
On utilise cette fonction pour lire des données, de différents types, à partir du clavier. Voici un exemple utilisant la fonction scanf() :
/*
*PROGRAMME 6
*Fichier : var_con.cpp
*Auteur : Mustapha AIT MAHJOUB
*Date : 10/09/1999
*Description : Ce programme lit une valeur et calcule une expression
*/
#include<stdio.h>
#include<conio.h>
void main()
{
clrscr() ;
const int JoursAn = 365 ;
float Annees, NombreJours ;
printff(‘’Entrez votre age :’’) ;
scanf(‘’%f’’ ,&Annees) ;
NombreJours = Annees*JoursAn ;
printf(‘’Votre age en nombre de jours = %.1f jours\n’’ ,Nombre Jours) ;
getch() ; //attend que l’utilisateur appuie sur une touche
}
Nous remarquons que le format de scanf () ressemble beaucoup à celui de la fonction printf () (voir tableau 4). Comme pour printf () l’argument à gauche est une chaîne qui contient le formateur ‘’%f’’ et à droite le nom de la variable &-annee. La fonction scanf () reçoit comme paramètre l’adresse de la variable annees d’où la présence de l’opérateur d’adresse &.
Une expression est un groupe d’opérandes liés par certains opérateurs pour former un terme algébrique qui représente une valeur. Il y’ a deux sortes d’expression : numérique et logique. Une expression numérique donne comme résultat une valeur numérique, alors qu’une expression logique représente une condition qu’est vraie ou fausse.
6.1 Opérateurs arithmétiques
Ils sont utilisés pour effectuer des opérations de type numérique. Le tableau suivant décrit cinq opérateurs très courants qu’on peut utiliser pour créer des expressions numériques
Opérateurs Signification
+
-
*
/
% Addition
Soustraction
Multiplication
Division
Reste de la division
TABLEAU 6 : Opérateurs arithmétiques
L’opérateur de division/ appliqué à des entiers donne un résultat entre de sorte que plusieurs divisions différentes peuvent donner le même résultat.
int resultat ;
resultat=3/3 ; //resultat = 1
resultat = 4/3 ; //resultat = 1
Si l’on ne désire pas perdre le reste, on peut employer l’opérateur %. Ce dernier, dont l’utilisation est réservée aux entiers, calcule le reste de la division de deux nombres.
int reste ;
reste = 3 % 3 ; // reste = 0
reste = 4 % 3 ; // reste = 1
Le programme 7 calcule le polynôme ax2 + bx + c
/*
*PROGRAMME 7
*Fichier : polyncpp
*Auteur : Mustapha AIT MAHJOUB
*Date : 10/09/1999
*Description : Ce programme calcule l’expression ax2 + bx + c
*/
#include<stdio.h>
#include<conio.h> //pour clrscr() et getch()
void main()
{
clrscr() ;
float a,b,c,x,y ;
scanf(’’%f %f %f %f’’ , &a, &b, &c, &x) ;
y = a* x* x + b* x + c ;
printf (‘’ax*x + bx + c = %g\n’’,y) ;
getch() ;
}
6.2 Opérateurs de manipulation
Les opérateurs de bits agissent au niveau du bit. Les opérandes de ces opérateurs ne sont plus des entiers ou des caractères, mains tous simplement une suite de bits. Un opérateur de bits permet de manipuler les bits individuellement en les positionnant soit à 1 soit à 0. Les opérandes doivent être de type entier. Les opérateurs du tableau 7 suivant permettent d’agir sur des bits particulièrement à l’intérieur d’une variable.
Opérateur Signification Exemple
x = 15 ou x = 1111 ou x = 0xF
~ Non(complément) y = x y = 0xfff0
<< Décalage à gauche Y = x <<2 y = 0x3c
>> Décalage à droite y = x >> 2 y = 3
& ET binaire y = x & 0xa y =0xa
| OU binaire y = x | 0xa y = 0xf
^ OU-Exclusif y = x ^ 0xa y = 5
TABLEAU 7 : Opérateurs de manipulation
6.3 Opérateurs d’incrémentation / decrémentation
L’expression n++ utilise l’opérateur d’incrémentation ++ qui a pour effet d’ajouter 1 à n. Ces opérateurs regroupent deux fonctionnalités : l’effet de bords qui est l’incrémentation ou la decrémentation, et la valeur qu’ils renvoient lorsqu’ils sont utilisés dans des expressions. Cette dernière dépend de la position relative du ++ ou du – par rapport à son opérande, par exemple si a = 5
b = 2*a++ // b =10, a = 6
b = 2*++a // a =7, b =14
b = ++a-2 // a = 8, b = 6
b = 10 –(- -a) // a = 7, b =3
6.4 Opérateur sizeof ()
Cet opérateur renvoie la taille , en nombre d’octets, de l’expression au du type syntaxe :
seizeof< expression> Ou Sizeof( <type>)
Exemple : Sizeof (int) renvoie le nombre d’octet qu’occupe un entier
Les expressions booléennes prennent des valeurs de vérité vraies ou fausses. Bien que nous parlions de valeurs logiques « vraie » et « fausse » n’oubliant pas qu’en fait ce ne sont que des valeurs numériques entières. Si le résultat de l’expression booléenne est 0, l’expression est fausse. Si le résultat est différent de zéro, l’expression est vrai.
7.1 Opérateurs de comparaison
Les opérateurs de comparaison sont tous des opérateurs binaires : ils relient deux opérandes. Le résultat de comparaison soit vrai(non nul), soit faux( nul).
Le tableau suivant décrit les opérateurs de comparaison.
Opérateur Signification
< Inférieur
> Supérieur
<= Inférieur ou égal
>= Supérieur ou égal
= = Egal
!= Différent
TABLEAU 8 : Opérateur de comparaison
7.2 Opérateurs logiques
Le langage C contient trois opérateurs logiques. A l’instar des opérateurs des comparaisons , de résultat d’une expression utilisant les opérateurs logiques soit vrai (non nul), soit faux (nul). Le type de résultat est toujours int. Les opérateurs logiques sont toujours évalués de la gauche vers la droite.
Le tableau suivant décrit les opérateurs logiques.
Opérateur Signification Exemple
a = 10, b =3
& & ET logique (a>0) && (b<10) est vraie
|| OU logique (a = = 4) || (b= = 3) est vraie
! NON logique ! (b = =3) est fausse
TABLEAU 9 : Opérateurs logiques
7.3 Opérateur conditionnel ternaire
Jusqu'à présent nous avons rencontré des opérateurs unaires ((NON binaire, incrémentation, etc.) qui manipulent un seul opérande et des opérateurs binaires (addition, division, etc.) qui manipulent deux opérandes. Il existe un opérateur ternaire qui manipule trois opérandes : l’opérateur arithmétique conditionnel. Voici sa syntaxe :
EXPRESSION 1 ;EXPRESSION 2 ; EXPRESSION 3 ;
On commence par évaluer Expression 1. Si elle est vrai (non nulle), alors on évalue Expression 2, si non on évalue Expression 3
Par exemple, pour calculer le maximum de deux nombres, on écrit,
Int a, b ; max ;
a = 5 ;
b = 10 ;
Max = (a>b) ; a :b ; // max = 10 car a n’est pas supérieur à b
Nous avons déjà vu, dans les exemples précédents, que l’instruction d’assignation (ou affectation) sert à assigner un élément de données à une variable.
Considérons l’expression
X= 10 ;
Une fois l’affectation effectuée, la variable x vaut 10. Mais l’expression entière x = 10 possède aussi la valeur 10 de sorte qu’on peut écrire en C ++ l’expression
Y = x = 10 ;
Après traitement de l’instruction, x et y valent 10 tous les deux.
![Tutoriel Arduino USB Keyboard [Eng]](/images/remos_downloads/id-10747.10747.pdf_thumb-min.webp)
