Support Programmation C++

Support de cours de programmation en C++
Chapitre 1 La Structure d'un programme
1. La structure d'un programme C++

#include <cstdlib>
#include<iostream>
using namespace std;
int a,b,s;
int main()
{ cout<<"Donnez deux entier";

Cin>>a>>b;
s=a+b;
cout<<a<<"+"<<b<<"="<<s;
sytem("pause");
return 0;
}
2. Déclarations de variables
Les types de base du C++ sont les mêmes que les types du C, avec les extensions suivantes:
• Le type bool
• La notion de référence
• Le type class (fondamental, car c'est lui qui permet de définir les objets)
La déclaration se fait par:
type nomvariable1, nomvariable2;
3. Les types de données

• Le type entier : int
Ce type peut être utilisé avec des qualificatifs pour indiquer sa taille (long ou short), et le
fait qu'il soit signé (signed) ou non (unsigned).
Pour les entiers et les caractères, le qualificateur signed est appliqué par défaut.
• Le type booléen: bool (Seulement en C++)
Un booléen peut prendre les valeurs true ou false. Il est possible de convertir un booléen en
entier et vice-versa; dans ce cas, true se convertit en 1, false se convertit en 0. Dans l'autre
sens, 0 est converti en false et tout entier non nul est converti en true.
• Les types réels
Ils sont codés de façon interne sous forme mantisse + exposant.
1. float: c'est le type réel simple précision, codé sur 32 bits

Réalisé par MATY Maman Page 1
2. double: c'est le type réel en double précision, codé sur 64 bits.
3. long double: c'est le type réel en précision étendue ou quadruple précision, codé
sur 128 bits.
• Le type char
Un seul caractère. Une lettre, un chiffre ou un symbole
• Le type string
C'est une chaine de caractère qui est considéré comme un tableau de caractères
4. Les opérateurs
Opérateurs signification Opérateurs signification Opérateurs signification
+ Plus. == égalité ! non
- Moins != non égalité || ou
* Fois > supérieur && et
/ diviser < inférieur >= supérieur ou égal
% Modulo (reste) = affectation <= inférieur ou égal
5. L'écriture
• Afficher un message : Cout<<"le message";

• Afficher le contenu d'une variable: cout<<nomvariable;
• Affiche un message et le contenu d'une variable: Cout<<"la somme de "<<a<<" et "
<<b<<"="<<s;
• Revenir à la ligne; cout<<endl; ou cout<<"\n";
• Effacer l'écran: system("cls");
6. La lecture
Lecture d'une variable cin>>nomvariable: cin>>a;
Lecture de deux variables: cin>>a>>b;
Nb: Quand on lit une variable il faut appuyer sur la touche entrée pour valider la saisie.

Chapitre II Les Structure de contrôle
1. Le if
Cette structure de contrôle permet d'exécuter une instruction ou une suite d'instructions seulement si
une condition est vraie.
Syntaxe :
if (condition) instruction
Exemple :
#include <iostream>
Using namespace std;
int main()
{
int a;
cout << "Tapez la valeur de a : "; cin >> a;
if (a > 10)
cout << "a est plus grand que 10" << endl;
cout << "Le programme est fini" << endl;
return 0;
}
Le if...else
Cette structure de contrôle permet d'exécuter une instruction si une condition est vraire, ou une autre
instruction si elle est fausse.
if (condition)
instruction1 ;
else
instruction2 ;
Exemple
#include <iostream>
int main()
int a;
if (a > 10)
cout << "a est plus grand que 10" << endl;
else
cout << "a est inférieur ou égal à 10" << endl;
return 0;
}

Exemples
1. Écrire un programme qui calcule la valeur absolue d'un réel x

2. Écrire un programme qui demande un nombre entier à l'utilisateur, puis qui teste
et affiche s'il est divisible par 3
3. Écrire un programme qui lit nombre et affiche si le nombre est nul, positif ou négatif
2. Le switch
L'instruction switch permet de tester plusieurs valeurs pour une expression. C'est une forme
réorganisée de if
Syntaxe
switch(expression)
{
case constante1:
instruction1_1; break;
case constante2:
instruction2_1; break;
...
default:
instruction;
}
Expression de type scalaire (entier, caractère, énumération, booléen).
Exemple 1
#include <iostream>
int main()
{
int a;
switch(a)
{
case 1 :
cout << "a vaut 1" << endl;
break;
case 2 :
break;
case 3 :
break;
default :
cout << "a ne vaut ni 1, ni 2, ni 3" << endl;
break;
}
return 0;}
Ce programme demande à l'utilisateur de taper une valeur entière et la stocke dans la variable a. On
teste ensuite la valeur de a : en fonction de cette valeur on affiche respectivement les messages "a
vaut 1", "a vaut 2", "a vaut 3", ou "a ne vaut ni 1, ni 2, ni 3".

Example 2
#include <iostream>
int main()
{ int a;
switch(a)
{
case 1 :
break;
case 2 :
case 4 :
cout << "a vaut 2 ou 4" << endl;
break;
case 3 :
case 7 :
case 8 :
cout << "a vaut 3, 7 ou 8" << endl;
break;
default :
cout << "valeur autre" << endl;
break;
}
return 0;
}
Ce programme demande à l'utilisateur de taper une valeur entière et la stocke dans la variable a. On
teste ensuite la valeur de a : en fonction de cette valeur on affiche respectivement les messages "a
vaut 1", "a vaut 2 ou 4", "a vaut 3, 7 ou 8", ou "valeur autre".
3. Le for
Le for est une structure de contrôle qui permet de répéter un certain nombre de fois une partie d'un
programme.
Syntaxe
for(instruction_init ; condition ; instruction_suivant)

instruction_repetée
Exemples
Premier cas simple :
#include <iostream>
int main()
{ int i;
for(i=0 ; i<10 ; i++)
cout << i*i << endl;
return 0;
}

