Vous êtes sur la page 1sur 81

Introduction au langage C++

•Premier programme
•Les entrées-sorties
•Les affectations
•Les structures de contrôle
•Les fonctions
•Les structures de données simples
1
Premier programme

#include<iostream.h>

int main(int argc, char * argv[])


{
cout<<" Bonjour U-AUBEN 1 !";
cout<<endl;
return 0;
}

2
3
Tout programme C++ Il va être nécessaire
doit contenir une d'utiliser les fonctions
fonction principale d'entrée-sortie

#include<iostream.h>

int main(int argc, char * argv[])


{
cout<<" Bonjour ESI 1!";
cout<<endl;
return 0;
}
4
Introduction à la notion de fonction en C++

#include<iostream.h>

int main(int argc, char * argv[]) y = f (x )


{
…….
return 0; y = cos (x )
}
5
(x,y)
longueur d’un vecteur
lié à l’origine
(0,0)

f ( x , y )= √x2 + y2

2
f  →Â

? Â f(Â ,Â)

double longueur(double x, double y);

6
main est une fonction
prenant deux arguments
et retournant
#include<iostream.h> une valeur entière.

int main(int argc, char * argv[])


{
…….
return 0; main retourne la valeur 0.
}

7
Avertissement….Warning

-------------------Configuration: Premier - Win32 Debug--------------------


Compiling...
Bonjour.cpp
C:\ESI1\EspaceW\Premier\Bonjour.cpp(8) : warning C4508: 'main' : function should
return a value; 'void' return type assumed
Linking...

Premier.exe - 0 error(s), 1 warning(s)

8
Les entrées-sorties

9
cin>>
Programme
3.14159 cout<<
3.14159
#include<iostream.h>

int main(int argc, char * argv[])


{
double x;
cout<<" lecture d’une valeur " ;
cin>>x ;
cout<<" écriture de la valeur lue"<<x ;
return 0;
}

10
Les variables
La plupart des langages sont basés sur la même technique
fondamentale, à savoir la manipulation de valeurs contenues
dans des variables.
Une variable est un emplacement donné dans la mémoire de la
machine et repéré par un nom . Cette notion simple est en fait la
notion la plus importante de la programmation. Nous n’aurons
pas, en effet, à nous préoccuper de savoir où sont stockées les
informations dont nous avons besoin.
On peut voir une variable comme une boîte dans laquelle, à
chaque instant, une et une seule VALEUR est rangée. Pour
connaître ou modifier cette valeur il va falloir ouvrir la boîte
(instruction de lecture ou d’écriture).
11
Pour des raisons d’économie de place et d’efficacité des calculs, on précisera
d’abord quel sera le type des valeurs qui pourront être rangées dans cette boîte.

Une variable qui contiendra un entier n’aura pas la même taille qu’une
variable devant contenir un réel. Une variable pourra contenir autre chose que
des nombres : un caractère, une chaîne de caractères...... Une fois le type
d’une variable décidé (déclaration) il n’est plus possible de le changer.

#include<iostream.h>

int main(int argc, char * argv[]){

double x;
char c;
char nom[50];
return 0;
}

12
Attention aux habitudes de l’algèbre
Il y a deux différences essentielles entre les variables
en mathématiques et celles de l’informatique.

En général, x, y, a, b ....... désignent des


variables en mathématiques. En
informatique, il sera préférable de
donner à chaque variable un nom
significatif.

Une variable informatique ne


peut contenir qu’une seule
valeur à tout moment 13
Une variable en informatique = boîte le contenant
capable de contenir une information de l’information

Cette boîte est repérable grâce à son nom : c’est


le moyen de désigner/référencer cette boîte.

Moyenne 15,25

L’information contenue dans la


variable correspond à son contenu
14
Soit x un élément de N

x désigne n’importe quelle valeur de N

ax2 + bx +c =0

x désigne en même temps les deux racines


éventuelles de ce trinôme.

15
Le type d’une variable (1)

Les informations contenues en mémoire sont codées en


binaire. En particulier le contenu de chaque variable sera
lui aussi codé en binaire.

Dans ces conditions, le contenu binaire d’une variable n’est


pas suffisant pour connaître sa valeur. Il faudra préciser quel
est le type de la variable considérée.

0 1 1 0 1 1 1 0

16
Le type d’une variable (2)

