1

UCA

Introduction au Langage C++. 1 ère Partie : Les Bases.

Département de physique

Année 2020/2021

Introduction au langage C++. Module Informatique. Filière SMP. Semestre 4

1 Introduction

1.1 Objectifs du module Informatique : Programmation C++.

De manière générale, le module informatique est là pour, apporter un complément de formation, dans le

cursus des étudiants de la filière sciences physiques en matière de techniques calculatoires. Notamment en

introduisant un outil indispensable pour la simulation, la modélisation, le traitement des données,

l’application des méthodes numériques etc.

Cet outil est le langage de programmation C++. Mais, au-delà du langage en lui-même, ce sont les bases de

la programmation qui sont ciblées ; ainsi que l’acquisition des techniques algorithmiques qui les

accompagnes.

Dans la réforme précédente le langage étudié était le langage C. Cette transition vers le C++, permet

d’élargir cette base de programmation, en y ajoutant d’autres concepts, en l’occurrence la programmation

orientée objet.

Le langage C++ est un langage compilé, il permet d’appréhender la programmation moderne ; structurée et

orientée objet. Théoriquement, le langage C++ englobe le langage C.

L’étudiant ayant acquis les bases du C++ devrait pouvoir migrer, moyennant un petit effort, vers d’autres

langages comme : Java, C#, Visual Basic, Python par exemple, Qui sont des langages orientés objets (POO).

Comme il pourrait de la même façon aller vers : C, Fortran etc. qui sont eux dans la catégorie des langages

structurés. Une autre catégorie de langages, celle des langages interprétés, très pratiques pour l’analyse des

données, comme Matlab, SciLab, IDL, Mathematica etc. lui seront aussi accessibles.

1.2 Un peu d’histoire.

Le langage C++ a été développé par Bjarne Stroustrup au cours des années 1980. L’objectif était d’améliorer

le C en y ajoutant l’approche Orientée objets. Le C++ garderait toutes les fonctionnalités du C. Il

combinerait donc toutes les possibilités de la programmation « classique » en y ajoutant la puissance de

l’approche objet.

Le choix du nom C++ fait référence au symbole d'incrémentation ++ du langage C, afin de signaler qu'il s'agit

d'un langage C amélioré (C++ équivaut à C+1).

Quant au langage C, il a été créé en 1972 par Denis Ritchie avec un objectif relativement limité : « écrire un

système d’exploitation UNIX ». Mais ses qualités opérationnelles ont fait qu’il soit vite adopté par une large

communauté de programmeurs.

Une définition rigoureuse du langage a été réalisée en 1978 par Kernighan et Ritchie avec la publication de

leur ouvrage « The C programming language ».

1.3 Avant de commencer

On souhaite attirer l’attention de l’étudiant sur un point très important pour lui éviter beaucoup de

déceptions par la suite. Comme cela a été dit, et bien dit, par d’autres, on se contentera de citer Patrick Trau,

« le langage C++ », Université de Strasbourg :

« Un ordinateur est une machine bête, ne sachant qu’obéir, et à très peu de choses :

– Addition, soustraction, multiplication en binaire, uniquement sur des entiers.

– Sortir un résultat ou lire une valeur binaire (dans une mémoire par exemple).

– Comparer des nombres.

Sa puissance vient du fait qu’il peut être Programmé, c'est-à-dire que l’on peut lui donner, à l’avance, la

séquence (la suite ordonnée) des ordres à effectuer l’un après l’autre. Ces ordres codés en binaire sont

sauvés dans un fichier nommé « exécutable » (.exe sous Windows). Le grand avantage de l’ordinateur

est sa rapidité. Par contre c’est le programmeur qui doit TOUT faire. »

2 Premier programme.

Pour entamer l’étude du langage, beaucoup d’auteurs choisissent de présenter de manière très

simple un premier programme dont l’objectif est d’afficher la phrase « Hello, world !». Ce

programme est devenu par la suite très répandu. La finalité est que si vous êtes capable d’écrire, de

compiler et d’exécuter ce programme, alors vous pouvez élaborer d’autres programmes en suivant

ce même modèle.

Ce premier programme C++ est le suivant :

1 #include<iostream>

2

3 int main()

4 {

5 std::cout << "Hello, World !" ;

6

7 return (0);

8 }

Le lancement de ce programme dépendra de l’environnement utilisé : Windows, Unix, Mac OS ou

autre. Dans notre cas, nous allons utiliser l’environnement Windows. Nous allons décrire les

transformations successives que doit subir ce programme, depuis sa forme texte, jusqu’au résultat

final.

On distingue 3 étapes principales : l’édition de texte, la compilation et enfin l’exécution.

2.1 Edition

On dit éditer le programme, c'est-à-dire l’écrire. Pour cela, il existe beaucoup d’éditeurs de texte

qui permettent de le faire. Même document texte de Windows : « Bloc-notes » peut suffire.

Une fois édité, on obtient un fichier, qu’on appellera fichier source. En principe il doit porter

l’extension "*.cpp". A titre d’exemple on peut l’appeler "premier.cpp".

2.2 Compilation

"premier.cpp" est l’expression en langage humain du programme. On se doute que la machine,

c’est à dire l’ordinateur, ne va pas comprendre cette forme de langage, et par conséquent il va

falloir lui faire la traduction dans son propre langage, c'est-à-dire le langage machine. C’est là le rôle

du compilateur, compiler en anglais.

Le compilateur est un super programme qui se charge de traduire en langage machine, ce que vous

écrivez en langage humain. Un compilateur du langage C++, va faire cette traduction dans le

respect règles d’écriture du langage.

Si le compilateur ne rencontre aucun problème il produit un nouveau fichier qui correspond à la

forme machine du programme "premier.cpp".

En principe l’extension de ce fichier est "*.exe", dans notre cas ce sera : "premier.exe".

Dans la réalité, la compilation est constituée de trois étapes :

La pré compilation.

La compilation.

L’édition des liens

On les schématise dans le diagramme suivant :

Dans les paragraphes ci-après, on aura l’occasion de dire quelques mots à propos de ces différentes

étapes. Pour l’instant, la « compilation » se résume à la transformation d’un fichier source sous

forme d’un fichier texte : premier.cpp, en un fichier cible sous forme binaire : premier.exe.

La compilation en soit, est réalisée via une commande, formulée au sein du système d’exploitation

utilisé : Windows, Linux etc. Elle diffère légèrement d’un système à un autre. Mais, de manière

générale, elle ressemblera à ceci :

Compilateur [options] Fichier_Source [options] Fichier_Cible

Par exemple :

mingw32-g++ premier.cpp premier.exe

Dans cette commande :

"premier.cpp" "premier.exe"

Pré

compilation

Compilation

Edition de

liens

Exécutable

Précompilation Compilation Edition des Liens

Fichier Source C++

Source Intermédiaire

Objet

Autre Source C++

Source Intermédiaire

Objet

Autres Objets

mingw32-g++ est le super programme ou le compilateur.

premier.cpp est le programme qu’on veut compiler.

premier.exe est le nom qu’on souhaite donner à l’exécutable issu de la compilation.

Il reste à préciser qu’il existe plusieurs compilateurs. Certains sont dans le domaine publique, donc

gratuits et d’autres sont commerciaux, donc payants.

2.3 L’exécution

La dernière étape est le lancement du programme. On dit aussi l’exécution du programme.

C’est une commande. A partir du système d’exploitation, on "lance" le fichier binaire "premier.exe".

Les instructions contenues dans le programme initial sont exécutées. On obtient enfin le résultat

cherché.

2.4 Les environnements de développement intégré (EDI).

EDI en français ou IDE en anglais (Integrated development environment) sont des applications fort

utiles, puisqu’elles regroupent dans un même espace les taches décrites ci-dessus : à savoir l’édition,

la compilation et l’exécution.

2.4.1 Aperçu.

L’EDI que nous utilisons en salle de TP et Code::Blocks : dont voici une capture d’écran.

2.4.2 Edition.

L’EDI contient une zone d’édition de texte, on peut y éditer le code source du programme

"premier.cpp".

2.4.3 Compilation et exécution.

Une série d’icones, qui sont des raccourcis, servent pour la compilation et l’exécution du fichier

édité. On laissera la découverte des autres détails sur la manipulation de cet environnement aux

séances de travaux pratiques.

On évoquera juste le résultat de l’exécution du programme ‘premier.exe’ : C’est l’affichage d’un

message. Il est obtenu dans une fenêtre séparée : la console, elle a l’aspect suivant :

2.5 Eléments constitutifs du premier programme.

Reprenons le programme premier.cpp.

Les éléments qui le composent, sont :

2.5.1 #include<iostream>

Située en entête du fichier, elle demande d’inclure la librairie standard iostream.

En C++, certains aspects, comme les entrées/sorties, font partie de la librairie standard, et non du

noyau du langage lui-même. Cette distinction est importante parce que le noyau du langage est

disponible pour tout programme C++ sans aucune autre formalité, mais pour les parties située dans

la librairie standard, on doit explicitement en demander l’inclusion dans le programme.

#include<iostream> est une directive de pré compilation. Elle intervient avant la compilation.

Un « fichier » constituant la librairie standard iostream sera ajouté au fichier source avant même

l’étape de compilation.

2.5.2 La fonction principale : main

Située après l’entête du fichier, une fonction est une partie du programme portant un nom. Toute

autre partie du programme peut l’appeler et entrainer son exécution.

std::cout << "Hello, World !";

return (0);

#include<iostream>

int main( )

Entête

Fonction Principale

Implémentation

Tout programme C++ doit contenir une fonction portant le nom main. C’est la fonction principale.

Quand on demande à exécuter un programme, c’est cette fonction qui est exécutée.

D’autres éléments accompagne le mot main, ce sont : int et ( ). Leur présence est nécessaire, on

trouvera les explications les concernant dans le paragraphe dédié aux fonctions.

2.5.3 Les accolades { }.

Les accolades { } précisent le début et la fin de la fonction main.

Ce qu’elles renferment constitue le corps de la fonction.

2.5.4 Les instructions.

Les accolades { } précisent le début et la fin du corps de la fonction main.

Elles suivent immédiatement l’entête de la fonction.

On trouve entre les accolades la ligne :

std::cout << "Hello, World !" ;

C’est l’implémentation -le remplissage- de la fonction, et c’est, au bout du compte, ce que doit faire

le programme. C’est le cœur du programme.

Cette instruction demande d’afficher un message dont le contenu est “Hello, World !”.

std::cout est l’élément qui a requis l’inclusion de la librairie standard iostream.