4. Le while
Syntaxe
Initialisation ;
while (condition)
{
instruction;
incrementation ;
}
Exemple de programme
#include <iostream>
int main()
{
int i = 0;
while (i < 10)
{
cout << "La valeur de i est : " << i << endl;
i++;
}
cout << "La valeur finale de i est : " << i << endl;
return 0;
}
5. Le do ... while
Syntaxe
Initialisation ;,
do {
...instructions ;
Incrémentation ;
} while( condition );
Exemple
#include <iostream>
using namesapce std;
int main()
{ int i = 0;
do
{ cout << "La valeur de i vaut : " << i << endl; i = i + 1;
}
while (i < 10);
cout << "La valeur finale de i est " << i << endl; return 0;}

TD1 Structures de contrôle

Exo 1
1. Écrire un programme qui résout l’équation ax2+bx+c=0 en envisageant tous

les cas particuliers.
2. Écrire un programme qui demande à l’utilisateur de saisir un entier X et qui
affiche la valeur absolue de X.
3. Écrire un programme qui demande à l’utilisateur de saisir 3 entiers A, B et C et
qui indique si C est compris entre A et B, bornes incluses.
4. Écrire un programme qui demande à l’utilisateur de saisir un entier A
puis qui affiche "ERREUR" si A n'est pas un nombre impair compris entre
83 et 101 bornes incluses. Dans le cas contraire, on affiche "PAS
D'ERREUR".
Exo 2
1. Écrire un programme ; qui dit si une année donnée est une année bissextile.
Une année est bissextile si elle est divisible par 4
2. Écrire un programme qui demande un numéro de mois à l’utilisateur et
indique en retour son nom et le nombre de jours dans ce mois.
Exo 3 :
Écrire un programme qui lit le nombre d'années le nombre de moi et des jours pour
tout en jour. Exemple: 9 ans 8 mois et 20 jours=3500jours
Exo 4 :
Écrire un programme qui lit un entier n et affiche entiers inférieurs ou égaux a n, leurs
carrés et leurs cubes. Il affiche à la fin la somme de ces entiers ; la somme des carrés
et la somme des cubes.
n n² n3
0 0 0
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
15 55 225

Exo 5:
1. Écrire un programme qui va afficher à l’écran les entiers compris entre 5 et 35.
2. Écrire un programme qui va afficher les multiples de 3 compris entre deux bornes
données
3. Écrire un programme qui va afficher les multiples de 4 compris entre deux bornes
données
4. Écrire un programme qui calcule le maximum entre quatre entier a, b, c et d.
Exo 6:
1. Écrire un programme, qui affiche les multiple d'un entier donné inférieurs à 100;
2. Écrire un programme qui affiche les diviseurs d'un entier n donnée
Exo 7:
1. Écrire un programme qui demande un nombre compris entre 10 et 20, jusqu’à

ce que la réponse convienne. En cas de réponse supérieure à 20, on fera
apparaître un message : « Plus petit ! », et inversement, « Plus grand ! » si le
nombre est inférieur à 10.
2. Écrire un programme qui demande un nombre de départ, et qui calcule la
somme des entiers jusqu’à ce nombre.
3. Écrire un programme qui un réel n et calcule la somme
s=1 +…+
4. Écrire un programme ; qui lit une série de réels, calcule puis affiche leur
somme S ; leur produit P et leur Moyenne M. le programme va s'arrêter
lorsque l'utilisateur entre 0 (zéro)
5. Écrire un programme qui demande à l’utilisateur de saisir 2 entiers A et B qu'il
affiche à l'écran. Le programme ne s'arrêtera que lorsque les deux entiers
seront tous impairs
Exo 8:
Écrire un seul programme qui permet de :
1. Saisir k réels
2. Calculer et afficher leur somme
3. Calculer et afficher leur moyenne
4. Afficher leur minimum
5. Afficher leur Maximum

Chapitre 3. Les tableaux
I. Les vecteurs
1. Utilité des tableaux
Imaginons que dans un programme, nous ayons besoin simultanément de 12

valeurs (par exemple, des notes pour calculer une moyenne). Évidemment, la seule
solution dont nous disposons à l’heure actuelle consiste à déclarer douze variables,
appelées par exemple Notea, Noteb, Notec, etc. Bien sûr, on peut opter pour une
notation un peu simplifiée, par exemple N1, N2, N3, etc. Mais cela ne change pas
fondamentalement notre problème, car arrivé au calcul, et après une succession de
douze instructions « Lire » distinctes, cela donnera obligatoirement une instruction
du genre :
Moy = (N1+N2+N3+N4+N5+N6+N7+N8+N9+N10+N11+N12)/12
C’est pourquoi l'algorithme nous permet de rassembler toutes ces variables en une
seule, au sein de laquelle chaque valeur sera désignée par un numéro.
2. Définition
Un tableau est un regroupement de variables de même type, il est identifié par un

nom. Chacune des variables du tableau est numérotée, ce numéro s’appelle
un indice. Chaque variable du tableau est donc caractérisée par le nom du tableau
et son indice.
Si par exemple, T est un tableau de 10 variables, alors chacune d’elles sera

numéroté et il sera possible de la retrouver en utilisant simultanément le nom du
tableau et l’indice de la variable. Les différentes variables de T porteront des
numéros de 1 à 10, et nous appellerons chacune de ces variables un élément de T.
3. Déclaration
Comme les variables d’un tableau doivent être de même type, il convient de
préciser ce type au moment de la déclaration du tableau. De même, on précise lors
de la déclaration du tableau le nombre de valeurs qu’il contient.
La syntaxe est :
Type nomtableau [nombre element];
4. Accès aux éléments
Les éléments d’un tableau à n éléments sont indicés de 0 à n-1. On

