07/04/2021 Informatique

Instructions élémentaires – C/C++

Licence – Filière SCIENCES DE LA MATIERE PHYSIQUE (SMP)

PROF. GIBET TANI HICHAM
Table des matières
Généralités :......................................................................................................................................... 2
Les commentaires ................................................................................................................................ 2
Les identificateurs ............................................................................................................................... 3
Les types primitifs ............................................................................................................................... 4
Déclaration et définition ...................................................................................................................... 4
Les variables........................................................................................................................................ 5
Déclaration d’une variable .................................................................................................................. 5
Les constantes ..................................................................................................................................... 5
Expressions.......................................................................................................................................... 6
Opérateurs ........................................................................................................................................... 6
Opérateurs arithmétique .................................................................................................................. 6
Opérateurs d’assignation ................................................................................................................. 7
Opérateurs d’incrémentation ........................................................................................................... 7
Opérateurs de comparaison ............................................................................................................. 8
Opérateurs logiques ......................................................................................................................... 9
Priorité des opérateurs ..................................................................................................................... 9
Entrées/Sorties................................................................................................................................... 10
Flux de sortie « cout » ................................................................................................................... 10
Flux de sortie « cout » (chainage) ................................................................................................. 10
Flux d’entrée « cin »...................................................................................................................... 11
Flux d’entrée « cin » (chainage) .................................................................................................... 11

1
Généralités :
Pour écrire un texte dans une langue définie, il est indispensable de connaître
les symboles nécessaires à la formation des mots et des phrases. Pour écrire un
programme en C++ les caractères suivants sont autorisés.
 les majuscules,
 les minuscules,
 les caractères spéciaux,
 les chiffres,
 les caractères invisibles (retour chariot, saut de ligne, saut de page,
tabulation).
On distingue habituellement les notions suivantes :
 Les commentaires,
 Les identificateurs,
 Les mots réservés,
 Les types primitifs,
 Les variables et les constantes,
 etc.
Exemple
int main ( ) {
int a=2;
int b=3;
int mult= a * b ;
cout << "le résultat est : " << mult;
return 0;
}

Les commentaires
Pour faciliter l’interprétation des programmes sources, il est conseillé d’y
ajouter des commentaires.

2
Les commentaires C++ peuvent être placés partout, ils peuvent s’écrire sous la
forme suivante :
/* le commentaire */
// sur la même ligne avec une instruction
a = a + 1 ; // incrémentation de la variable a

Les identificateurs
Les identificateurs nomment les objets C++ (variables, fonctions, classes etc.).
Un identificateur valide est constitué d’un ou plusieurs caractères qui peuvent
être des lettres, des chiffres ou le caractère de soulignement.
Le premier caractère doit être constitué par une lettre ou par le caractère de
soulignement. Pas d’espaces entre les caractères d’un identificateur. Les
identificateurs qui contiennent un double souligné ou bien qui commencent par
un souligné suivi par une lettre en majuscule sont réservés pour être utilisés par
le système.

Identificateur Commentaire

Affiche, indice, entree, sortie Style normal

I216, qzz, a, b, c, a123 OK, mais problème de compréhension

__Sys__, __PART__, __C__ Réservé par le système

9parties, passe-2, 50$billet Incorrects

Bool, true, return, int, class Réservé

Les mots réservés

3
Les types primitifs
Un type de donnée définit la taille de la mémoire occupée et la forme de sa
mémorisation. La taille dépend du système d’exploitation et de la version du
compilateur. Pour connaître la taille d’un type, on utilise la fonction sizeof().
Par exemple sizeof(int) indique la taille d’un type entier.
Le tableau suivant indique à titre d’exemple la taille et l’intervalle pour certains
types de données très utilisés:

Type Taille Valeur

char 1 octet -128 à 127

unsigned char 1 octet 0 à 255
int 4 octet -32768 à 32767
unsigned int 4 octet 0 à 65535
short 2 octet -32768 à 32767
unsigned short 2 octet 0 à 65535
long 4 octet -2 147 483 648 à 2 147 483 647
unsigned long 4 octet 0 à 4 294 967 295
float 4 octet 3.4*10−38 à 3.4*1038
double 8 octet -1.7*10−308 à 1.7*10308
long double 16 octet -3.4*10−4932 à 3.4*104932

Déclaration et définition
Pour pouvoir utiliser un identificateur, un compilateur doit savoir à quoi
correspond cet identificateur : un type donné, un nom de variable, un nom de
fonction ou toute autre chose.
Une déclaration informe le compilateur sur la nature exacte de l’identificateur.
Une définition est associée à un espace mémoire, une valeur, un corps ou le
contenu d’une déclaration.

4
La différence entre une déclaration et une définition est que la première fournit
le nom et le type de l’identificateur alors que la seconde fournit une vue
matérielle de l’identificateur.

Les variables
Une variable est un emplacement mémoire d’un ou de plusieurs octets qui
permet de stocker des valeurs. Chaque variable possède :
 Un type,
 Une valeur,
 Une adresse,
 Un nom,

Déclaration d’une variable

 Type nom_de_variable [ = valeur ]
Exemple
int x;
x = 12 ;
Une variable possède un nom unique et doit être déclarée avant d’être utilisée.
Syntaxe :

Les constantes
Ce sont des éléments qui ne changent pas de valeur durant l’exécution du
programme. Pour les déclarer on doit utiliser le mot clé « const »:
Syntaxe de déclaration
 const type nom = valeur ;
Exemple
const int x = 2 ;