On trouve également, entre les accolades, l’instruction :

return (0);

Elle indique la dernière instruction de la fonction main. Cette ligne est le lien avec le programme

qui a lancé l’exécution de la fonction principale main.

Dans la suite on va s’intéresser à la syntaxe d’écriture des instructions dans l’objectif de concevoir

nos propres programmes.

2.5.5 Les commentaires

Il est conseillé d’ajouter des commentaires dans un programme afin de rendre plus claire sa lecture

par humains.

Un commentaire est un texte ajouté au code source qui a pour but d'expliquer le fonctionnement

du programme, sans que le compilateur ne le prenne en compte. C.à.d. que le compilateur l’ignore

dans la phase de compilation du code source.

Pour insérer des commentaires, le langage prévoit d’utiliser des symboles qui indiquent leur lieu de

présence. Ces symboles délimitent le commentaire. Il y en a deux sortes :

Le symbole : /* et */.

Le symbole : //.

Voici, en exemple, des commentaires dans le programme premier.cpp.

/*

programme : premier.cpp

auteurs : .....

date : Mars 2015

Symbole Exemple portée origine

/* et */ /* Ceci est un commentaire */ Peut s’étendre sur plusieurs lignes. Vient du C

// // Ceci est un commentaire S’arrête à la fin de ligne. Ajouté par C++.

Affiche le message : Hello World !

*/

#include<iostream> // Entete

using namespace std; // espace de nommage

int main() //Fonction Principale

{

cout << "Hello world !" ; // Implementation

return (0);

}

3 Eléments de base du langage C++.

3.1 Généralités

3.1.1 Les unités lexicales : Les mots du langage.

Les symboles utilisés dans le langage sont composés des touches du clavier d’un ordinateur.

On distingue :

i. Les lettres : a, b, c, …, z, A, B, C, …, Z. On dira d’eux des caractères alphabétiques. Le

langage différencie entre majuscules et minuscules. Pour lui, a et A sont deux lettres

différentes.

ii. Les chiffres : 0, 1, 2 etc. On dira d’eux des caractères numériques.

iii. Le reste des caractères : +, -, %, & etc. On dira d’eux que ce sont des caractères spéciaux.

Certains ont un pictogramme (un dessin pour les représenter) comme < & * etc. D’autres

n’en ont pas, comme « espace », « retour chariot » etc. Mais tous ont un code grâce

auquel le langage les identifie.

Les caractères alphanumériques (alphabétiques +numériques) et caractère spécial ‘_’, sont utilisés

pour créer des noms pour toutes sortes d’objets du langage.

Avec le reste des caractères spéciaux le langage conçoit des operateurs.

L’élément de base du code source est un token (c’est un terme anglais, en français on peut dire :

une unité lexicale), un token est un texte du code source que le compilateur ne va pas chercher à

décomposer en plus petit éléments. C’est le composant ultime, comme les atomes pour la matière.

Le langage comprend 6 types d'unités lexicales (token) :

i. Les mots-clés

ii. Les identificateurs

iii. Les constantes

iv. Les chaînes

v. Les opérateurs

vi. Les signes de ponctuation

Voici une définition très simplifiée pour chacun de ces éléments. Sachant que dans la suite de ce

cours on aura l’occasion de détailler ces éléments.

3.1.1.1 Les mots-clés (Keywords).

Certains mots du langage courant (l’anglais est la langue du C++) sont réservés par le langage C++

pour son propre usage, ils existent en tant que tels. Et par conséquent, ils ne doivent pas être ré-

utilisés par l’utilisateur avec un autre sens que celui que le C++ leur a prévu.

La liste exhaustive des mots-clés du C++ est composée, d’abord les mots clés déjà usités par le

langage C, et qui sont :

auto break case char

const 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

Ensuite, viennent s’ajouter les mots clés propres à C++, qui ne faisaient pas partie des mots clés du

C. Leur liste est la suivante :

asm bool catch class

const_cast delete Dynamic_cast explicit

export false friend inline

mutable namespace new operator

private protected public reinterpret_cast

static_cast template this throw

true try typeid typename

using virtual wchar_t

3.1.1.2 Les identificateurs (identifiers)

sont les noms donnés aux variables, types, fonctions ou labels de vos programmes. A ce

titre « main » et « printf » sont des identificateurs. Un mot-clé ne peut pas servir d’identificateur.

On a droit aux caractères alphanumériques, en plus du seul caractère spécial ‘_’. Voici la liste

exhaustive des caractères auxquels on a droit :

i. _ (c’est le caractère situé sur la touche 8)

ii. a b c d e f g h i j k l m n o p r s t u v w x y z

iii. A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

iv. 0 1 2 3 4 5 6 7 8 9

Aucun caractère spécial n’est admis à l’exception de _. De plus un identificateur ne doit jamais

commencer par un chiffre.

Exemple d’identificateurs corrects : x, y, age, prix123, _beta.

Exemple d’identificateurs non valides : 3a, a$, x 2 (x espace 2).

3.1.1.3 Les constantes littérales.

Ce sont les nombres entiers ou réels, les caractères ou suite de caractères utilisés comme valeurs

dans un programme.

Par exemple : 54, 3.14 et 2.9e+08 sont des constantes numériques.

'a', 'Z', '1', '47' et '=' sont des constantes de type caractères.

Hello est une constante de type chaine de caractères.

Le langage reconnait ces constantes sans qu’aucune définition les décrivant ne soit nécessaire.

3.1.1.4 Les opérateurs

Ils sont formés à partir des caractères spéciaux essentiellement. Les opérateurs permettent de faire

des opérations sur les autres éléments du langage, comme les variables par exemple. Parmi eux, on

a les opérateurs arithmétiques : +, *, −, / et % pour les opérations d’addition, de multiplication,

de division et de modulo. On a aussi les opérateurs : >, < ou == pour les opérations de

comparaison (logique). Etc..

3.1.1.5 Les signes de ponctuations.

Certains caractères ont un sens bien spécifique en C++, ils seront rencontrés tout au long du cours.

Parmi eux on trouve :

[ ] ( ) { } * , : = ; ... #

Dans le programme exemple premier.cpp , on a vu ces deux signes ( ) et { } dans la fonction

main, indiquant le début et la fin du corps de main.

Il y a aussi le signe # réservé aux directives du préprocesseur.

Il y a aussi le signe ';' désignant la fin de l’instruction : std::cout << "Hello, World !";

3.1.2 Les phrases du langage : Les instructions.

Le langage prévoit d’organiser les mots du langage en phrases. On les appelle alors des instructions.

Une instruction est une suite d’unités lexicales terminée par le signe de ponctuation point-virgule (;)

Un exemple est donné dans premier.cpp, il s’agit de : std::cout << "Hello, World !";

3.1.3 Les structures de contrôles.

Les structures de contrôle sont des instructions définies dans le langage, et pas que dans le C++,

mais dans tous les autres aussi. Ce sont elles qui confèrent à la machine « un peu d’intelligence »,

pour peu que l’on sache les programmer.

Elles consistent en deux structures d’aspects différents, mais elles se complètent mutuellement.

La première : Les structures de choix. Qui vont permettre d’exécuter certaines instructions plutôt

que d’autres.

Et la seconde : Les structures de répétition qui vont permettre de répéter certaines instructions à

souhait.

Elles seront vues dans les paragraphes qui leurs sont dédiés.

3.1.4 Les programmes.

Le programme dans le langage C++ va être une composition de tous les ingrédients qui viennent

d’être présentés. C’est une alchimie des mots-clés, des opérateurs et des variables, couplés dans des

instructions, elles mêmes entrelacées dans des structures de contrôle, pour la réalisation d’une tâche.

C’est une magie, seul votre imaginaire peut la limiter. Les outils encore une fois sont :

i. Les variables et leurs affectations.

ii. Les entrées / sorties.

iii. Les structures de choix.

iv. Les structures de répétition.

Après ces généralités, on va décrire plus en détail, caractéristique de chaque notion.

3.2 La notion de variable

La plus part des langages utilisent la notion de variable. Une variable est un nom (identificateur) qui

sert à repérer un emplacement dans la mémoire centrale. Notion simple qui contribue à faciliter la

réalisation de programmes. Elle permet de manipuler des valeurs sans avoir à se préoccuper de

l’emplacement mémoire. Cela est rendu possible parce qu’il existe un programme de traduction

(compilateur ou interpréteur) de votre programme dans le langage de la machine. C’est lui qui

attribuera une adresse à chaque variable.

Pour toutes les opérations, l’utilisateur n’a pas à connaitre l’adresse en mémoire d’une variable

mais seulement le nom de la variable.

De sa définition jusqu'à son utilisation, une variable n’est complètement définie qu’après avoir

franchi quatre étapes (pas forcément dans l’ordre, sauf la dernière):

1. Avoir obtenu un nom.

2. Avoir un type.

3. Avoir été déclarée.

4. Avoir obtenu une valeur.

3.2.1 Les noms de variables

Le nom d’une variable appartient à la catégorie des identificateurs (le nom est un token). Il faut

donc respecter les consignes des identificateurs, à savoir:

i. Utiliser des caractères parmi :

_abcdefghijklmnoprstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789

ii. N’utiliser aucun autre caractère spécial.

iii. Ne pas commencer par un chiffre.

Pour la longueur en caractères, on peut au moins aller jusqu'à 32 caractères.

3.2.2 Les types de variables

Comment conçoit la machine le stockage des valeurs numériques en mémoire est différente de

notre expérience quotidienne de la mémorisation de l’information. En effet nous représentons des

informations comme 10 ou 3,14 de la même manière ; ou du moins nous croyons que notre esprit

le fait. Mais pour la machine il lui faut plus de mémoire pour représenter 3,14 que pour représenter

10. On parle alors de codage de l’information.

La machine code l’information en bits : c'est-à-dire soit 0 soit 1. Ensuite elle les organise en bytes.

Le byte est la plus petite unité adressable d’un ordinateur. Aujourd’hui, les bytes de 8 bits se

sont généralisés en informatique.

Définition : L’octet est une unité de mesure en informatique. Elle mesure la quantité de données. Un octet est lui-même composé de 8 bits, soit 8 chiffres binaires (0 ou 1). Le byte, qui est un ensemble de bits adjacents, a presque toujours une taille d'un octet et les deux mots sont généralement, mais abusivement, considérés comme synonymes.

Le langage C++ donne la possibilité d’attribuer à chaque variable un certain nombre d’octets, 1,2 ,4

ou plus. De plus il offre plusieurs possibilités de codages. Il adapte la variable à la nature de

l’information qu’elle représente.