note T(i) l’élément d’indice i du tableau T. Les quatre éléments du tableau de
l’exemple ci-avant sont donc notés T[0], T[1], T[2] et T[3].

5. Exemple
#include<iostream>
#include<cstdlib>
int i,n,a;
int main()
{
cout<<" donnez la taille du tableau:";
cin>>n;
int T[n];
for(i=0;i< n;i++)
{
cout<<"Donnez la valeur "<<i+1<<" du tableau:";
cin>> T[i]=a;
}
for(i=0;i< n;i++)
cout<<T[i]<<"\t";
cout<<endl;
system("pause");
return 0;
}
Ce type de boucle s’appelle un parcours de tableau. En règle générale on utilise

des boucles pour manier les tableaux, celles-ci permettent d’effectuer un traitement
sur chaque élément d’un tableau. Pour lire ou afficher un tableau il est plus facile
d'utiliser la boucle pour.
II. LES TRIS D'UN TABLEAU

1. Tri par sélection
Admettons que le but de la manœuvre soit de trier un tableau de 12 éléments dans
l’ordre croissant. La technique du tri par sélection est la suivante : on met en bonne
position l’élément numéro 1, c’est-à-dire le plus petit. Puis en met en bonne position
l’élément suivant. Et ainsi de suite jusqu’au dernier. Par exemple, si l’on part de :
45 122 12 3 21 78 64 53 89 28 84 46
On commence par rechercher, parmi les 12 valeurs, quel est le plus petit élément, et
où il se trouve. On l’identifie en quatrième position (c’est le nombre 3), et on l’échange
alors avec le premier élément (le nombre 45). Le tableau devient ainsi :
3 122 12 45 21 78 64 53 89 28 84 46
On recommence à chercher le plus petit élément, mais cette fois, seulement à partir
du deuxième (puisque le premier est maintenant correct, on n’y touche plus). On le trouve

en troisième position (c’est le nombre 12). On échange donc le deuxième avec le
troisième :
3 12 122 45 21 78 64 53 89 28 84 46
On recommence à chercher le plus petit élément à partir du troisième (puisque les

deux premiers sont maintenant bien placés), et on le place correctement, en
l’échangeant, ce qui donnera in fine :
3 12 21 45 122 78 64 53 89 28 84 46
On continue la recherche jusqu’à l’avant dernier élément
• Boucle principale : prenons comme point de départ le premier élément, puis

le second, etc, jusqu’à l’avant dernier.
• Boucle secondaire : à partir de ce point de départ mouvant, recherchons
jusqu’à la fin du tableau quel et le plus petit élément. Une fois que nous l’avons
trouvé, nous l’échangeons avec le point de départ.
void triselection(int T[])

{ int i,j,k,aux;
for(i=0 ;i<nb-1;i++)
{ k=i;
for(j=i+1; j<nb;j++)
if (T[j] < T[k])
k=j;
aux=T[k];
T[k]=T[i];
T[i]=aux;
}}
2. Tri à bulles
L’idée de départ du tri à bulles consiste à se dire qu’un tableau trié en ordre croissant,
c’est un tableau dans lequel tout élément est plus petit que celui qui le suit.
En effet, prenons chaque élément d’un tableau, et comparons-le avec l’élément qui le suit.
Si l’ordre n’est pas bon, on permute ces deux éléments. Et on recommence jusqu’à ce que l’on
n’ait plus aucune permutation à effectuer. Les éléments les plus grands « remontent » ainsi
peu à peu vers les premières places, ce qui explique la charmante dénomination de « tri à
bulle ».
void tribulle(int t[])
{ int aux;
for(i=0; i<nb-1; i++)
for(j=i+1; j<nb; j++)
if (t[i]>t[j])
{ aux=t[j];
t[j]=t[i];
t[i]=aux;
}}

3. Tri par insertion
#include<iostream>
#include<cstdlib>
int a,i,j,k,n;
int main()
{
cout<<"Donner le nombre d'element:";
cin>>n;
int t[n];
i=0;
while(i<n)
{
cout<<"donner la valeur"<<i<<":";
cin>>a;
if (i==0)
t[0]=a;
else
if(a<t[i-1])
t[i]=a;
else
if(a>t[0])
{
for(j=i;j>0;j--)
t[j]=t[j-1];
t[0]=a;
}
else
{
k=0;
while(t[k]>a)
k++;
//cout<<"k="<<k<<"i="<<i;
//system("pause");
for(j=i;j>k;j--)
t[j]=t[j-1];
t[k]=a;
}
i++;
}
for(i=0;i<n;i++)
cout<<t[i]<<"\t";
cout<<endl;
system("pause");
return 0;
}
4. LA RECHERCHE DICHOTOMIQUE
On coupe le tableau en deux parties et on cherche dans une partie des partie qui sera
elle aussi divisée en deux sous parties jusqu''à la l'obtention ou pas de la valeur
recherchée.

void recherchedicho(int t[], int elm,int nb)
{ bool trouver=false; int inf,sup;
tribulle(t);
inf=0; sup= nb-1;
while ((inf<=sup)&&(not trouver))
{ i=(inf+sup) / 2;
I f (t[i]==elm)
trouver=true;
else
if(t[i]<elm) inf=i+1;
else sup=i-1;
}
if (trouver)
cout << elm << " est dans le tableau"<<endl;
else
cout << elm << " n'est pas dans le tableau"<<endl;;
}
Programme complet
#include <iostream>
#include <string>
bool trouver=false;
int nb,T[100],n,i;
void triselection(int T[])

{ int i,j,k,aux;
for(i=0 ;i<nb-1;i++)
{ k=i;
for(j=i+1; j<nb;j++)
if (T[j] < T[k])
k=j;
aux=T[k];
T[k]=T[i];
T[i]=aux;
}
}
void afficher(int T[])