Le type d’une variable considérée précise :

1. le nombre de bits utilisés par la variable

2. la signification à donner aux différents


groupes de bits décrivant ce type

17
Les types numériques

Réels Entiers
float 4 octets short 1 octet
double 8 octets int 2 octets
long 4 octets

Deux octets
un octet 0 1 1 1 0 0 1 0
On représente les entiers (int) compris entre -32768 et 32767.
8 7 6 5 4 3 2 1
Quatre octets
Il y a 28 combinaisons possibles de 0 et de 1. Un octet ne peut donc
On représente
représenter queles
256entiers
objets(long) compris entre
distincts.
-2 147 483 648 et 2 147 483 647. 18
Quatre octets

On représente les réels (float) compris entre


3,4 10-38 et 3,4 1038

Huit octets

On représente les réels (double) compris entre


1,7 10-308 et 1,7 10308

mantisse exposant

0.5298014 -21
19
x=3.14;
y=7.345;

cout<<endl<<endl<<" Le capitaine "<<nom<<" a "


<<ceil(4*sin(x)+3*log(y)-1)<<" ans"<<endl;

20
Affecter une valeur à une variable
Si on imagine une variable comme une boîte contenant une valeur,
affecter une valeur à une variable signifie mettre cette valeur dans la
boîte.

double x; 3.14
6.28

double y;

x=3.14; x=2*x;
21
double x; mettre dans la boîte de nom x, le
nombre 3.14.

x=3.14;

mettre dans la boîte de nom x, la


x=x+1; valeur actuelle de la boîte
augmentée de 1.

Attention ! Ce n’est pas une équation !!!

0=1;
22
Voici deux variables de type réel.
X 13.0
4.5
10.5
12.0
? Prédire la valeur de ces variables
après l’exécution des instructions
suivantes :
1) X=10.5;
y 1.5
3.5
? 2) y=1.5;
3) X=X+y;
4) X=X+1;
5) X=y*3;
6) y=X-1;

23
Les structures de contrôle

24
L’intérêt essentiel de l’ordinateur (et sa puissance)
proviennent de deux concepts :

la possibilité d’effectuer des choix dans les traitements


réalisés
la possibilité de répéter plusieurs fois la même
instruction (ou le même groupe d’instructions)

Ce sont les structures de contrôle du déroulement des


algorithmes. Ces structures apparaissent dans tous les
langages évolués.

25
Un algorithme est une suite précise, non ambiguë,
d'étapes pouvant être exécutées automatiquement
pour arriver à un résultat à partir de données.

Algorithme

26
Un exemple
1 Choisissez un nombre entier naturel différent de zéro.

2 Si cet entier est impair alors multipliez-le par 3 et ajoutez 1.


3 S’il est pair alors divisez-le par 2.

4 Si l’entier obtenu est 1 alors vous avez terminé, sinon


recommencez en 2 avec ce nombre.

3
10 16
3 5 8
27 4
Choisir un nombre entier N N 3

si (N est impair) alors


remplacer N par 3N+1 10
sinon
remplacer N par N/2 5
finsi

si (N ≠1) alors
exécuter à nouveau le travail de
la boîte bleue
sinon
STOP
finsi
28
Choisir un nombre entier N

Tant que (N≠1) faire


si (N est impair) alors
N ← 3N+1 affectation
sinon
N ← N/2 affectation
finsi
Fintantque

29
Tantque (N≠1) faire
si (N est impair) alors
N = 3N+1
sinon
N = N/2
finsi
Fintantque

30
On peut dire qu’un algorithme comporte deux types d’instructions :
•les instructions de base (affectation, lecture, écriture)
•les instructions de structuration de l’algorithme

si cond alors
......
sinon
.....
finsi

Tant que cond faire


......
......
Fintantque
31
La syntaxe de l’alternative

…..
si condition alors
instruction1
VRAI
sinon N 3
instruction2
FAUX
finsi
…. if (N%2 = =1)
N=3*N+1;
else
N=N/2;

32
Exemple

N 10
53

if (N%2 = =1)
VRAI N=3*N+1;
else
FAUX N=N/2;

33
…..
si condition alors
instruction11
VRAI instruction12
instruction13

sinon
instruction21
FAUX instruction22

finsi
….