La combinaison : taille en octets et codage de la représentation s’appelle le type de la variable.

Le langage C++ prévoit 3 types de base, avec des variantes pour chacun :

i. Types caractères

ii. Types entiers et Logique

iii. Types flottants. (réels)

3.2.2.1 Les types caractères.

Les différents types servant à représenter les caractères sont donnés dans le tableau suivant :

Type Signification Taille (Octets) Valeurs acceptées

signed char Caractère signé 1 -128 à 127

unsigned char Caractère non signé 1 0 à 255

char Caractère 1 -128 à 127

3.2.2.2 Les types entiers et le type logique.

Les différents types servant à représenter les entiers sont donnés dans le tableau suivant :

Type de variable Signification Taille (Octets) Valeurs acceptées

short int Entier court 2 -32 768 à 32 767

unsigned short int Entier court non signé 2 0 à 65 535

int Entier 2 (sur processeur 16 bits)

4 (sur processeur 32 bits)

-32 768 à 32 767

-2 147 483 648 à 2 147 483 647

unsigned int Entier non signé 2 (sur processeur 16 bits) 0 à 65 535

4 (sur processeur 32 bits) 0 à 4 294 967 295

long int Entier long 4 -2 147 483 648 à 2 147 483 647

unsigned long int Entier long non signé 4 0 à 4 294 967 295

3.2.2.3 Le type logique.

Pour les besoins des langages de faire des opérations relationnelles et des opérations logiques (voir

les paragraphes à venir sur ces deux genres d’opérations), ils ont besoin d’un type qui ne possède

que deux valeurs possible : 0 et 1.

Beaucoup de langages définissent un type réservé à ce genre de variables et ils l’appellent type

logique.

En C++ le type (bool) est le type logique. Pour tous les langages la valeur 0 signifie faux (false en

anglais) et 1 signifie vrai (true en anglais).

Pour ce type un seul bit suffirait pour coder les variables logiques, mais comme la plus petite

quantité adressable est l’octet (8 bit) alors les autres bits ne sont pas utilisés.

Le langage C a une approche quelque peu originale de représenter les variables logiques. En effet,

pour le langage C, la valeur 0 (zéro) représente la valeur logique 0 (faux/false) et tout autre

nombre non nul représente 1 (vrai/true). Tout type de base est bon pour représenter le type logique

en C. Mais il est courant de prendre le type int pour les variables logiques du C.

Il est important de savoir comment le langage C gère les valeurs logiques, parce que le C++, qui est

l’objet de notre étude, intègre d’office la syntaxe du C.

Le comportement du langage C, pour les variables logiques est résumé dans ce tableau :

C

Type logique Convention

inexistant

Valeur équivaut

0 de tout type (En particulier int) faux/0

Toute autre valeur de tout type 0 vrai/1

Le comportement du langage C++ est plus clair, il est résumé dans ce tableau :

C++

Type logique Taille (Octets) Valeurs acceptées

bool

Même taille que le

type int, parfois 1 sur

quelques compilateurs.

true false

1 0

mais une conversion implicite (valant 0 ou 1) est

faite par le compilateur lorsque l'on affecte un

entier (en réalité toute autre valeur que 0 est

considérée comme égale à True).

3.2.2.4 Les types flottants.

Les différents types servant à représenter les réels sont donnés dans le tableau suivant :

Type de variable Signification Taille (Octets) Valeurs acceptées

float Flottant (réel) 4 3.4*10-38

à 3.4*1038

double Flottant double 8 1.7*10-308

à 1.7*10308

long double Flottant double long 10 3.4*10-4932

à 3.4*104932

Une remarque générale qui concerne toute variable déclarée sous n’importe lequel des types de

base, Il est important de s’assurer par soit même, que les valeurs qu’on lui fait prendre, restent

incluses dans l’intervalle défini par le type. S’il y a débordement de l’intervalle des valeurs possibles,

le compilateur ne détectera pas d’erreur, d’abord à la compilation, et il y a de fortes chances qu’elle

le soit indécelable à l’exécution aussi.

Par exemple, si on a trois variables A, B et C de type unsigned short int (allant de 0 à 65 535). Si

on donne à A et B, la valeur 35 000 à chacun. Et si C est égale à A+B, Alors la valeur de C ne sera

pas 70 000, puisque cette valeur dépasse la valeur maximale du type. Si on teste cela avec un petit

programme, on obtient, en affichant C, la valeur 4464.

A présent on va s’intéresser aux déclarations des variables.

3.2.3 Les déclarations de variables

La déclaration est une instruction dans laquelle, le nom et le type de la variable sont

simultanément définis. D’autres caractéristiques de la variable peuvent aussi avoir leur place dans

cette instruction.

La déclaration d’une variable est nécessaire, et elle doit être faite avant toute autre manipulation de

celle-ci.

Syntaxe d’une déclaration :

Type identificateur ;

Exemples :

1 2 int main()

3 {

4 float prix;

5 int x1, y_1, z;

6 char _a, b, c;

7 unsigned short int A, B, C;

8 double prixPain, ageCapitane,dureeDeVie;

9 /** les incorrectes

10 long int 1A, A', A+B;

11 */

12 return 0;

13 }

A noter que le langage C restreignait les déclarations au début des programmes, le C++ quant à lui,

a étendu la possibilité de déclaration à tout le corps du programme.

3.2.4 Les assignations des variables

Une variable n’est sensée être impliquée dans des opérations que si au préalable on lui a attribuée

une valeur.

La phase précédente, de déclaration de la variable, n’a eu pour effet que de lui réserver de la place

(en Octets) en mémoire centrale de la machine.

Les valeurs des octets réservés restent en l’état – c.-à-d. n’importe quoi–. Certains langages mettent

à zéro le contenu des octets au moment de la déclaration de la variable ; ce n’est pas le cas de

C/C++.

Il appartient à l’utilisateur de prendre en charge l’assignation d’une valeur , dire –valide– , à la

variable, avant d’en faire un quelconque usage.

Pour cela il a à sa disposition, les affectations et les initialisations.

3.2.4.1 Les affectations de valeurs à une variable.

Pour affecter une valeur à une variable, on peut utiliser :

i. La manière directe avec l’operateur '='.

Par exemple :

prix = 1.5 ;

ii. La manière indirecte avec une autre variable déjà bien définie.

Par exemple :

a = 1.7 ;

prix = a ;

iii. une expression mettant en jeu d’autres variables liées par des operateurs.

Par exemple :

prix = 2*a-3.6 ;

3.2.4.2 Les initialisations des variables.

Les initialisations sont des affectations des variables au moment de leurs déclarations.

Comme dans :

float prix = 10. ;

int age(10) ;

Les deux écritures sont valides.

On peut attribuer à la variable toute valeur admise par le type.

La différence entre les initialisations et les affectations est que, l’initialisation ne se fait qu’une seule

fois dans un programme, alors que les affectations peuvent se répéter autant de fois que l’on le

souhaite. C’est ce qui justifie le nom de variable. Car ce qui varie dans une variable c’est sa valeur.

3.3 La notion d’opérateur

A l’instar des mathématiques qui disposent d’opérateurs qui peuvent agir sur des fonctions ou sur

des variables, et les transformer ainsi en d’autres objets ; les langages C/C++ possèdent des

opérateurs qui vont agir sur des variables ou autres objets, et les transformer ou créer de nouveau

objets.

Il est d’une importance capitale de définir à chaque stade des opérations les éléments mis en

jeu. Les éléments dans une opération sont :

- Les opérateurs.

- Les opérandes.

Dans une opération il est possible que l’on soit en présence de l’un des trois cas suivants :

- d’un seul opérateur et d’un seul opérande. L’opérateur est dit être unaire.

- d’un seul opérateur et de deux opérandes. L’opérateur est dit être binaire.

- d’un seul opérateur et de trois opérandes. L’opérateur est dit être ternaire.

Dans le cas de plusieurs opérations, le langage définit un ordre d’exécution, il réalise une seule

opération à la foi. Si bien que l’on revient toujours à la distinction faite ci-dessus.

Il faut, d’un autre côté, préciser les positions relatives de l’opérateur et des opérandes.

On va fournir ci-après une liste non exhaustive des opérateurs usuels.

3.3.1 L’opérateur d’affectation =

Il s’utilise entre deux opérandes, selon la syntaxe :

Opérande_gauche = opérande_droit

On pourra lire : mettre le contenu de l’opérande droit dans l’opérande gauche.

A partir d’ici il faut dégager et assimiler une notion fondamentale en programmation. A savoir, la

notion de lecture/ écriture.

Par lecture, on veut dire lecture dans une adresse mémoire. Et par écriture on comprend l’écriture

dans l’adresse mémoire.

Ces deux notions se ressemblent beaucoup ; mais une différence de taille les sépare. Pour C/C++,

la lecture dans la mémoire est possible pratiquement pour toute les adresses sans conséquence

négative sur le déroulement du programme. Car l’adresse lue n’est pas modifiée par l’opération de

lecture.

Par contre l’écriture dans une mémoire efface le contenu précédent l’écriture. On dit aussi écrase ou

détruit le contenu de la mémoire. Par conséquent cette opération conduit à la perte

d’information. Les langages C/C++ prévoient la protection de certaines adresses, comme les

constantes par exemple ; et ne va pas permettre d’y écrire en signalant une erreur à la compilation.

Le langage C++, avec l’introduction des classes, va permettre une plus grande protection des

variables –qu’il va appeler attributs−. Il va verrouiller l’accès à certains attributs, ne permettant

qu’un accès restreint à celles-ci.

Toute fois, c’est au programmeur d’être vigilant quant à sa façon de gérer ces variables.

Revenons à l’opérateur d’affectation =.

A droite l’opérande subit une lecture. Et alors on peut placer presque toute sorte d’objets dans

cette position.

A gauche l’opérateur subit une écriture. Et donc il faut s’assurer que cet opérande soit une lvalue.

Le langage utilise la terminologie lvalue pour dire left value (valeur de gauche dans une affectation).

Ce qui veut dire : valeur dans laquelle on peut écrire. Il y a des objets dans lesquels on ne pourra

pas écrire, les constantes par exemple.

Affectation correcte :

A=5 ;

Affectation invalide :

5=A ;

3.3.2 Les opérateurs arithmétiques.

3.3.2.1 Les opérateurs + d’addition et – de soustraction.

Ils ont la propriété d’être à la fois unaires et binaires.

Forme unaire.

Comme opérateurs unaires. Leurs écritures sont alors :

op opérande

Où op est + ou −. Et opérande peut être une variable de tout type parmi les types de base,