{
for(i=0;i<nb;i++)
cout <<T[i]<<" ";
cout<<endl;
}

void saisie(int T[])
{
cout<<"Donnez la taille du tableau:";
cin>>nb;
for(i=0;i<nb;i++)
{ cout<<"Donnea la valeur de l'element "<< i <<":";
cin>>T[i];
}
}
void tribulle(int t[])

{ int aux;
for(i=0; i<nb-1; i++)
for(j=i+1; j<nb; j++)
if (t[i]>t[j])
{ aux=t[j];
t[j]=t[i];
t[i]=aux;
}
}
void recherchedicho(int t[], int elm,int nb)
{ bool trouver=false; int inf,sup;
tribulle(t);
inf=0; sup= nb-1;
while ((inf<=sup)&&(not trouver))
{
i=(inf+sup) / 2;
if (t[i]==elm)
trouver=true;
else
if(t[i]<elm)
inf=i+1;
else
sup=i-1;
}
if (trouver)
cout << elm << " est dans le tableau"<<endl;
else
cout << elm << " n'est pas dans le tableau"<<endl;;
}
int main ()
{
saisie(T);
afficher(T);
rechercher();
tribulle(T);
afficher(T);
system("PAUSE"); return 0;}
TD2 TABLEAUX
EXERCICE 1
1. Écrire un programme qui demande à l'utilisateur de saisir n entiers stockés dans un

tableau. Le programme doit afficher le nombre d'entiers supérieurs ou égaux à 10.
2. Le programme doit rechercher si un réel V se trouve dans le tableau et afficher "V se
trouve dans le tableau" ou "V ne se trouve pas dans le tableau".
3. Le programme doit ensuite afficher l'indice du plus grand élément du tableau.
4. Le programme doit ensuite afficher soit "le tableau est croissant", soit "le tableau est
décroissant", soit "le tableau est constant", soit "le tableau est quelconque".
EXERCICE 4
Écrire un programme qui demande à l'utilisateur de saisir n entiers stockés dans un tableau.
Le programme doit permettre de:
1. saisir et afficher k réels

2. Calculer et afficher leur somme
3. Calculer et afficher leur moyenne
4. Chercher et afficher leur minimum
5. Chercher et afficher leur Maximum Le programme
6. Trier le tableau par ordre croissant et réafficher le tableau.
7. Rechercher une valeur donnée dans le tableau
EXERCICE 3
Écrire un programme qui demande à l'utilisateur de saisir n nom stockés dans un tableau.
Le programme doit permettre de:
1. saisir et afficher les n Noms;
2. Chercher et afficher le plus petit nom
3. Chercher et afficher le grand petit nom
4. Trier le tableau par ordre croissant et réafficher le tableau.

Chapitre 4 Les sous programmes