34
En C++, on peut regrouper des instructions entre
deux accolades pour former un bloc d’instructions.
Ce bloc d’instructions peut alors être vu comme une
instruction (une méta-instruction)
if (N%2 = =1)
{
cout<<“N est impair.”<<endl;
N=3*N+1;
cout<<“Sa nouvelle valeur est “<<N<<endl;
}
else
{
cout<<“N est pair.“<<endl;
N=N/2;
cout<<“ Sa nouvelle valeur est “<<N<<endl;
}
35
….
si condition alors
si condition alors instruction1
instruction1 sinon
finsi 
finsi
....

36
Une instruction peut-être, elle-même, une
structure de contrôle
Une méthode décrivant le calcul des racines d’un polynôme
du 2d degré

calcul de  .
si  est >0 alors
calcul des deux racines réelles
2
sinon x + x− 6
si  <0 alors 2
pas de racines réelles − 3 x +2 x− 6
sinon
2
calcul de la racine double x + 2 x +1
finsi
finsi
37
38
La syntaxe du « tant que »

…..
FAUX
tant que condition faire
VRAI instruction1;
instruction2;
instruction3;


fin tant que
….

39
Tant que (N≠1) faire
si (N est impair) alors
N = 3N+1
sinon
N = N/2
finsi
Fin tant que

40
Les règles à respecter

Règle N°1 : Initialiser la condition.

long A,C;
Qui donne la première valeur
cin>>A;
àC?
while (C!=0)
{
A = A+1;
C = 2*A-3*C+1;
}
41
Les règles à respecter

Règle N°2: Vérifier que la condition peut être modifiée à


l’intérieur de la boucle.

long A,C;
cin>>A>>C;
while (C!=0)
La variable C ne peut {
jamais A = A+1;
être modifiée !!! cout<<C;
}

42
La boucle répéter ....... jusqu’à

En théorie la structure tant que ...... fin tant que est suffisante
pour écrire une structure itérative quelconque. Cependant, la
nature du problème et la manière dont on l’aborde, font que
l’on a parfois besoin de disposer de structures différentes.

Par exemple, on peut avoir besoin de répéter une suite


d’instructions jusqu'à satisfaction d’une certaine condition. Il
n’y a pas de test d’entrée dans la boucle (on y passe TOUJOURS
au moins une fois). L’arrêt éventuel ne peut se produire qu’après
une exécution de la suite des instructions.

43
La syntaxe

répéter
instruction1;
Un bloc d’instructions
instruction2;
instruction3;
……..
jusqu’à Condition

répéter
lire son cours;
faire des exercices
jusqu’à maîtrise_du_sujet

44
do
répéter {
instruction1; instruction1;
instruction2; instruction2;
instruction3; instruction3;
…….. ……..
jusqu’à Condition }
while (Non Condition);

repeat do
{ {
i =i+1; i =i+1;
} }
until (i==10); while (i!=10);
45
On entre dans la boucle si Condition est vraie

tant que Condition faire


instruction1
instruction2
instruction3
……..
Fin tant que

Boucle pré-testée 46
On entre toujours dans la boucle

répéter
instruction1;
instruction2;
instruction3;
……..
jusqu’à Condition

Boucle post-testée
47
La boucle pour ....... fin pour
N = 1;
Tant que (N  50) faire
instruction1;
instruction2;
instruction3;
....
N = N+1
Fin tant que

Dans cette boucle, nous voulons répéter 50 fois une même


action (ou une même série d’actions). Nous savons donc à
priori combien de fois il faudra passer dans cette boucle.
Dans ce genre de situation, il est préférable d’utiliser une
structure différente. 48
N=1 Pour N = 1 à 50 faire
Tant que (N <=50) faire instruction1;
instruction1;
instruction2; instruction2;
instruction3; instruction3;
....
N = N+1
... N = N+1
Fin tant que Fin pour

La variable N est la variable compteur ; elle ne doit JAMAIS être


modifiée par une affectation à l’intérieur de la boucle.

49
Un exemple
Faire la somme des nombres entiers de 1 à 9

somme=0;
pour i = 1 à 9 faire i 1
2
3
4
somme=somme+i
fin pour