int, char, float etc.

L’effet de l’opérateur – est de changer le signe de la variable. Et + quant à lui, il laisse invariable

le signe de la variable.

Forme binaire.

Comme opérateurs binaires. Leurs écritures sont alors :

Operande_1 op operande_2

Les opérandes peuvent être là aussi des variables de types de base. Le résultat des opérations

sont comme en mathématiques : l’addition ou la soustraction des valeurs contenues dans les

variables.

3.3.2.2 Les opérateurs * de multiplication et / de division.

Ce sont des opérateurs binaires. On les utilise comme dans les opérations mathématiques de

multiplication et de division. La syntaxe est la suivante :

Opérande_1 op opérande_2

Les opérandes peuvent être là aussi des variables de tous les types de base.

3.3.2.3 L’operateurs % de modulo.

C’est un opérateur binaire. Sa syntaxe est la suivante :

opérande_1 % opérande_2

Il donne en résultat le reste de la division de l’opérande_1 par l’opérande_2. Evidemment cela n’a

de sens que sur les types entiers.

3.3.2.4 Le type du résultat d’une opération arithmétique.

Le résultat d’une opération du genre :

opérande_1 op opérande_2

Dans laquelle op vaut : + − * / dépend du type des opérandes.

Si tous les deux sont d’un même type alors le résultat est du même type. Par exemple si on a :

type int + type int alors le résultat est de type int. Ainsi de suite.

Pour l’opérateur de division / cela a beaucoup d’importance. Une division comme : 3/2 donne 1 et

non pas 1.5. Ce qui n’est pas la même chose. Si on veut le résultat exact il faut écrire 3.0/2.0 soit

type float / type float.

Si les deux opérandes ne sont pas du même type, alors le langage prévoit de transformer le « plus

petit type » dans le format du « plus grand type » et ensuite de faire l’opération dans le format le

plus grand. Le résultat est fourni dans le plus grand.

Exemple :

type int + type float devient type float + type float le résultat est dans le type float.

Cette conversion de type, on dit aussi promotion de type, peut varier d’une machine à l‘autre ;

pour le type int par exemple ; qui peut faire 2 ou 4 octet. Il faut donc être attentif quand on

utilise ces conversions.

3.3.3 L’opérateur de cast.

Le langage permet de « forcer » la conversion de type pour effectuer certaines opérations.

Supposons que l’on veuille faire cette opération :

int a = 5, b = 3, c = 2 ; float x ;

x = a + b / c;

Si on souhaite que le résultat soit un réel, il y aurait problème avec le terme b/c qui va être un

entier puisque b et c sont des entiers. Il faut forcer la conversion, en réel, de l’un des deux : b ou c.

pour cela on utilise l’opération de cast, de cette manière :

x = a + (float) b / c;

De cette manière b sera converti en float avant de faire la division.

3.3.4 Opérateurs d’incrémentation ++ et de décrémentation −−.

On a souvent besoin d’incrémenter, ou de décrémenter, d’une unité les variables qui servent de

compteurs. Pour ça, il y a dans C/C++ des opérateurs pour cet effet. Prenons par exemple le code

suivant :

int i = 0, j = 1 ; /* instructions */

j = j - 1 ; //décrémentation

i = i + 1 ; //incrémentation

Ce code peut être remplacé par celui-ci :

int i = 0 ; /* instructions */

j--;

i++;

++ (−−) est en lui-même un seul opérateur, composé de 2 caractères. Sa position par rapport à la

variable admet deux écritures : avant ou après la variable.

i++ ;

++i ;

La différence est dans la priorité attribuée à chacune. ++i est plus prioritaire que i++. Il en est de

même pour −−.

Prenons un exemple.

int i = 0, j = 0; cout << "i = " << i++ << "j = " << ++j ;

Ce code affichera : i=0 et j=1. Parce que cout est prioritaire sur i++.

Et au contraire ++j et prioritaire sur cout.

En résumé, les opérateurs d’incrémentation et de décrémentation sont :

opérateur équivalence

++i

−−i

i = i + 1

i = i − 1

i++

i−−

i = i + 1

i = i − 1

Dans ce tableau la priorité est plus élevée en haut, elle décroit vers le bas

Avant de passer aux autres genres d’opérateurs, on va s’arrêter sur une notion qu’on a souvent

évoquée, sans vraiment en donner explication claire.

C’est la notion de priorité dans les opérations, ainsi que la notion d’associativité qui lui est

afférente.

3.3.5 Priorité et associativité des opérations.

3.3.5.1 Priorité.

Que se passe-t-il si dans une même instruction se trouve réunis plusieurs opérateurs et opérandes ?

On peut prendre comme exemple :

Opérande1 op1 opérande2 op2 opérande3

Où opérateurs 1 et 2 sont binaires par exemple. On s’attend à ce que le compilateur exécute les

opérations les unes après les autres et non simultanément. Tout comme en mathématiques en

définitive. La question devient quelle opération va-t-il effectuer en premier ?

En fait le langage donne un ordre de priorité aux différents opérateurs. Et il donne un tableau

résumant ces priorités par défaut.

Supposons que l’opérateur 2 est prioritaire sur l’opérateur 1. Alors les opérations vont se dérouler

selon le diagramme ci-dessous :

Si on souhaite que le compilateur fasse les opérations suivant un ordre défini ; et si cet ordre n’est

pas celui qui va être adopté par le compilateur ; alors dans ce cas on utilisera les parenthèses ( )

pour fixer les priorités.

Les parenthèses permettent d’imposer un ordre de priorité. Les opérations mises entre parenthèses

sont prioritaires sur les autres.

3.3.5.2 Associativité.

Dans le cas où, ça arrive, les opérateurs sont à égalité de priorité c.à.d. la priorité est identique pour

tous, c’est le principe d’associativité qui est utilisé.

le même qu’en mathématiques. A savoir qu’on associe les opérandes soit à partir de la gauche soit à

partir de la droite. Cela reste à préciser selon chaque opérateur.

L’égalité de priorité peut se produire dans le cas de la répétition du même opérateur. Mais aussi

dans le cas d’opérateur différents.

Exemple :

int a = 5, b = 7, c = 12, d ;

d = a + b + c ;

L’associativité pour + est de gauche vers la droite. Donc le calcul se fera comme si on faisait :

d = (a + b) + c ;

L’ensemble des priorités connues sur les opérateurs que nous avons évoqués jusqu’à présent est

résumé dans le tableau ci-dessous.

La priorité est décroissante de haut en bas.

Les opérateurs d’une même cellule ont la même priorité même s’ils sont sur des lignes différentes.

catégorie opérateurs description associativité

unaire +

−

++

−−

&

(cast)

sizeof

identité

opposé

incrémentation

décrémentation

adresse

conversion forcée

taille d’un objet

←

arithmétique *

/

%

produit

division

modulo (reste de la division entière)

→

arithmétique +

−

Somme de 2 nombres

Soustraction de 2 nombres

→

opérande1 op1 Opérande2 op2 opérande3

Résultat de l’opération 2 opérande1 op1

Résultat final

3.3.6 Les opérateurs relationnels.

Avant de donner la définition d’un operateur relationnel, il convient de préciser ce qu’est une expression

dans les langages de programmation..

3.3.6.1 Définition d’une « expression ».

Une expression est un élément de syntaxe qui combine un ensemble d’unités lexicales retournant

une valeur –Wikipedia–.

Par exemple, 2+3 est une expression arithmétique qui vaut 5.

Une variable est une expression car elle représente une valeur contenue en mémoire. Par exemple,

la variable X est une expression, et aussi X+6 est une expression.

Autrement dit, si on a une séquence de littéraux, de variables et d’opérateurs, et si cette séquence

conduit à une nouvelle valeur, évaluée en suivant les règles de priorité et d'associativité du langage,

cette séquence est une expression.

Puisqu'elle retourne une valeur, une expression peut être affectée à une variable. Par exemple

X=X+6.

3.3.6.2 Définitions d’un « operateur relationnel »

Les opérateurs relationnels sont des opérateurs binaires pouvant agir sur des opérandes de différents

types et produisant comme résultat une valeur de type logique. C.à.d. que le résultat est soit 1, soit

0. (Ou encore, soit true (vrai) soit false (faux)).

Sa syntaxe :

Opérande1 op opérande2

Opérande1 op opérande2 est une expression dont la valeur est 1 ou 0.

Il y a là, une différence très importante avec les opérateurs arithmétiques.

Pendant que dans une expression arithmétique, le type pouvait être celui de l’Opérande1, ou celui

de l’opérande2, le type d’une expression relationnel est nécessairement booléen.

Voir la représentation schématique de cette comparaison :

3.3.6.3 Liste des opérateurs relationnels

Les opérateurs relationnels sont des opérateurs de comparaison. Ils sont une reproduction des signes

mathématiques correspondants, ils en héritent la signification.

Opérateur Signification Correspondance mathématique

< inférieur <

<= inférieur ou égal ≤

> supérieur >

>= supérieur ou égal ≥

Opérande 1

Type T1

Opérateur

Arithmétique

Opérande 2

Type T2

Résultat

Type T1 ou T2

Opérateur

Relationnel

Opérande 2

Type T2

Opérande 1

Type T1

Résultat

Type bool

Comparaison entre opérateurs arithmétiques et opérateurs relationnels

== égal =

!= Différent, non égal

3.3.6.4 Exemples d’expression relationnelle.

Prenons quelques exemples numériques :

Expression 10>2 1.0<10.6 'a'<='A' 10==1. 2 != 'a'

valeur true true false false true

Ou 1 1 0 0 1

Les affirmations qui sont vraies se verront attribuer la valeur 1 celles qui sont fausses auront la valeur

0.

Si on utilise des variables au lieu des constantes de l’exemple précédent, le résultat serait similaire.

Soit l’exemple suivant :

int main()

{

int a = 10, b = 2;

float x = 1., y = 10.6;

char u = 'a', v = 'A';

cout << (a > b) << endl; ///affichera : 1

cout << (x < y) << endl; ///affichera : 1

cout << (u <= v) << endl; ///affichera : 0

cout << (a == x) << endl; ///affichera : 0

cout << (b != u) << endl; ///affichera : 1

return 0;

}

Remarque :

L’affichage par défaut, dune valeur booléenne, se fait avec les valeurs 0 et 1. Celui avec les valeurs

false et true, peu être obtenu par l’usage des manipulateurs boolalpha et noboolalpha –

inclure la bibliothèque iomanip –.

#include<iostream>

#include<iomanip>

using namespace std;

int main()