Certains problèmes conduisent à des programmes longs, difficiles à écrire et à
comprendre. On les découpe en des parties appelées sous-programmes ou
modules. Les fonctions et les procédures sont des modules (groupe
d'instructions) indépendants désignés par un nom. Elles ont plusieurs intérêts :
• permettent de "factoriser" les programmes, càd de mettre en

commun les parties qui se répètent
• permettent une structuration et une meilleure lisibilité des
programmes
• facilitent la maintenance du code (il suffit de modifier une seule
fois)
• ces procédures et fonctions peuvent éventuellement être
réutilisées dans d'autres programmes
I. Les fonctions
Le rôle d'une fonction en programmation est similaire à celui d'une fonction en
mathématique : elle retourne un résultat à partir des valeurs des paramètres
Une fonction s'écrit en dehors du programme principal sous la forme :
type nomfonction(parametres)
{
Return type resultat;

}
#include<iostream>
#include<cstdlib>
int x,y,z;
bool b;
int sommecarre(int x, int y)

{
int z;
z=(x*x)+(y*y);
return z;
}

bool paire(int x)
{
return x%2==0;
}
int minimum(int a, int b)

{
int mn=a;
if(b<mn)
mn=b;
return mn;
}
int factorielle(int n)
{
int f=1,i;
for(i=1;i<=n;i++)
f=f*i;
return f;
}
int puissance(int a, int b)

{
int p=1,i;
for(i=1;i<=b;i++)
p=p*a;//p*=a;
return p;
}
int main()
{
int c;
do
{
cout<<"\n1: sommecarre\n";
cout<<"2: paire\n";
cout<<"3: minimum\n";
cout<<"4: factorielle\n";
cout<<"5: puissance\n";
cout<<"6: quitter\n";
cout<<"faite votre choix:";
cin>>c;
while(c<1||c>6)
{
cout<<"faite votre choix:";
cin>>c;
}
switch(c)
{
case 1:
cout<<"donner deux entiers:";
cin>>x>>y;
z=sommecarre(x,y);
cout<<"z = "<<z;break;
case 2:
cout<<"donner un entier:";
cin>>x;
b=paire(x);
if(b)
cout<<x<<" est pair ";
else
cout<<x<<" est impair ";
cout<<endl;break;
case 3:
cin>>x>>y;
z=minimum(x,y);
cout<<"le minimum = "<<z;break;
case 4:
cout<<"donner un entier:";
cin>>x;
z=factorielle(x);
cout<<"la factorielle de"<<"x"<<" = "<<z;
cout<<endl;
break;
case 5:
cin>>x>>y;
z=puissance(x,y);
cout<<x<<"^"<<y<<" = "<<z<<endl;
break;
case 6:
cout<<"bye bye"<<endl;
break;
}
}
while(c!=6);
return 0;
}

II. Les procédures
Dans certains cas, on peut avoir besoin de répéter une tache dans plusieurs
endroits du programme, mais que dans cette tache on ne calcule pas de
résultats ou qu'on calcule plusieurs résultats à la fois
Dans ces cas on ne peut pas utiliser une fonction, on utilise une procédure
Une procédure est un sous-programme semblable à une fonction mais qui ne

retourne rien
Une procédure s'écrit en dehors du programme principal sous la forme :
void nomprocedure(parametres)
{
corps de la procedure ;
}
Remarque : une procédure peut ne pas avoir de paramètres
L'appel d'une procédure, se fait dans le programme principal ou dans une autre
procédure par une instruction indiquant le nom de la procédure :
void nomprocedure()
{
corps de la procedure ;
}
Remarque : contrairement à l'appel d'une fonction, on ne peut pas affecter la

procédure appelée ou l'utiliser dans une expression. L'appel d'une procédure est
une instruction autonome
II. Passage des paramètres
Les paramètres servent à échanger des données entre le programme principal

(ou la procédure appelante) et la procédure appelée
Les paramètres placés dans la déclaration d'une procédure sont appelés

paramètres formels. Ces paramètres peuvent prendre toutes les valeurs
possibles mais ils sont abstraits (n'existent pas réellement)
Les paramètres placés dans l'appel d'une procédure sont appelés paramètres
effectifs. Ils contiennent les valeurs pour effectuer le traitement

TD sur les fonctions
EXERCICE 1
Écrire une fonction distance ayant comme paramètres 4 doubles xa,ya et xb,yb qui représentent les
coordonnées de deux points A et B et qui renvoie la distance AB.
EXERCICE 2
Écrire une fonction f ayant comme paramètres un double x et un booléen ok et qui renvoie un double
par un return. La fonction renvoie par un return la racine carrée de (x-1)*(2-x). La fonction renvoie par
l'intermédiaire de la variable ok la valeur true si la fonction est définie au point x, false sinon.
EXERCICE 3
Écrire une fonction f ayant en paramètre un entier et qui renvoie par un return un booléen : true si
l'entier est premier et false sinon.
EXERCICE 4
Écrire une fonction f ayant comme paramètre un entier n et qui renvoie le n-ième nombre premier :
cette fonction utilisera la fonction du 3).
EXERCICE 5
Écrire une fonction swap ayant en paramètres 2 entiers a et b et qui échange les contenus de a et de
b. .
EXERCICE 6
Écrire une fonction f ayant en paramètres un tableau t de taille quelconque et un entier n indiquant la
taille du tableau. f doit renvoyer par un return un booléen b indiquant s'il existe une valeur comprise
entre 0 et 10 dans les n premières cases du tableau t
EXERCICE 7
taille du tableau. f doit renvoyer par un return le nombre de valeurs comprises entre 0 et 10 dans les n
premières cases du tableau t.
EXERCICE 8
taille du tableau. f possède un autre paramètre v , entier passé par référence. f doit renvoyer par un
return un booleén b indiquant s'il existe une valeur comprise entre 0 et 10 dans les n premières cases
du tableau t. Si f renvoie true, v est égal à la valeur de la première case du tableau comprise entre 0 et
10.
EXERCICE 9
Écrire une fonction f ayant en paramètres un tableau t1 de taille quelconque et un entier n indiquant la
taille du tableau, ainsi qu'un tableau t2 de la même taille que t1. f doit renvoyer par un return un entier
nb indiquant le nombre de valeurs comprises entre 0 et 10 dans le tableau t1. f doit mettre dans le
tableau t2 les différentes valeurs comprise entre 0 et 10 qu'il a rencontrées dans le tableau t1.
EXERCICE 10
taille du tableau. f doit renvoyer par un return un entier égal à l'indice de la première case du tableau
(parmi les n premières) comprise entre 0 et 10. S'il n'existe pas de telle valeur, la fonction renvoie -1.

Chap5 Récursivité
Un module (fonction ou procédure) peut s'appeler lui-même: on dit que c'est un
module récursif
Tout module récursif doit posséder un cas limite (cas trivial) qui arrête la
récursivité
Exemple : Calcul de la factorielle
#include <iostream>
#include<cstdio>
int f;
int facto(int n)
{
if( n==1)
return 1;
else
return n*facto(n-1);
}
int main()
{ int n;
cout<<"Donnez un entier:";
cin >>n;
f=facto(n);
cout<<"La factorielle de " <<n <<" = " <<f<<endl;;
system("pause");
return 0;
}
Exemple
Écrivez une fonction récursive (puis itérative) qui calcule le terme n de la suite
définie par : U(0)=2; U(1)=3 et U(n)=4U(n-1)+2U(n-2)
#include<iostream>
#include<cstdlib>
int n,s;
int suite(int n)
{
if(n==0)
return 2;
else
if(n==1)
return 3;
else
return 4*suite(n-1) + 2*suite(n-2);
}
int main()
{
cout<<"Donner un entier:";
cin>>n;
s=suite(n);
cout<<"U("<<n<<") = "<<s<<endl;
system("pause");
return 0;
}
Une procédure récursive qui permet d'afficher la valeur binaire d'un entier n
#include<iostream>
#include<cstdlib>
int n;
void binaire(int n)
{
if(n!=0)
{
binaire(n/2);
cout<<n%2;
}
}
int main()
{
cout<<"Donner un entier:";
cin>>n;
cout<<n<<" = ";binaire(n);
cout<<endl;
system("pause");
return 0;
}

Chapitre 6 Les structures
Structure
La notion de structure permet de manipuler sous forme d'une entité unique un objet composé
d'éléments, appelés membres ou champs, de types pouvant être différents. Elle est très proche
de la notion de classe en programmation orientée objet.
1. Déclaration d'une structure
Voici un exemple de déclaration d'une structure:
struct personne {
char nom[20];
char prenom[20];
int no_ss;
}
struct Client
{
int Age;
float Taille;
} maty;
ou, plus simplement :
struct
{
int Age;
float Taille;
} maman;
1. Accès aux champs d'une structure:
L'accès aux champs d'une structure se fait avec l’opérateur.. Par exemple, si l'on reprend la
structure complexe z, on désignera le champ re par z.re. Les champs ainsi désignés peuvent
être utilisés comme toute autre variable.
2. Déclaration d'une variable de type structure
[struct] nom_structure identificateur;

Exemple - Déclaration de structure
struct Client
{
int Age;
string nom,prenom
folat Taille;
};
struct Client Maty, Maman;
3. Définition de nouveau type de type structure
typedef struct nomstructure nouveau type;
typedef struct client cli;
4. Exemples
a) Structure employé
include<iostream>
#include<cstdlib>
struct employer
{
string nom;
string prenom;
float salaire;
};
typedef struct employer emp;

