Chapitre 2 

: Syntaxe élémentaire en langage C++ :

2.1. Les commentaires

Le programme que vous écrivez doit être clair non seulement pour vous, mais aussi
pour le lecteur de votre programme. En général, les commentaires peuvent être utilisés pour
identifier les auteurs du programme, donner la date lorsque le programme est écrit ou
modifié, donnez une brève explication du programme, et expliquer la signification des
énoncés clés dans un programme [12]. Il existe deux types de commentaires dans un
programme C ++: les commentaires d'une seule ligne et les commentaires sur plusieurs
lignes.

Les commentaires sur une seule ligne commencent par //. Tout ligne rencontré
d’après // est ignoré par le compilateur. Par exemple :

//**************************************************************
// Cette programme en C++ calcule le périmètre et la surface du rectangle.
// Date 11/12/2017.
//**************************************************************
Les commentaires sur plusieurs lignes sont compris entre / * et * /. Le compilateur ignore
tout qui apparaît entre / * et * /. Par exemple:
/*
Un commentaire explicatif
sur plusieurs lignes....*/

2.2. Mots clés et mots réservés d’un programme en langage C++

Voici un exemple de programme en C++. Lorsque le programme est exécuté, il affiche à

l’écran: Bonjour tout le monde !

#include <iostream>
using namespace std;
int main ()
{
cout<< " Bonjour tout le monde !";
Ce programme est expliqué plus en détails ci-dessous :

 #include<iostream>
#include est une directive qui indique au préprocesseur d'inclure le contenu du fichier d'en-
tête iostream avant la compilation .iostream contient des fonctions de bibliothèque standard
qui indique au compilateur ce que va faire.
 using namespace std

Vous permet d'utiliser les deux fonctions cout et endl et ces fonctions devraient être utilisées
comme std (standard).
 int main()

L'exécution du programme commence à la fonction main (). int (entier) spécifie le type de
retour de la fonction main (). Chaque programme doit avoir une seule fonction main ().
 Dans C++ << est un opérateur, appelé l’opérateur de flux d’insertion.
 cout <<affiche le message "Bonjour tout le monde !" sur l'écran.
 return 0 renvoie la valeur 0 au système d'exploitation lorsque le programme se termine.
2.2. Les variables
A. La déclaration de variables :
Pour pouvoir utiliser une variable, il faut la définir, c'est-à-dire lui donner un nom, mais
surtout un type de données à stocker afin qu'un espace mémoire conforme au type de données
qu'elle contient lui soit réservé. Une variable se déclare de la façon suivante :
Type Nom_de_la_variable;
Ou bien s'il y a plusieurs variables du même type :
Type Nom_de_la_variable1, Nom_de_la_variable2, ...;
B. Affectation d'une donnée à une variable :
On utilise l'opérateur d'affectation « = » :
Nom_de_la_variable = donnée;
Pour stocker le caractère B dans la variable que l'on a appelée Caractere, il faudra écrire :
Caractere = 'B';
Ce qui signifie stocker la valeur ASCII de « B » dans la variable nommée « Caractère ». Il est
bien évident qu'il faut avoir préalablement déclaré la variable en lui affectant le type char :
char Caractere.
C. Initialisation d'une variable  :
La déclaration d'une variable ne fait que « réserver » un emplacement mémoire où stocker la
variable. Tant que l'on ne lui a pas affecté une donnée celle-ci contient ce qui se trouvait
précédemment à cet emplacement, que l'on appelle garbage (en français détritus). On peut
donc affecter une valeur initiale à la variable lors de sa déclaration, on parle alors
d'initialisation :
Type Nom_de_la_variable = donnée;
Exemple :
float T=125.36;
D. Variable globale et variable locale
 Une variable déclarée au début du code, c'est-à-dire avant tout bloc de donnée, sera
globale, on pourra alors l'utiliser à partir de n'importe quel bloc d'instructions.
  Une variable déclarée à l'intérieur d'un bloc d'instructions (dans une fonction ou une
boucle par exemple) aura une portée limitée à ce seul bloc d'instruction, c'est-à-dire
qu'elle est inutilisable ailleurs, on parle alors de variable locale.
E. Les types entiers
Le langage C++ possède plusieurs types de base pour désigner un entier.
 int : contient un entier de taille normale, positif ou négatif.
 short int : contient un entier de petite taille, positif ou négatif.
 long int : contient un entier de grande taille (32 bits), positif ou négatif.
 long long int : contient un entier de plus grande taille (64 bits), positif ou négatif.
 unsigned int : contient un entier de taille normale, positif ou nul.
 unsigned short int : contient un entier de petite taille, positif ou nul.
 unsigned long int : contient un entier de grande taille (32 bits), positif ou nul.
 unsigned long long int : contient un entier de plus grande taille (64 bits), positif ou