{

cout << boolalpha << (10 > 2) << endl; ///affichera : true

cout << noboolalpha << (10 > 2) << endl; ///affichera : 1

return 0;

}

3.3.7 Les opérateurs logiques

3.3.7.1 Définition.

Les opérateurs logiques sont des opérateurs qui agissent sur des objets de type booléens, et

produisent des résultats de type booléens aussi.

Il faut arriver à faire la distinction avec les opérateurs relationnelle, qui eux agissent sur des objets

de tout type et produisent des résultats de type booléen.

Les opérateurs logiques sont au nombre de trois :

– && (et),

– || (Ou inclusif)

– ! (Négation).

Les deux premiers sont binaires et le troisième est unaire. Le résultat de la comparaison vaut 1 ou 0.

Ils jouent un rôle très important dans les structures de choix et aussi dans les structures de répétition.

Ils gardent les sens qu’ils avaient en mathématique, se reporter au cours d’algèbre et de logique.

On se contentera de rappeler les résultats importants les concernant, résumés dans les tables de

vérité:

Opérande 1 Opérateur Logique Opérande 2 Résultat

faux/false/0

&&

faux/false/0 faux/false/0

faux/false/0 vrai/true/1 faux/false/0

vrai/true/1 faux/false/0 faux/false/0

vrai/true/1 vrai/true/1 vrai/true/1

faux/false/0

||

faux/false/0 faux/false/0

faux/false/0 vrai/true/1 vrai/true/1

vrai/true/1 faux/false/0 vrai/true/1

vrai/true/1 vrai/true/1 vrai/true/1

!

faux/false/0 vrai/true/1

vrai/true/1 faux/false/0

3.3.7.2 Exemples

Voici quelques exemples pour fixer les idées :

(5<10) && (6>3) devient 1 && 1 et enfin donne 1

Si a = 5, b = 10, c = 6 et d = 3 alors l’expression ci-dessus s’écrirait :

(a<b) && (c>d) et elle donnerait 1.

! (a==b) deviendrait !(0) et donnerait 1.

Et aussi :

a || b 5 || 10 1||1 1.

!c !6 !1 0.

Avec la représentation du langage C pour les logiques ; ces écritures sont correctes

3.3.7.3 Les priorités et les associativités.

L’opérateur unaire ! est prioritaire sur tous les opérateurs arithmétiques binaires et sur les

opérateurs relationnels.

L’opérateur || est moins prioritaire que l’opérateur &&. Tous deux ont une priorité inférieure aux

opérateurs arithmétiques ou relationnels.

Tous ces opérateurs sont associatifs de gauche à droite. Par exemple, si on a :

bool d ; (ou int d )

Opérateur

Logique

Opérande 1

Type bool

Opérande 2

Type bool

Résultat

bool

Opérateur

Relationnel

Opérande 2

Type T2

Opérande 1

Type T1

Résultat

Type bool

Opérateurs arithmétiques et opérateurs relationnels

d=a && b && c est équivalente à : (a && b) && c

3.3.8 Récapitulatif des règles de priorité et d’associativité.

En regroupant les règles de priorité des opérateurs arithmétiques, relationnelles et logique on aboutit à un

tableau unique. La priorité est décroissante de haut en bas:

catégorie opérateurs description associativité

unaire

+

−

++

−−

!

&

(cast)

sizeof

identité

opposé

incrémentation

décrémentation

négation logique

adresse

conversion forcée

taille d’un objet

←

arithmétique

*

/

%

produit

division

modulo (reste de division entière)

→

arithmétique +

−

somme de 2 nombres

soustraction de 2 nombres

→

relationnels < <=

> >=

inférieur à, inférieur ou égal à

supérieur à, supérieur ou égal à

→

relationnels ==

!=

égal à

différent de

→

logique && Et logique →

logique || ou logique →

conditionnel ? : (opérateur ternaire) ←

affectation

=

+= −= *= /=

%=

affectation usuelle

opération associée suivie

d’affectation

←

3.4 La notion de structure de contrôle.

Les instructions de contrôle sont des instructions qui permettent de contrôler et d’orienter

l’exécution du programme.

L’exécution du programme se fait pas à pas, on dit, de façon séquentielle. On a souvent besoin de

rompre cette séquence d’exécution :

Parfois on veut sauter certaines instructions : on dira d’elles que ce sont des instructions

conditionnelles.

D’autres fois on a besoin de répéter certaines instructions : on dira que ces instructions sont

répétitives.

Les structures de contrôle confèrent aux machines “un comportement intelligent”, les rendent plus

intéressantes. Et contribuent à la résolution d’un certain nombre de problèmes.

Les structures de contrôles sont au nombre de deux :

– Les structures conditionnelles. Dites aussi séquentielles ou de choix.

– Les structures de répétition. On dit aussi structures itératives

3.4.1 Les structures de choix.

Les structures de choix sont des instructions de contrôles qui permettent de choisir, parmi plusieurs

instructions, laquelle sera exécutée.

Le choix est fait sous condition. Une expression à valeur numérique servira de condition.

Elles existent sous quatre formes, sensiblement différentes :

Les structures conditionnelles alternatives.

Les structures conditionnelles simples.

Les structures conditionnelles imbriquées, ou en cascade.

Les structures de choix multiples.

3.4.1.1 Les structures conditionnelles alternatives.

Elles offrent le choix entre deux instructions.

3.4.1.1.1 Son algorithme.

Formellement, la syntaxe d’une instruction conditionnelle alternative est

Si <condition> Alors

instruction(s) 1

Sinon

instruction(s) 2

La condition est une expression logique qui peut avoir pour valeur 0 ou 1. Elle est d’abord évaluée,

si elle vaut 1 c’est l’instruction 1 qui est exécutée si elle vaut 0 c’est l’instruction 2 qui sera exécutée.

3.4.1.1.2 Son organigramme.

3.4.1.1.3 Sa syntaxe.

La traduction de l’algorithme précédent en langage C est :

if (expression)

instruction 1

else

Instruction 2

Dans le cas où, plusieurs instructions seraient présentes, il serai impératif de les grouper au sein d’un

bloc {} ; de cette manière :

if (expression) {

instruction 11;

instruction 12;

...

}

else

{

instruction 21;

Instructions 1

Début

Instructions 2

Fin

Condition

faux/false/0

vrai/true/1

instruction 22;

...

}

Dans ces écritures :

If et else sont les mots-clés, traductions de Si et Sinon.

expression est une expression quelconque de type numérique, de valeur 0 ou 1.

Si elle est non nulle, ce sont les instructions 1 qui sont exécutées. Sinon ce sont les

instructions 2 qui le seraient.

3.4.1.1.4 Un exemple.

Appliquons la structure de choix dans le cas d’un programme qui lit 2 entiers au clavier et qui

affiche la plus grande des 2 valeurs :

int a, b;

cout << "entrez 2 nbres entiers : ";

cin >> a >> b;

if (a>b)

cout << "le maximum est: " << a << endl; // Instrunction 1

else

cout << "le maximum est: " << b << endl; // Instrunction 2

En saisissant les valeurs a = 5 et b = 1, par exemple, la condition a>b vaut 1 ; c’est l’expression 1

qui sera exécutée.

3.4.1.2 Les structures conditionnelles simples.

Elles offrent le choix entre une instruction ou rien. On dira plutôt, que c’est une structure de

branchement conditionnel ; c.à.d. que si la condition est vraie, l’instruction est exécutée, sinon

l’instruction est ignorée.

3.4.1.2.1 Son algorithme.

Une structure conditionnelle simple est :

Si <condition> Alors

instruction(s)

Si la condition vaut 1 l’instruction(s) est exécuté, sinon le programme continue sans l’exécuter.

3.4.1.2.2 Son organigramme.

3.4.1.2.3 Sa syntaxe.

La traduction de l’algorithme précédent en langage C est :

if (expression)

instruction 1

Pour plus d’une instruction, l’usage du bloc {} devient necéssaire.

if (expression) {

instruction 11;

instruction 12;

...

}

3.4.1.2.4 Un exemple.

Dans cet exemple, trois variables a, b et c sont saisies, le programme affichera la valeur maximale.

int a, b, c, max;

cout << "Entrez 3 Entiers : " << endl;

cin >> a >> b >> c;

max = a;

if(b > max) max = b;

if(c > max) max = c;

cout << "maximum : " << max;

On mémorise la variable a dans max. Si b est plus grand que a ; alors c’est b qui est mémorisé. Si c

est plus grand que a et b, alors c sera mémorisé dans max.

3.4.1.3 Les structures conditionnelles imbriquées

Cette forme de branchement conditionnel permet d’effectuer une suite de tests en cascade (les uns

après les autres), jusqu’à ce qu’à la première condition vraie. Si aucune n’est vraie, il exécute

l’instruction par défaut.

Condition

Instructions

Début

Fin

faux/false/0

vrai/true/1

3.4.1.3.1 Son algorithme.

Si (condition 1) alors instructions 1

Sinon si (condition 2) alors instructions 2

… … … … …

Sinon si (condition N) alors instructions N

[Sinon instructionsDefaut]

Si la première condition vraie porte le numéro i, alors les instructions exécutées seraient les

instructions i. ensuite le programme, sort de la structure conditionnelle.

Si aucune condition n’est vraie, alors les instructionsDefaut seront exécutées.

Comme la dernière ligne de cette structure est facultative, si elle est absente, aucune instruction ne

serait exécutée dans le cas où toutes les conditions seraient fausses.

3.4.1.3.2 Son organigramme.

Si la condition 1 est vraie alors les instructions 1 sont exécutées, et le programme ignore toutes les

autres instructions et va à la fin de si. Si elle est fausse, la condition 2 est évaluée ; si elle est vraie

les instructions 2 sont alors exécutées. Ainsi de suite. Si aucune des conditions n’est vraie, le

programme va à la ligne sinon (la dernière) et exécute les instructions par défaut.

3.4.1.3.3 Sa syntaxe.

if( condition_1)

instruction_1;

else if( condition_2)

instruction_2;

else if( condition_3)

instruction_3;

else if( condition_4)

instruction_4;

[else instructionDefaut;] // Facultatif

Fausse

Vraie

Début

Instruction(s) 1

Instruction(s) 2

Instruction(s) 3

InstructionDefaut

Fin

Condition 1

Condition 2

Condition 3 Vraie

Vraie

Fausse

Fausse

3.4.1.3.4 Un exemple.

Voici un programme qui lit la note d’un étudiant, et affiche le résultat de validation avec la mention

obtenue.

int N;

cout << "Entrer Note N, telle que 0<= N <=20" << endl;