emp e,T[20];
int n;
void saisie()
{
cout<<" donnez le nombre d'employers: ";
cin>>n;
for(int i=0;i<n;i++)
{
cout<<" donnez le nom "<<i<<":";
cin>>e.nom;
cout<<" donnez le prenom "<<i<<":";
cin>>e.prenom;
cout<<"donnez le salaire de "<<i<<":";
cin>>e.salaire;
T[i]=e;
}
}
void afficher()
{
for(int i=0;i<n;i++)
cout<<T[i].nom<<"\t"<<T[i].prenom<<"\t"<<T[i].salaire<<endl;
}
void trier()
{
int i,j;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(T[i].salaire<T[j].salaire)
{ e=T[i];
T[i]=T[j];
T[j]=e;
}
}
void rechercher(emp T[])

{
bool ok=false;
int i;string v;
cout<<" donnez le nom rechercher: ";
cin>>v;
i=0;
while(i<n&&!ok)
{
if(T[i].nom==v)
{
ok=true;
cout<<v<<" est trouve "<<endl;
}
i++;
}
if(!ok)
cout<<v<<" n'est pas engage "<<endl;
}
int main()
{
saisie();
afficher();
rechercher(T);
trier();
cout<<"\n----tableau trier----\n";
afficher();
system(" pause ");
return 0;
}

b) Structure Etudiant
#include<iostream>
#include<cstdlib>
#include<myconio.h>
struct etudiant
{
string nom,prenom,mention;
float moyenne,age;
int rang;
};
typedef struct etudiant etud;
etud e,T[20];int n,i,j,k;
void saisie()
{
cout<<" donnez le nombre d'etudiant: ";
cin>>n;
for(i=0;i<n;i++)
{
cout<<"donnez le nom:";
cin>>e.nom;
cout<<" donnez le prenom:";
cin>>e.prenom;
cout<<" donnez son age:";
cin>>e.age;
cout<<" donnez sa moyenne:";
cin>>e.moyenne;
T[i]=e;
}
}
void afficher(int k)
{
gotoxy(1,1);
cout<<" nom ";
gotoxy(15,1);
cout<<" prenom ";
gotoxy(25,1);
cout<<" age ";
gotoxy(35,1);
cout<<" moyenne ";
gotoxy(45,1);
cout<<" mention ";
gotoxy(60,1);
cout<<" rang ";
for(i=0;i<n;i++)
{
gotoxy(1,k);cout<<T[i].nom;
gotoxy(15,k);cout<<T[i].prenom;
gotoxy(25,k);cout<<T[i].age;
gotoxy(35,k);cout<<T[i].moyenne;
gotoxy(45,k);cout<<T[i].mention;
gotoxy(60,k);cout<<T[i].rang;
k=k+2;
}
cout<<endl;
}
void mention()
{
for(i=0;i<n;i++)
{
if(T[i].moyenne<10)
T[i].mention=" ajourne ";
else
if(T[i].moyenne<12)
T[i].mention=" passable ";
else
if(T[i].moyenne<14)
T[i].mention=" assez bien ";
else
if(T[i].moyenne<16)
T[i].mention=" bien ";
else
if(T[i].moyenne<18)
T[i].mention=" tres bien ";
else
if(T[i].moyenne<20)
T[i].mention=" excellent ";
}
}
void trier()
{
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(T[j].moyenne>T[i].moyenne)
{
e=T[i];
T[i]=T[j];
T[j]=e;
}
}
void rang()
{
T[0].rang=1;
i=0;
for(j=i+1;j<n;j++)
if(T[i].moyenne==T[j].moyenne)
T[j].rang=T[i].rang;
else
{
T[j].rang=j+1;
i=j;
}
}
void admis()
{
for(i=0;i<n;i++)
{
if(T[i].moyenne<10)
cout<<T[i].nom<<"\t"<<T[i].prenom<<"\t"<<T[i].age<<"\t"<<T[i].moyenne<<"\t"<<T[i].mentio
n<<"\t"<<T[i].rang<<"\n";
}
cout<<"\n-------\n";
}
void redoublant()
{
for(i=0;i<n;i++)
{
if(T[i].moyenne<10&&T[i].moyenne>=8)
n<<"\t"<<T[i].rang<<"\n";
}
cout<<"\n-------\n";
}
void exclu()
{
for(i=0;i<n;i++)
{
if(T[i].moyenne<8)
n<<"\t"<<T[i].rang<<"\n";
}
cout<<"\n-------\n";
}
int main()
{
saisie();
system("cls");
afficher(3);
system("pause");
mention();
trier();
rang();
system("cls");
afficher(3);
gotoxy(1,20);
admis();
redoublant();
exclu();
system(" pause ");
return 0;
}