somme 0 1 3 6 10
50
51
#include <iostream.h>
#include <stdio.h>
int main(int argc, char *argv[])
{
long i, somme;
int c;
somme=0;
for (i=1;i<10;i++)
{
somme=somme+i;
cout<<somme<<endl;
}
cout<<endl;
cout<<somme;
c=getchar();
return 0;
}
52
La variable compteur ne doit JAMAIS être modifiée par une
affectation à l’intérieur de la boucle.

Mais il est possible d’utiliser la valeur de ce compteur


53
Les fonctions

54
La programmation modulaire en C++

• Un programme écrit d’un seul tenant est illisible


• La programmation modulaire permet :
– d’éviter les séquences d’instructions répétitives
– de paramétrer certains modules et de réutiliser ce qui a
déjà été fait
– l’analyse plus aisée des erreurs de syntaxe et de logique

55
longueur d’un vecteur
(x,y)

(a,b)

f (x,y)= √(x− a) +( y− b)
2 2

2
f  →Â

?
 f( ,Â)

double longueur(double
56x, double y);
En C++, un seul module : la fonction

La valeur retournée par une fonction peut ne pas être utilisée.

Une fonction peut ne fournir aucune valeur.

Une fonction peut modifier certains de ses paramètres.

Plusieurs fonctions peuvent partager des variables (variables


globales).

57
Structure d’un programme

#include <iostream.h> Les directives de compilation

#define N 100 Les déclarations globales

double sinus(double x); Les prototypes de fonctions

int main(int argc, char * argv[]) La fonction principale


{.......}

double sinus(double x) Les descriptions des fonctions


{.......}
58
Un exemple
#include <iostream.h>

void saute_ligne( void); Le prototype

int main(int argc, char * argv[])


{
cout<<‘‘Bonjour ’’;
saute_ligne(); Appel de la fonction
cout<<‘‘ESI1 !’’;
saute_ligne();
return 0;
void saute_ligne(void)
}
{
cout<<endl;
}
59
60
#include <iostream.h>
Un autre exemple
void saute_ligne(long n); Le prototype

int main(int argc, char * argv[])


{
cout<<‘‘Bonjour ’’;
saute_ligne(10); Appel de la fonction
cout<<‘‘u-auben!’’;
saute-ligne(5); Appel de la fonction
return 0;
}
void saute_ligne(long n)
{
long i;
for(i=1;i<=n;i++)
cout<<endl;
}
61
Saute_ligne(10)

Saute_ligne(5)

62
fonction = boîte noire

(x,y)

(0,0)

x
calcul
longueur de la longueur
du vecteur
y

double longueur (double x, double y);


63
Comment coder cette boîte noire ?

double longueur(double x, double y) En-tête de


la fonction
{
double z; Corps de
z=sqrt(x*x+y*y); la fonction
return z;
}

double longueur(double x, double y)


{
return sqrt(x*x+y*y);
} 64
Un autre exemple
using namespace std;
long puissance(long m, long n); long puissance(long m, long n)
int main() {
{ long i,p;
long x; long y; p=1;
cout << "entrez un chiffre"<<endl; for(i=1;i<=n;i++)
cin >> x; p=p*m;
cout << "entrez la puissance"<<endl; return p;
cin >> y; }
cout << x<<" a la puissance "<<y<<"=
" << puissance(x,y);
return 0;
}
65
#include<iostream.h>
long puissance(long m, long n);
int main(int argc, char * argv[])
{
long i;
int c;
for(i=0;i<10;i++)
{
cout << puissance(i,2)<<endl;
}
return 0;
}
long puissance(long m, long n)
{
long i,p;
p=1;
for(i=1;i<=n;i++)
p=p*m;
return p;
} 66
Paramètres d'une fonction

67
Quel avenir pour mes paramètres ?

x=????

x=10 calcul
de la longueur longueur
y=12 du vecteur

y=????

68
Un argument d’une fonction est dit en entrée lorsque toute
modification de la valeur de l’argument dans la fonction n’est
pas répercutée dans la fonction appelante. On parlera de
passage de paramètre par valeur.

On parlera de passage de paramètre par adresse ou en entrée


sortie lorsque (au contraire) les modifications intervenues sur
la variable à l’intérieur de la fonction devront être conservées
pour la fonction appelante.

69
Passage par valeurs de paramètres
ou
arguments en entrée seulement

x=10 x= 10

x_copie=10 x_copie=25
longueur
y_copie=12 y_copie=-1

y=12 y= 12

70
Passage par adresses de paramètres
ou
arguments en entrée-sortie