cin >> N;

if( N < 0 || N > 20) cout << "Note Invalide " << endl;

else if ( N >= 16 ) cout << "Mention TB " << endl;

else if ( N >= 14 ) cout << "Mention B " << endl;

else if ( N >= 12 ) cout << "Mention AB " << endl;

else if ( N >= 10 ) cout << "Mention P " << endl;

else cout << "Module NV " << endl;

3.4.1.4 Les structures à choix multiples : switch

La structure de contrôle switch permet de faire un choix parmi plusieurs valeurs possibles, d’une

même expression.

3.4.1.4.1 Son algorithme

Si on en donnait une écriture algorithmique, celle-ci serait de la sorte :

SelonQue expression vaut

DébutSelonQue

Valeur1 : instructions 1

valeur2 : instructions 2

//...

valeurn : instructions n

sinon : instructionDefaut

FinSelonQue

Qu’on interprète en disant : selon la valeur de expression, c.à.d. que si expression est

égale à valeur1, alors les instruction1 seront exécutées. Sinon, si expression est

différente de valeur1, on passe à valeur2 et on refait le même raisonnement. Et ainsi de

suite. Dans le cas où toutes les valeurs sont différentes de expression alors les instructions

par défaut seront exécutées.

3.4.1.4.2 Son organigramme.

Pour le cas de switch, il n y a pas de condition explicite, mais il y a une comparaison entre la

variable et la valeur, en cas d’occurrence d’égalité, il y a branchement vers les instructions.

3.4.1.4.3 Sa syntaxe.

switch (Variable)

{

case Valeur_1 : instructions_1

[break;] // facultatif

case Valeur_2 : instructions_2

[break;] // facultatif

case Valeur_n : instructions_n

[break;] // facultatif

default : instructions_def

[break;] // facultatif

}

switch, case, default sont des mots clés du C++.

variable ou de façon générale, une expression entière doit être de type

char, int, bool ou long c'est-à-dire un type entier.

Valeur_i doit être une constantes entières : 'a', 0, 1234, etc.

Le compilateur vérifie, dans l’ordre, si variable est égale à une des constantes, dans lequel cas les

instructions correspondantes sont exécutés.

Si break est absent, les instructions qui suivent sont aussi exécutées. Si break est présent, le

programme va vers la fin de la structure.

Si aucune des constantes n’est égale à la variable de switch alors les instructions de default sont

exécutées.

3.4.1.4.4 Exemples.

Supposons que l’on veuille vérifier si une lettre saisie au clavier est une voyelle ou non ?

instructions1 Valeur1

Avec break

Instructions2 Valeur2

Avec break

instructionsn Valeurn

Avec break

Instructions

Defaut

Avec break

Début

Fin

Sans break

Sans break

Sans break

Défaut

Variable

0

0

0

1

1

1

char c ;

cout << "Entrez une lettre : ";

cin >> c ;

switch(c)

{

case 'a' :

case 'e' :

case 'i' :

case 'o' :

case 'u' :

case 'y' : cout << c << " est une voyelle" << endl;

break;

default : cout << c << " n\'est pas une voyelle" << endl;

}

Vérifier si un nombre entier est pair ou impair ?

int n ; cout << "Entrez une entier : ";

cin >> n ;

switch(n%2)

{

case 0 : cout << n << " est pair";

break;

case 1 : cout << n << " est impair";

}

3.4.2 Les structures répétitives /itératives.

Les structures répétitives ou simplement boucles permettent de répéter, plusieurs fois, un groupe

d’instructions. Elles sont constituées d’une instruction ou d’un groupe d’instructions à exécuter, et

d’une expression fournissant une condition.

Tant que cette condition est vraie ; on répète l’exécution du groupe d’instructions ; dès que la

condition devient fausse l’exécution s’arrête.

L’ordre dans lequel on place les instructions et la condition offre deux possibilités d’usage des

boucles, avec très peu de différences entre elles:

Si la condition précède les instructions, on a une boucle de forme : tant que …faire…

Dans ce cas le test est effectué avant d’exécuter les instructions.

Le mot clef, qui lui correspond dans le langage C/C++ est while.

Si au contraire les instructions précèdent la condition, on est en présence dune boucle de forme:

faire…tant que…

Dans ce cas l’exécution des instructions se fait avant de faire le test.

Le mot clef, qui lui correspond est do … while.

3.4.2.1 Forme tant que … faire / while

3.4.2.1.1 Algorithme tant que … faire

TantQue <condition>

DebutTantQue

Instructions

FinTantQue

Tant que la condition est vraie on exécute les instructions. Dès que la condition devient fausse on

va à la ligne du programme situé après tant que, sans exécuter les instructions.

3.4.2.1.2 Son organigramme.

3.4.2.1.3 Sa syntaxe

En C/C++ la structure while est la traduction de tantQue, elle a la syntaxe suivante :

while(condition)

instruction

Où :

Condition est une expression logique, elle doit être entre parenthèses.

Instruction instruction à exécuter.

Dans le cas de la présence de plusieurs instructions, on place les instructions entre accolades.

while(condition)

{

Instructions

}

3.4.2.1.4 Exemples.

Exemple 1 : Une structure while qui affiche les nombres entiers compris entre deux nombres a et b

tels que a < b.

#include<iostream>

using namespace std;

int main()

{

int a = 10, b = 20, i;

i = a;

while(i <= b)

{

1/true

0/false

Fin

Début

Instructions

Condition

cout << i << endl;;

i++;

}

cout << "Valeur de i en sortie de boucle : " << i;

return 0;

}

Il est à noter que la valeur de i à la sortie de la boucle est 21. Puisque b vaut 20 ; la condition ne

sera fausse qu’à partir de i = 21.

Exemple 2 : Lire 5 valeurs entières au clavier.

int a, compteur = 0;

while ( compteur < 5 )

{

cin >> a;

compteur++;

}

cout << "Valeur de compteur est : " << compteur;

La variable ‘compteur’ varie de 0 à 4, avec à chaque itération une lecture de a.

Quand ‘compteur’ vaut 5, on sort de la boucle.

Exemple 3 : Afficher et compter les diviseurs d’un nombre n saisi au clavier.

int n, i, compt = 0;

cin >> n;

i=1;

while(i<=n)

{

if(n%i==0)

{

cout << "i= " << i << " divise " << n << endl;

compt++;

}

i++;

}

Ce même exemple peut servir pour chercher si n est un nombre premier ou non. Il suffit de

contrôler si le nombre de diviseurs est égal ou supérieur à 2.

Exemple 4 : lire des nombres réels positifs ou nuls, dès qu’un nombre négatif est saisi la lecture

s’arrête.

float x;

x=1.;

while(x>=0.)

{

cin >> x;

}

Pour que l’on puisse accéder la première fois à l’intérieur de la boucle, il faut bien initialiser x à une

valeur non négative quelconque.

On peut ensuite modifier ce programme pour qu’il calcule la moyenne des valeurs saisies.

float x,som=0.;

int compt=0;

x=1.;

while(x>=0.)

{

cin >> x;

if (x>=0.)

{

compt++;

som+=x;

}

}

if(compt) cout << "la moyenne est : " << som/compt;

3.4.2.2 Forme faire … Tant que / do … while.

3.4.2.2.1 Algorithme faire … tant que.

La différence annoncée entre la forme tant que …faire et faire… tant que était dans l’ordre de

placement de la condition et des instructions à exécuter. L’algorithme de faire …tant que place les

instructions avant la condition. Voici son algorithme :

Faire

instructions

TantQue(condition)

Les instructions sont exécutées, au moins, une fois. Leur exécution plus d’une fois dépendra de l’état

de la condition.

3.4.2.2.2 Son organigramme.

3.4.2.2.3 Sa syntaxe

La traduction de Faire … TantQue dans le langage C/C++ est do…while() ;

do

instruction

1/true

0/false

Fin

Début

Instructions

Condition

while(condition);

Attention au point-virgule présent après la condition. La condition entre parenthèse doit être une

expression logique. Par ailleurs, dans le cas de la présence de plusieurs instructions, il faut les placer

entre accolades.

Do {

instructions

} while(condition);

3.4.2.2.4 Exemples.

D’une manière générale, tout ce qui est écrit avec une des deux formes de boucle peut être réécrit

avec l’autre moyennant des adaptations mineures.

Exemple 1 : Reprenons l’exemple 4 précédent.

Il s’agit de lire, au clavier, des nombres réels tant qu’ils sont positifs ou nuls ; dès qu’un nombre

négatif est saisi la lecture doit s’arrêter. Calculer ensuite la moyenne des nombres saisis.

float x, moy, som;

int compt = 0;

do

{

cin >> x;

if (x>=0.)

{

compt++;

som+=x;

}

} while(x>=0.);

if(compt) cout << "la moyenne est : " << som/compt;

Comme on peut le constater, on lit d’abord x et ensuite on teste son signe. Selon sa valeur on

revient faire une autre lecture ou on sort de la boucle. Il n’a pas été nécessaire d’initialiser x comme

dans le cas de while.

Exemple 2 :

Afficher tous les multiples pairs de 3 inferieurs à 100.

int n = 100, i = 1;

do

{

if (i%2 == 0 && i%3 == 0) cout << i << " est pair et mult de 3" <<endl;

i++;

}while( i <= 100 );

3.4.2.3 Forme for

La forme des structures répétitives utilisant for s’apparente beaucoup à celle utilisant while, en ce

sens que le test y est effectué avant l’exécution du bloc d’instructions ; en plus d’un réarrangement

des autres éléments de la structure.

3.4.2.3.1 Syntaxe de for

for a la syntaxe suivante dans le cas général de présence de plusieurs instructions:

for ([expression1] ; [expression2] ; [expression3])

{

instructions

}

Remarque : les crochets [] ne font pas partie de la syntaxe, mais ils indiquent que ce qu’il y a

dedans est facultatif, et qu’il peut être omis.

Nature et sens des expressions incluses dans for :

expression1 : est exécutée une fois et une seule, tout au début de la première itération. Pour

cela, on l’utilisera pour l’initialisation d’une variable dite de contrôle, qui servira dans la

condition.

expression2 : elle servira de contrôle pour la boucle. Si vrai on exécute les instructions, si

fausse on quitte la boucle.

expression3 : elle est exécutée à la fin de chaque itération. On peut y modifier la valeur de

la variable de contrôle, comme par incrémentation ou décrémentation par exemple.

3.4.2.3.2 Exemple.

On va prendre un exemple avec un cas de boucle fait avec la forme while que l’on convertie en