TD4 Structures
EXO1:
Soit une structure étudiant composée des champs Nom, Prénom, Age, Moyenne, Rang et Mention.
1. Écrire une fonction qui permet de saisir la liste des étudiants
2. Écrire une fonction qui permet d'afficher la liste des étudiants
3. Écrire une fonction qui permet d'affecter une mention aux étudiants
4. Écrire une fonction qui permet d'affecter le rang aux étudiants
5. Écrire une fonction qui permet d'afficher la liste des admis
6. Écrire une fonction qui permet d'afficher la liste des exclus
7. Écrire une fonction qui permet d'afficher la liste des redoublants
8. Écrire une fonction qui permet rechercher un étudiant en fonction de Nom et de son Prénom
9. Écrire le programme principal avec un menu correspondant aux différentes fonctions
EXO2:
Soit une structure monôme composée des champs coefficient et exposant.
1. Écrire une fonction qui permet de saisir la liste des monômes (polynôme)
1. Écrire une fonction qui permet d'afficher la liste un polynôme
2. Écrire une fonction qui permet de calculer et afficher la dérivée d'un polynôme
3. Écrire une fonction qui permet de calculer et afficher la primitive d'un polynôme
4. Écrire une fonction qui permet de calculer et afficher la somme de deux polynômes
Exo3:
Soit une structure article composée des champs désignation; quantité; prix et Montant.
1. Écrire une fonction qui permet de saisir une liste d'articles
2. Écrire une fonction qui permet d'afficher la facture correspondante aux articles saisis;
3. Écrire une fonction qui permet de calculer et afficher le montant total hors taxe; le montant
TVA (18%) du montant hors taxe et le montant TTC.

Chapitre 6 Les listes chainées

1. Définition
2. Création d'une liste chainée.
3. Insertion à la tète (la pile)
liste* saisieTete(liste* &t)

{ ter='n';
t=NULL;
while (ter=='n')
{ cout<<"Donnez l'element: ";
cin>>e;
p=new(liste);
p->elm=e;
p->svt=t;
t=p;
cout<<"Terminer? ";
cin>>ter;
}
return t;
}
4. Insertion à la queue(File)
liste * saisiequeue(liste *&t)

{ ter='n';
t=NULL;
while (ter=='n')
cin>>e;
p=new(liste);
p->elm=e;
p->svt=NULL;
if(t==NULL)
{ t=p;
q=t;
}
else
{ q->svt=p;
q=q->svt;
}
cout<<"Terminer? ";cin>>ter;
}
return t;
}
5. Affichage d'une liste
void afficher(liste* t)
{ p=t;
while (p!=NULL)
{ cout<<p->elm<<" ";
p=p->svt;
}
cout<<endl;
}
6. Programme principal
int main()
{
menu();
return 0 ;
}

Exemple complet sur les listes chainées
#include <cstring>
#include <iostream>
struct liste{
int elm;
liste* svt;
};
liste *t,*t1,*t2;
int e;char ter;
liste* saisieTete(liste* &t)

{
ter='n';
t=NULL;
while (ter=='n')
{
cout<<"Donnez l'element: ";
cin>>e;
p=new(liste);
p->elm=e;
p->svt=t;
t=p;
cout<<"Terminer? ";
cin>>ter;
}
return t;
}
liste * saisiequeue(liste *&t)

{ter='n'; t=NULL;
while (ter=='n')
cin>>e;
p=new(liste);
p->elm=e;
p->svt=NULL;
if(t==NULL)
{ t=p; q=t;
}
else
{
q->svt=p;
q=q->svt;
}
cout<<"Terminer? ";
cin>>ter;
}
return t;
}

liste* saisieordonner(liste* &t)
{ liste *s,*r;
ter='n';
t=NULL;
while (ter=='n')
{
cout<<"Donnez l'element: ";
cin>>e;
p=new(liste);
p->elm=e;
p->svt=NULL;
if(t==NULL)
t=p;
else
if (p->elm<t->elm)
{ p->svt=t;
t=p;
}
else
{
r=t;
while(r->elm<=p->elm && r->svt!=NULL)
{ s=r;
r=r->svt;
}
if(r->elm>p->elm)
{ p->svt=r;
s->svt=p;
}
else
r->svt=p;
}
cout<<"Terminer? ";
cin>>ter;
}
return t;
}
void afficher(liste* t)
{ p=t;
while (p!=NULL)
{
cout<<p->elm<<" ";
p=p->svt;
}
}

void menu()
{
int i;
cout<<endl<<endl<<"*************"<<endl;
cout<<"1:Saisie Tete"<<endl;
cout<<"2:Saisie Queue"<<endl;
cout<<"3:Saisie Ordonne"<<endl;
cout<<"4:Fusionner Deux Listes"<<endl;
cout<<"5:Quitter"<<endl;
cout<<endl<<endl<<"***********"<<endl;
cout<<"Faite votre choix:"; cin>>i;
while (i<0 ||i>5)
{ cout <<"Choix incorrect recommencer:";
cin>>i;
}
switch (i)
{
case 1:
saisieTete(t);
afficher(t);
menu();
break;
case 2:
saisiequeue(t);
afficher(t);
menu();
break;
case 3:
saisieordonner(t);
afficher(t);
menu();
break;
case 4:
cout<<endl<<"En chantier"<<endl;
menu();
break;
case 5:
cout<<"Fin"<<endl;
}
}
int main()
{
menu();
return 0 ;
}