5
Expressions
Une expression est la composition d’opérateurs, de variables, de constantes, de
fonctions et de parenthèses.
Une expression retourne toujours un résultat (valeur).
La valeur de l’expression a un type et peut-être utilisée dans une autre
expression.
Dans cet exemple :
int x = 3 + sin(z);
Variable: z
Constante: 3
Fonction: sin
Valeur de retour: x avec le type int

Opérateurs
Un opérateur représente une opération effectuée sur un ou deux opérandes. Le
langage C++ est riche en opérateurs. Il existe cinq types d’opérateurs :
 Les opérateurs arithmétiques,
 Les opérateurs de comparaison,
 Les opérateurs logiques,
 Les opérateurs d’affectation,
 Les opérateurs d’incrémentation et de décrémentation.
Opérateurs arithmétique
Résultat
Opérateur Dénomination Effet Exemple (avec x
valant 7)

opérateur Ajoute deux

+ x+3 10
d'addition valeurs

opérateur de Soustrait deux

- x-3 4
soustraction valeurs

6
 opérateur de Multiplie deux
* x*3 21
multiplication valeurs

opérateur de Divise deux

/ x/3 2.3333333
division valeurs

Met la
Affecte une
opérateur valeur 3
= valeur à une x=3
d'affectation dans la
variable
variable x

Opérateurs d’assignation
Opérateur Effet

additionne deux valeurs et stocke le résultat dans

+=
la variable (à gauche)

soustrait deux valeurs et stocke le résultat dans

-=
la variable

multiplie deux valeurs et stocke le résultat dans

*=
la variable

divise deux valeurs et stocke le résultat dans la

/=
variable

Opérateurs d’incrémentation
Résultat
Opérateur Dénomination Effet Syntaxe (avec x
valant 7)

Augmente
++ Incrémentation d'une unité x++ 8
la variable

Diminue
-- Décrémentation d'une unité x-- 6
la variable

7
Pré-incrémentation: j=++i; // d’abord i=i+1 et puis j=i
Post-incrémentation: j=i++; // d’abord j=i et puis i=i+1
NB: On fait la même chose pour la décrémentation.
Opérateurs de comparaison
Résultat
Opérateur Dénomination Effet Exemple (avec x
valant 7)

Compare deux Retourne 1 si

opérateur
== valeurs et vérifie x==3 x est égal à 3,
d'égalité
leur égalité sinon 0

Vérifie qu'une
opérateur variable est Retourne 1 si
< d'infériorité strictement x<3 x est inférieur
stricte inférieure à une à 3, sinon 0
valeur

Vérifie qu'une Retourne 1 si

opérateur variable est x est inférieur
<= x<=3
d'infériorité inférieure ou égale ou égal à 3,
à une valeur sinon 0

Vérifie qu'une
opérateur de variable est Retourne 1 si
> supériorité strictement x>3 x est supérieur
stricte supérieure à une à 3, sinon 0
valeur

Vérifie qu'une Retourne 1 si

opérateur de variable est x est supérieur
>= x>=3
supériorité supérieure ou égale ou égal à 3,
à une valeur sinon 0

Vérifie qu'une
Retourne 1 si
opérateur de variable est
!= x!=3 x est différent
différence différente d'une
de 3, sinon 0
valeur

8
Opérateurs logiques
Opérateur Dénomination Effet Syntaxe

Vérifie
qu'une des
|| OU logique ((condition1)||(condition2))
conditions
est réalisée

Vérifie que
toutes les
&& ET logique conditions ((condition1)&&(condition2))
sont
réalisées

Inverse
l'état d'une
variable
booléenne
! NON logique (retourne la (!condition)
valeur 1 si
la variable
vaut 0, 0 si
elle vaut 1)

Priorité des opérateurs

Priorité des opérateurs

() []

-- ++ !

* / %

+ -

9
< <= >= >

== !=

&& ||

= += -= *= /= %=

Entrées/Sorties
La bibliothèque « iostream » offre deux opérateurs surchargés de manière
appropriée pour les flux:
 L’opérateur d'insertion << (écriture)
 L’opérateur d'extraction >> (lecture)
Flux de sortie « cout »
Sortir des données à l’aide d’un flux n’est pas très difficile. La syntaxe s’écrit
sous la forme :
cout << données;
 cout : le flux de sortie
 << : L’opérateur de transfert
 données : les données a afficher qui sont de type ( int, char, char *, float
)
Flux de sortie « cout » (chainage)
Si vous avez plusieurs variables à afficher. Vous pouvez utiliser autant
d’instructions de sortie que de variables à afficher, ou vous pouvez l’écrire dans une
même instruction. Par exemple
cout << 123456;
cout << ‘\n’;
cout << 1.23456;
 ou on peut les chaîner dans une même instruction
cout << 123456 << ‘\n’ << 1.23456;

10
Flux d’entrée « cin »
Le flux d’entrée « cin » conduit les données tapées au clavier vers votre
programme (en mémoire). Le « cin » commence la lecture après la touche
Entrée.
Syntaxe :
cin >> variable ;
 cin : mot clé qui est le nom du flux d’entrée
 >> : opérateur de transfert
 variable : nom de la case mémoire qui vas recevoir la valeur d’entrée.
Flux d’entrée « cin » (chainage)
Si vous avez plusieurs variables à lire. Vous pouvez utiliser autant d’instructions
de lecture que de variables à lire, ou vous pouvez l’écrire dans une même
instruction. Par exemple:
cin >> i;
cin >> c;
cin >> d;
ou on peut les chaîner dans une même instruction :
cin >> i >> c >> d;

11