forme for. On pourrait écrire un programme qui affiche 5 fois le mot « hello » en utilisant une

variable de contrôle qui est un entier i :

Avec while avec for

int i; int i;

i = 0;

while( i < 5 ) for( i=0; i < 5; i++ )

{ {

cout << "Hello ! " << i << endl; cout << "Hello ! " << i << endl;

i++;

} }

On remarquera que :

L’expression1 : i = 0 correspond à l’initialisation.

L’expression2 : i < 5 correspond à la condition.

L’expression3 : i++ correspond à l’incrémentation.

Pour montrer que la présence des expressions, dans for( ; ; ) est facultative, on peut apporter

ces quelques modifications, au code ci-dessus :

int i;

i = 0;

for( ;i < 5; )

{

cout << "Hello ! " << i << endl;

i++;

}

Ce programme s’exécutera normalement.la ressemblance avec la forme while devient évidente.

On peut également supprimer la condition i < 5. La syntaxe sera toujours correcte.

Quand la condition est absente, par défaut, le langage la considère comme vraie. On va obtenir

une boucle infinie. Cela n’a pas beaucoup d’intérêt pratique.

3.4.2.4 Opérateur séquentiel.

Selon le contexte, l’opérateur virgule (,) peut servir de séparateur. C’est le cas des lignes de

déclaration :

int a, b, c;

Dans cet exemple, l’opérateur (,) sert à séparer les différentes variables.

Dans d’autres cas, il peut servir comme opérateur séquentiel :

L’opérateur séquentiel (,) permet de regrouper des sous-expressions dans une seule expression. Les

sous-expressions y apparaissent sous forme d’une liste, sur une même ligne. Ces sous-expressions

sont évaluées en séquence (à la suite les unes après les autres). La valeur d'une liste d'expressions est

celle de la dernière de la liste.

Exemple, soit les expressions suivantes :

i++;

j += 5;

k = i + 2 * j;

Si on écrivait

i++, j += 5, k = i + 2 * j;

On obtiendrait un opérateur séquentiel avec (,) dans lequel les expressions précédentes sont

devenues des sous expressions d’une instruction terminée par (;).

L’expression i++ est d’abord évaluée, suivie de j += 5, et k = i + 2 * j est évaluée en

dernier. C'est-à-dire que l’associativité est de gauche vers la droite.

Il ne faut pas confondre cette écriture avec cette autre écriture :

i++; j += 5; k = i + 2 * j;

Laquelle à l’évidence est équivalente à la première, où les expressions occupaient une ligne chacune.

Ici, les trois sont sur la même ligne, mais chacune est terminée par un point-virgule.

Un autre exemple pour montrer la deuxième partie de la définition : La valeur d'une liste

d'expressions est celle de la dernière de la liste.

i = (j++, i+3, k+1);

Dans cet exemple, la variable i prendra la valeur k+1 tout simplement ; mais auparavant, la sous

instruction j++ sera exécutée, suivie de l’expression i+3 et enfin k+1. Comme k+1 est la dernière

expression, alors i sera égale à k+1. Notez que la présence des parenthèses est déterminante, sinon

la séquence précédente aura une autre interprétation.

L’usage de l’opérateur séquentiel se rencontre particulièrement dans les structures de contrôle de

répétition for.

3.4.2.5 Opérateur séquentiel (,) dans for.

Souvent, dans l’usage de la forme for, on a besoin de plus qu’une instruction dans l’initialisation

ou dans l’incrémentation. Dans ces cas l’operateur séquentiel est très utile.

Prenons un exemple : Deux variables i et j, initialement à 0 et 60 respectivement. i augmente d’un

pas de 2, et j diminue d’un pas de 3. Où se trouve l’intersection ?

Pour répondre, on écrit le code suivant :

int i, j;

for( i=0, j=60; i < j; i=i+2, j=j-3 )

{

cout << "i= " << i << " j= " << j << endl;

}

Notez l’utilisation de (,) dans les initialisations et les incrémentations. Le critère d’arrêt de boucle,

est que i doit rester inferieur à j. Dès que ce n’est plus vrai, on arrête la boucle.

A l’exécution, on a la réponse ; l’intersection se trouve dans les intervalles [22,24] pour i et [24,27]

pour j.

3.4.2.6 Les branchements inconditionnels : continue, break et goto.

Ces instructions vont faire le branchement vers un endroit précis du programme sans aucune

condition préalable.

Elles vont ainsi interrompre l’exécution pas à pas du programme, et générer un saut de quelques

lignes.

La lecture par l’homme (pas pour la machine), du code du programme, devient un exercice difficile

sinon impossible.

La programmation, dite structurée, évite ce genre d’instructions, ou du moins, en limite l’usage.

Ces instructions sont : break, continue et goto.

Les instructions continue et break ont un usage contrôlé, pourvu qu’on les utilise dans des

structure de contrôle comme les boucles. Les effets seront limités à cette seule structure.

L’instruction goto est vivement déconseillée, car elle permet de faire des sauts de n’importe, vers

n’importe dans le programme. Elle existe toujours dans les compilateurs, pour des raisons

historiques, mais aussi pour des usages orientés machines.

3.4.2.6.1 continue

Si on limite son usage aux boucles, les effets de cette instruction sont :

Continue renvoie à la fin de l’itération en cours en sautant toutes les instructions qui la suivent.

Prenons l’exemple d’un programme qui afficherait les diviseurs d’un entier N, ignorerait les non

diviseurs. Les diviseurs 1 et N étant connus d’avance.

6 int N, i, compt;

7

8 cout << "Entrez un nombre : ";

9 cin >> N;

10

11 for ( compt=0, i = 2; i < N; i++ )

12 {

13 if ( N % i != 0 ) continue;

14 cout << i << " est diviseur de " << N << endl;

15 compt++;

16 }

17 cout << "Nbre de diviseurs = " << compt;

A la ligne 13, il y a l’instruction continue. Si le reste de la division de N par i est non nul,

continue est activée. Alors les lignes 14 et 15 sont sautées, on reste dans la boucle mais on passe

dans le pas suivant, c.à.d. à i+1.

3.4.2.6.2 break.

Utilisée dans une boucle, break fait sortir de la boucle, en sautant toutes les instructions qui la

séparent de l’accolade fermant le bloc.

Exemple : étant donné un nombre entier N, on écrit un programme qui permet de dire s’il est un

nombre premier, ou non ?

Pour cela, on passe tous les nombres de 2 à N-1, si N possède un seul diviseur, il ne sera pas

premier. Si on rencontre un tel diviseur, on affiche un message et on utilise break pour arrêter la

boucle.

Une fois en dehors de la boucle, on teste i, s’il a atteint N, c’est qu’il n y a pas de diviseur de N. on

affiche un message.

6 int N, i, compt; 7

8 cout << "Entrez un nombre : ";

9 cin >> N;

10

11 for ( i = 2; i < N; i++ )

12 {

13 if ( N % i == 0 )

14 {

15 cout << i << " est diviseur de " << N << endl;

16 cout << N << " n\'est pas un nombre premier";

17 break;

18 }

19 }

20 if(i>=N) cout << N << " est un nombre premier ";

21

3.4.2.6.3 goto.

Avant de pouvoir utiliser l’instruction goto, on aura besoin de savoir ce qu’est une étiquette.

– Etiquette/Label.

Une étiquette –label en anglais- est une numérotation des lignes d’un programme.

Une étiquette doit porter un nom, qui respecte les règles des identificateurs.

Elle doit être insérée, à l’endroit du programme que l’on voudrait étiqueter, suivie du caractère

spécial (:).

Le nom donné à une étiquette n’a pas besoin d’être déclaré. Les étiquettes possèdent un espace

de noms propre.

– Exemples d’étiquettes.

L0, L1 et L2, dans le programme qui suit sont des étiquettes.

– goto.

Elle s’utilise avec la syntaxe :

goto etiquette :

goto L1 : // par exemple

Elle opère un branchement non conditionnel de la ligne d’appel, vers l’étiquette, sans aucune

formalité.

Pour illustrer ces propos, on va donner comme exemple, la conception d’une boucle avec goto,

sans avoir besoin, ni de while ni de for.

Cette boucle sera faite pour i allant de : i=0 à i=N, N étant un entier quelconque.

6 L0:

7 int N, i, compt;

8

9 cout << "Entrez un nombre >0 : ";

10 cin >> N;

11

12 i = 0;

13 L1:

14 cout << "valeur de i : " << i << endl;

15 /// + autres instructions

16 i++;

17

18 if ( i < N ) goto L1;

19 else goto L2;

20 L2:

21 cout << "Message: sortie de boucle" << endl;

22

Dans la ligne n°18 est présente l’instruction goto. Tant que i reste inférieur à N, goto renvoie vers

l’étiquette L1 (boucle), dès que i devient égale à N, goto renvoie vers L2 (hors boucle).

3.5 Les tableaux.

Les variables, telles que nous les avons vues, jusqu’à présent, ne permettent de stocker qu'une seule

donnée à la fois. Une information requiert un nom. Et donc à plusieurs informations, plusieurs

noms. A ce rythme, un programme risque de consommer un nombre considérable de noms.

Pour réduire le nombre de noms de variables dans un programme, le langage utilise :

Les tableaux – ou listes- pour grouper les données de même type, sous un seul nom.

Les structures pour grouper des données de types hétérogènes sous un même nom.

Il s’avère que ces tableaux et structures, ont des vertus supplémentaires, qui n’étaient pas offertes

avec des variables simples, comme par exemple, la possibilité d’opérer des processus de tri ou de

transferts de données.

3.5.1 Définition d’un tableau.

Un tableau est un ensemble fini d’éléments de même type, stockés en mémoire à des adresses

contigües (les unes à la suite des autres).

Un tableau est donc une suite de cases de même taille.

La taille des cases est déterminée par le type des données. Ainsi, on pourrait avoir :

Des données des types de base : int, char, float, long, double, etc.

Des pointeurs (objets contenant une adresse mémoire).

Des tableaux.

Des structures.

Etc.

Les tableaux peuvent être monodimensionnels (ou vecteurs), ou multidimensionnels (matrice,

table).

3.5.2 Tableau à une dimension

3.5.2.1 Déclaration.

Pour exister, un tableau doit être, d’abord déclaré.

La syntaxe de la déclaration d'un tableau unidimensionnel est la suivante :