Lorsque vous créez un algorithme utilisant des conteneurs, il existe différentes manières de les
implémenter, la façon la plus courante étant les tableaux, que vous connaissez tous. Lorsque
vous créez un tableau, les éléments de celui-ci sont placés de façon contiguë en mémoire. Pour
pouvoir le créer, il vous faut connaître sa taille. Si vous voulez supprimer un élément au milieu du
tableau, il vous faut recopier les éléments temporairement, ré-allouer de la mémoire pour le
tableau, puis le remplir à partir de l'élément supprimé. En bref, ce sont beaucoup de
manipulations coûteuses en ressources.
Une liste chaînée est différente dans le sens où les éléments de votre liste sont répartis dans la
mémoire et reliés entre eux par des pointeurs. Vous pouvez ajouter et enlever des éléments
d'une liste chaînée à n'importe quel endroit, à n'importe quel instant, sans devoir recréer la liste
entière.
Nous allons essayer de voir ceci plus en détail sur ces schémas :
Vous avez sur ce schéma la représentation que l'on pourrait faire d'un tableau et d'une liste
chaînée. Chacune de ces représentations possède ses avantages et inconvénients. C'est lors de
l'écriture de votre programme que vous devez vous poser la question de savoir laquelle des deux
méthodes est la plus intéressante.
• Dans un tableau, la taille est connue, l'adresse du premier élément aussi. Lorsque vous
déclarez un tableau, la variable contiendra l'adresse du premier élément de votre
tableau.
Comme le stockage est contigu, et la taille de chacun des éléments connue, il est
possible d'atteindre directement la case i d'un tableau.
• Pour déclarer un tableau, il faut connaître sa taille.
• Pour supprimer ou ajouter un élément à un tableau, il faut créer un nouveau tableau et

supprimer l'ancien. Ce n'est en général pas visible par l'utilisateur, mais c'est ce que
realloc va souvent faire. L'adresse du premier élément d'un tableau peut changer après
un realloc, ce qui est tout à fait logique puisque realloc n'aura pas forcement la possibilité
de trouver en mémoire la place nécessaire et contiguë pour allouer votre nouveau
tableau. realloc va donc chercher une place suffisante, recopier votre tableau, et
supprimer l'ancien.
• Dans une liste chaînée, la taille est inconnue au départ, la liste peut avoir autant
d'éléments que votre mémoire le permet.
Il est en revanche impossible d'accéder directement à l'élément i de la liste chainée.
Pour ce faire, il vous faudra traverser les i-1 éléments précédents de la liste.
• Pour déclarer une liste chaînée, il suffit de créer le pointeur qui va pointer sur le premier
élément de votre liste chaînée, aucune taille n'est donc à spécifier.

• Il est possible d'ajouter, de supprimer, d'intervertir des éléments d'une liste chaînée sans
avoir à recréer la liste en entier, mais en manipulant simplement leurs pointeurs.
Chaque élément d'une liste chaînée est composé de deux parties :
• la valeur que vous voulez stocker,
• l'adresse de l'élément suivant, s'il existe.

S'il n'y a plus d'élément suivant, alors l'adresse sera NULL, et désignera le bout de la
chaîne.
Voilà deux schémas pour expliquer comment se passent l'ajout et la suppression d'un élément
d'une liste chaînée. Remarquez le symbole en bout de chaîne qui signifie que l'adresse de
l'élément suivant ne pointe sur rien, c'est-à-dire sur NULL.

Langue

Support Programmation C++

Transféré par

Informations du document

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Support Programmation C++

Titre original :

Transféré par

Droits d'auteur :

Support de cours de programmation en C++

Chapitre 1 La Structure d'un programme

1. La structure d'un programme C++

{ cout<<"Donnez deux entier";

La déclaration se fait par:

type nomvariable1, nomvariable2;

3. Les types de données

• Le type booléen: bool (Seulement en C++)

• Les types réels

Ils sont codés de façon interne sous forme mantisse + exposant.

1. float: c'est le type réel simple précision, codé sur 32 bits

Un seul caractère. Une lettre, un chiffre ou un symbole

+ Plus. == égalité ! non

- Moins != non égalité || ou

* Fois > supérieur && et

/ diviser < inférieur >= supérieur ou égal

% Modulo (reste) = affectation <= inférieur ou égal

• Afficher un message : Cout<<"le message";

Lecture de deux variables: cin>>a>>b;

Réalisé par MATY Maman Page 2

Réalisé par MATY Maman Page 3

1. Écrire un programme qui calcule la valeur absolue d'un réel x

Expression de type scalaire (entier, caractère, énumération, booléen).

Réalisé par MATY Maman Page 4

for(instruction_init ; condition ; instruction_suivant)

Premier cas simple :

Réalisé par MATY Maman Page 5

Réalisé par MATY Maman Page 6

TD1 Structures de contrôle

1. Écrire un programme qui résout l’équation ax2+bx+c=0 en envisageant tous

Réalisé par MATY Maman Page 7

1. Écrire un programme qui demande un nombre compris entre 10 et 20, jusqu’à

Écrire un seul programme qui permet de :

Réalisé par MATY Maman Page 8

Imaginons que dans un programme, nous ayons besoin simultanément de 12

Un tableau est un regroupement de variables de même type, il est identifié par un

Si par exemple, T est un tableau de 10 variables, alors chacune d’elles sera

Type nomtableau [nombre element];

4. Accès aux éléments

Les éléments d’un tableau à n éléments sont indicés de 0 à n-1. On

Réalisé par MATY Maman Page 9

Ce type de boucle s’appelle un parcours de tableau. En règle générale on utilise

II. LES TRIS D'UN TABLEAU

Réalisé par MATY Maman Page 10

On recommence à chercher le plus petit élément à partir du troisième (puisque les

On continue la recherche jusqu’à l’avant dernier élément

• Boucle principale : prenons comme point de départ le premier élément, puis

void triselection(int T[])

Réalisé par MATY Maman Page 11

Réalisé par MATY Maman Page 12

void triselection(int T[])

void afficher(int T[])

Réalisé par MATY Maman Page 13

void tribulle(int t[])

1. Écrire un programme qui demande à l'utilisateur de saisir n entiers stockés dans un

1. saisir et afficher k réels

Réalisé par MATY Maman Page 15

Chapitre 4 Les sous programmes

• permettent de "factoriser" les programmes, càd de mettre en

Une fonction s'écrit en dehors du programme principal sous la forme :

Return type resultat;

int sommecarre(int x, int y)

Réalisé par MATY Maman Page 16

int minimum(int a, int b)