nul.
F. Les types réels
Pour représenter un réel, il existe 3 types de base:
 float (simple précision)
 double (double précision)
 long double (précision étendue)
Il est usuel de représenter un int sur 32 bits : il peut alors représenter n'importe quel
entier entre -231 et 231-1. Le langage ne précise pas le système de représentation, ni la précision
de ses différents formats. Le type long double est juste censé être plus précis que le double,
lui-même plus précis que le float. Il est toutefois usuel (mais non obligatoire) de représenter
le float sur 32 bits dans le format IEEE 754 simple précision et le double sur 64 bits dans le
format IEEE 754 double précision.
G. Les booléens
Le C++ utilise le type bool pour représenter une variable booléenne. Un bool ne peut prendre
que 2 valeurs : True ou false. On peut affecter à un bool le résultat d'une condition, ou l'une
des deux constantes citées précédemment.
Exemple :
bool a ; int c ; c=89 ; a=(c>87) ;

2.2. Définition de constantes

Un constant est une variable dont la valeur est inchangeable lors de l'exécution d'un
programme

Exemple :
const int A = 26;
const float Pi = 3.14159

2.3. Opérations arithmétiques et Logiques

Un opérateur est un symbole qui indique au compilateur d'effectuer des manipulations
mathématiques ou logiques spécifiques. C ++ est riche en opérateurs intégrés. Le tableau
suivant listes les opérateurs arithmétiques et logique disponibles en C ++.

Opérateurs arithmétiques
Opérateurs Description
+,-,*,/,% Addition, soustraction, Multiplication, division, et
modulo (reste d'une division)
= Affectation
 +=, -=, *=, /=  y += 20; équivalent y = y + 20;
 jj += k; équivalent jj=jj+k;
 ii *= 3; équivalent ii = 3*ii;
Affectation avec somme ou soustraction
Affectation avec multiplication, division ou modulo
== , != tests d'égalité et d'inégalité
>, >=, <, <= tests de supériorité et d'infériorité
() Parenthèses pour évaluer en priorité
[] Tableau
Opérateurs logique
Opérateurs Description
& ET logique bit à bit
| OU logique bit à bit
^ OU exclusif bit à bit
&& ET logique booléen
|| OU logique booléen
&= ,^=, |= Affectation avec ET logique, OU logique ou OU
exclusif bit à bit
~ NON logique bit à bit
! NON logique
++ -- Incrémentation post ou pré-fixée

2.4 Priorité des opérateurs

Comme en mathématiques, tous les opérateurs n'ont pas la même priorité. Souvent, la
signification d'une expression complexe change en fonction de l'ordre dans lequel elle est
calculée. L'ordre des opérations est donné par le tableau suivant:
Priorité 1 (la plus forte) () 
Priorité 2 ! ++ -- 
Priorité 3 * / % 
Priorité 4 + - 
Priorité 5 <<= >>=
Priorité 6 == != 
Priorité 7 && 
Priorité 8 || 
Priorité 9 (la plus faible) = += -= *= /= %= 

Par exemple, l'expression 1+2*3 retournera la valeur 7 car l'opérateur * a une plus
grande priorité et est évaluée avant l'opérateur +. L'expression est donc équivalente à
1+(2*3). Les parenthèses permettent de modifier les priorités en encadrant ce qu'il faut
évaluer avant. Ainsi l'expression (1+2)*3 retournera la valeur 9.
2.5 Opérateurs bit à bit
Les opérateurs binaires bit à bit pris en charge par C ++ sont : ET logique bit à bit (&),
OU logique bit à bit (|), OU exclusif bit à bit (^), NON logique bit à bit (~),DÉCALAGE À
GAUCHE (<<) et DÉCALAGE À DROITE(>>). Ces opérateurs fonctionnent au niveau du
bit.
 Considérons deux bits bit1 et bit2. Le tableau suivant montre comment les opérateurs
bit à bit manipulent les bits. Et la programmation de ces manipulations en langage C++ sont
illustré par le code ci-dessous :

A=13 0 0 0 0 1 1 0 1
B=181 1 0 1 1 0 1 0 1
A&B 0 0 0 0 0 1 0 1
~A 1 1 1 1 0 0 1 0
A|B 1 0 1 1 1 1 0 1
A^B 1 0 1 1 1 0 0 0
A >> 1 0 0 0 0 0 1 1 0
A << 2 0 0 1 1 0 1 0 0

#include<iostream>
using namespace std;
int main() {
int a = 13, b = 181;
int x, y, z, r, s;
x = a & b; y = a | b; z = a ^ b; r = a << 2; s = a >> 1;
cout<< a << " & " << b << " = " << x << endl;
cout<< a << " | " << b << " = " << y << endl;
cout<< a << " ^ " << b << " = " << z << endl;
cout<< a << " << " << 2 << " = " << r << endl;
cout<< a << " >> " << 1 << " = " << s << endl;
return 0;
}