Type_des_données Nom_du_tableau [Nombre d'éléments] ;

Type_des_données Définit le type des éléments du tableau, char, int, float, etc.

Nom_du_tableau Est le nom attribué au tableau. Ce doit être un identificateur.

Nombre d'éléments Est un nombre entier qui détermine le nombre de cases que contient

le tableau. Ce paramètre doit être bien défini à la compilation. Ça peut

être une variable, déclarée avec #define, ou par const.

[ ] opérateur –obligatoire- contient la taille.

Exemples :

int t[5];

char lettre[6];

t est un tableau de 5 entiers, lettre est un tableau de 6 caractères.

3.5.2.2 Accès aux éléments d’un tableau

3.5.2.2.1 Par affectation

Apres la déclaration, il devient possible d’accéder aux éléments du tableau, en lecture et en écriture. D’abord, on doit savoir quelles sont les variables crées ? Les variables créés suite à la déclaration, sont : t[0], t[1], t[2], t[3] et t[4], exclusivement. Il est obligatoire de conserver la numérotation de : 0 à 4.

Ainsi, si on veut leur affecter les valeurs : -1, 617, 0, -10 et 4, par exemple, on écrira : t[0] = -1; t[1] = 617;

t[2] = 0;

t[3] = -10;

t[4] = 4;

3.5.2.2.2 Par initialisation.

Peut attribuer des valeurs aux éléments d’un tableau au moment de la déclaration.

int t[5] = {-1, 617, 0, -10, 4};

3.5.2.2.3 Opérations avec les éléments de tableaux.

On peut faire des opérations avec les éléments d’un tableau à l’instar de toute autre variable.

t[0]= 2*t[1]+5;

3.5.2.3 Exemple.

Voici un code dans lequel un tableau, de N entiers, est rempli par lecture au clavier ; puis affiché à

l’écran.

#include<iostream>

using namespace std;

const int N = 5;

int main()

{

int t[N],i;

cout << "Saisir " << N << " entiers";

for(i=0; i<N; i++)

{

cout << "\nEntrez t[" << i << "] = ";

cin >> t[i];

}

cout << "\nles elements du tableau saisis sont:" << endl;

for(i=0;i<N;i++)

cout << "t[" << i << "]= " << t[i] << endl;;

}

1 INTRODUCTION ............................................................................................................................................... 3

1.1 Objectifs du module Informatique : Programmation C++. .......................................................................................... 3

1.2 Un peu d’histoire. ......................................................................................................................................................... 3

1.3 Avant de commencer ................................................................................................................................................... 3

2 PREMIER PROGRAMME. ................................................................................................................................. 4

2.1 Edition ........................................................................................................................................................................... 4

2.2 Compilation .................................................................................................................................................................. 4

2.3 L’exécution .................................................................................................................................................................... 6

2.4 Les environnements de développement intégré (EDI). .............................................................................................. 6

2.4.1 Aperçu. ............................................................................................................................................................................. 6

2.4.2 Edition. ......................................................................................................................................................................... 6

2.4.3 Compilation et exécution. ......................................................................................................................................... 7

2.5 Eléments constitutifs du premier programme. ............................................................................................................ 7

2.5.1 #include<iostream> ........................................................................................................................................................... 7

2.5.2 La fonction principale : main ............................................................................................................................................. 7

2.5.3 Les accolades { }. ................................................................................................................................................................ 8

2.5.4 Les instructions. ................................................................................................................................................................. 8

2.5.5 Les commentaires ............................................................................................................................................................. 8

3 ELEMENTS DE BASE DU LANGAGE C++. ................................................................................................... 9

3.1 Généralités .................................................................................................................................................................... 9

3.1.1 Les unités lexicales : Les mots du langage. ........................................................................................................................ 9

3.1.1.1 Les mots-clés (Keywords). ........................................................................................................................................ 9

3.1.1.2 Les identificateurs (identifiers) ............................................................................................................................... 10

3.1.1.3 Les constantes littérales. ........................................................................................................................................ 10

3.1.1.4 Les opérateurs ........................................................................................................................................................ 10

3.1.1.5 Les signes de ponctuations. .................................................................................................................................... 10

3.1.2 Les phrases du langage : Les instructions. ...................................................................................................................... 11

3.1.3 Les structures de contrôles. ............................................................................................................................................ 11

3.1.4 Les programmes. ............................................................................................................................................................. 11

3.2 La notion de variable ................................................................................................................................................. 11

3.2.1 Les noms de variables...................................................................................................................................................... 11

3.2.2 Les types de variables ...................................................................................................................................................... 12

3.2.2.1 Les types caractères. ............................................................................................................................................... 12

3.2.2.2 Les types entiers et le type logique. ....................................................................................................................... 12

3.2.2.3 Le type logique. ...................................................................................................................................................... 13

3.2.2.4 Les types flottants. .................................................................................................................................................. 13

3.2.3 Les déclarations de variables ........................................................................................................................................... 14

3.2.4 Les assignations des variables ................................................................................................................................... 14

3.2.4.1 Les affectations de valeurs à une variable. ............................................................................................................. 14

3.2.4.2 Les initialisations des variables. .............................................................................................................................. 15

3.3 La notion d’opérateur ................................................................................................................................................ 15

3.3.1 L’opérateur d’affectation =.......................................................................................................................................... 15

3.3.2 Les opérateurs arithmétiques. .................................................................................................................................. 16

3.3.2.1 Les opérateurs + d’addition et – de soustraction. .................................................................................................. 16

3.3.2.2 Les opérateurs * de multiplication et / de division. ............................................................................................... 16

3.3.2.3 L’operateurs % de modulo. ..................................................................................................................................... 17

3.3.2.4 Le type du résultat d’une opération arithmétique. ................................................................................................ 17

3.3.3 L’opérateur de cast. .................................................................................................................................................. 17

3.3.4 Opérateurs d’incrémentation ++ et de décrémentation −−. ............................................................................ 17

3.3.5 Priorité et associativité des opérations. .................................................................................................................. 18

3.3.5.1 Priorité. ................................................................................................................................................................... 18

3.3.5.2 Associativité. ........................................................................................................................................................... 19

3.3.6 Les opérateurs relationnels. ...................................................................................................................................... 20

3.3.6.1 Définition d’une « expression ». ............................................................................................................................. 20

3.3.6.2 Définitions d’un « operateur relationnel » ............................................................................................................. 20

3.3.6.3 Liste des opérateurs relationnels ........................................................................................................................... 20

3.3.6.4 Exemples d’expression relationnelle. ..................................................................................................................... 21

3.3.7 Les opérateurs logiques............................................................................................................................................. 21

3.3.7.1 Définition. ............................................................................................................................................................... 21

3.3.7.2 Exemples ................................................................................................................................................................. 22

3.3.7.3 Les priorités et les associativités............................................................................................................................. 22

3.3.8 Récapitulatif des règles de priorité et d’associativité. ........................................................................................... 23

3.4 La notion de structure de contrôle. ........................................................................................................................... 23

3.4.1 Les structures de choix. ................................................................................................................................................. 23

3.4.1.1 Les structures conditionnelles alternatives. ........................................................................................................... 24

3.4.1.1.1 Son algorithme. ............................................................................................................................................... 24

3.4.1.1.2 Son organigramme. ......................................................................................................................................... 24

3.4.1.1.3 Sa syntaxe. ....................................................................................................................................................... 24

3.4.1.1.4 Un exemple. .................................................................................................................................................... 25

3.4.1.2 Les structures conditionnelles simples. .................................................................................................................. 25

3.4.1.2.1 Son algorithme. .............................................................................................................................................. 25

3.4.1.2.2 Son organigramme. ........................................................................................................................................ 25

3.4.1.2.3 Sa syntaxe. ....................................................................................................................................................... 26

3.4.1.2.4 Un exemple..................................................................................................................................................... 26

3.4.1.3 Les structures conditionnelles imbriquées ............................................................................................................. 26

3.4.1.3.1 Son algorithme. ................................................................................................................................................. 27

3.4.1.3.2 Son organigramme. ........................................................................................................................................... 27

3.4.1.3.3 Sa syntaxe. ......................................................................................................................................................... 27

3.4.1.3.4 Un exemple. ...................................................................................................................................................... 28

3.4.1.4 Les structures à choix multiples : switch ................................................................................................................ 28

3.4.1.4.1 Son algorithme .................................................................................................................................................. 28

3.4.1.4.2 Son organigramme. ........................................................................................................................................... 29

3.4.1.4.3 Sa syntaxe. ......................................................................................................................................................... 29

3.4.1.4.4 Exemples. .......................................................................................................................................................... 29

3.4.2 Les structures répétitives /itératives. ........................................................................................................................ 30

3.4.2.1 Forme tant que … faire / while ............................................................................................................................. 30

3.4.2.1.1 Algorithme tant que … faire ............................................................................................................................. 30

3.4.2.1.2 Son organigramme. ........................................................................................................................................... 31

3.4.2.1.3 Sa syntaxe .......................................................................................................................................................... 31

3.4.2.1.4 Exemples. .......................................................................................................................................................... 31

3.4.2.2 Forme faire … Tant que / do … while. ................................................................................................................... 33

3.4.2.2.1 Algorithme faire … tant que. ............................................................................................................................ 33

3.4.2.2.2 Son organigramme. ........................................................................................................................................... 33

3.4.2.2.3 Sa syntaxe .......................................................................................................................................................... 33

3.4.2.2.4 Exemples. .......................................................................................................................................................... 34

3.4.2.3 Forme for ............................................................................................................................................................... 34

3.4.2.3.1 Syntaxe de for ................................................................................................................................................... 34

3.4.2.3.2 Exemple. ............................................................................................................................................................ 35

3.4.2.4 Opérateur séquentiel.............................................................................................................................................. 36

3.4.2.5 Opérateur séquentiel (,) dans for. ......................................................................................................................... 36

3.4.2.6 Les branchements inconditionnels : continue, break et goto............................................................................... 37

3.4.2.6.1 continue ............................................................................................................................................................ 37

3.4.2.6.2 break. ................................................................................................................................................................. 37

3.4.2.6.3 goto. .................................................................................................................................................................. 38

3.5 Les tableaux. ............................................................................................................................................................... 39

3.5.1 Définition d’un tableau. ................................................................................................................................................ 39

3.5.2 Tableau à une dimension ......................................................................................................................................... 39

3.5.2.1 Déclaration. ............................................................................................................................................................ 39

3.5.2.2 Accès aux éléments d’un tableau .......................................................................................................................... 40

3.5.2.2.1 Par affectation ................................................................................................................................................... 40

3.5.2.2.2 Par initialisation. ................................................................................................................................................ 40

3.5.2.2.3 Opérations avec les éléments de tableaux. ....................................................................................................... 40

3.5.2.3 Exemple. ................................................................................................................................................................. 40