x=10 x= 25

x=10 x=25
longueur
y=12 y=-1

y=12 y= -1

71
Passage par valeurs de paramètres
ou
arguments en entrée seulement
La fonction travaille sur une copie de la variable

Passage par adresses de paramètres


ou
arguments en entrée-sortie
La fonction travaille sur la variable originale
72
Passage par valeur ou passage par adresse ?
La valeur modifiée La valeur modifiée
du paramètre ne vous du paramètre vous
intéresse pas à la fin intéresse à la fin de
de l’exécution de la l’exécution de la
fonction ? fonction ?

passage par valeur passage par adresse

Paramètre Paramètre
= =
copie de la variable variable originale
73
x 1 x 12
y 2 y 21
echange(x,y); echange(&x,&y);

passage par valeur passage par adresse


void echange(long a, long b) void echange(long *a, long *b)
{ {
long aux; long aux;
aux=a; aux=*a;
a=b; *a=*b;
b=aux; *b=aux;
} }

aux 1 aux 1
a 12 *a 2
b 21 *b 74
1
Passage par valeur
Appel de la fonction

void echange(long a, long b);

echange(x, y);
75
Passage par adresse
Appel de la fonction

l’adresse de x
void echange(long *a, long *b); *#@&!!!!

&x !!

echange(&x, &y);
76
Allure générale d’une fonction (1)
1. Commentaires de spécification de la fonction
On précisera ici a) le nom de la fonction, b) la liste de ses
paramètres en fournissant pour chaque paramètre son type,
son mode de transmission à la fonction et son rôle dans la
fonction, c) le résultat retourné d) le rôle de la fonction.
2. En-tête de la fonction
C’est lui qui va définir le prototype de la fonction en précisant
l’ordre dans lequel les arguments sont transmis au moment de
l’appel de la fonction, et le type de ces arguments. Il découle
Automatiquement du paragraphe précédent.
3. Corps de la fonction
Contient l’ensemble des déclarations et instructions propres à la
fonction.
77
Allure générale d’une fonction (2)
// Nom de la fonction :
1. // Paramètres de la fonction :
// Résultat retourné par la fonction :
// Rôle de la fonction :

2. Type_retourné_par_fonction Nom_fonction([typarg1 arg1[, typarg2 arg2]…])

{
// Déclaration des variables de travail

3. // Initialisation des variables de travail


// Code associé au traitement spécifique effectué par la fonction

// Résultat retourné par la fonction


}
78
Exemple d’écriture d’une fonction (1)
// Nom de fonction : doubler
// Paramètre : un entier arg passé par valeur et dont le double est à calculer
// Résultat retourné : un entier correspondant au double du paramètre transmis
// Rôle de la fonction : calculer la valeur double du paramètre transmis
int doubler(int arg)
{
// Déclaration des variables de travail
int x;
// Initialisation des variables de travail

// Code associé au traitement spécifique effectué par la fonction


x=2*arg;

// Résultat retourné par la fonction


return x;
}

79
Exemple d’écriture d’une fonction (2)
// Nom de fonction : doubler
// Paramètres
en entrée : un entier arg dont le double est à calculer
en sortie : néant
en entrée-sortie : néant
// Résultat retourné : un entier correspondant au double du paramètre transmis
// Rôle de la fonction : calculer la valeur double du paramètre transmis
int doubler(int arg)
{
// Déclaration des variables de travail
int x;
// Initialisation des variables de travail

// Code associé au traitement spécifique effectué par la fonction


x=2*arg;

// Résultat retourné par la fonction


return x;
}
80
Remarques importantes
1. On doit avoir une parfaite cohérence entre les commentaires
de spécification de la fonction et l’en-tête : tout ce qui est dit
dans l’en-tête provient des commentaires de spécification de la
fonction, et tout ce qui est dit dans les commentaires de
spécification de la fonction doit se retrouver dans l’en-tête.
2. Le corps d’une fonction ne peut être correctement rédigé si
la partie commentaire de spécification de la fonction et l’en-
tête n’ont pas clairement été décrits.

3. La liste des variables de travail = liste des variables


intermédiaires en algorithmique. C’est généralement au fur et à
mesure de l’écriture de l’algorithme que le besoin d’en utiliser
se fait sentir  liste mise continuellement à jour.
81