EXERCICE 1

[Link]();
Écrire un programme qui affiche ceci à l'écran :
return EXIT_SUCCESS;
}
Hello world!
Voici un programme illustrant
l'utilisation de cout ! EXERCICE 3
Solution Écrire un programme qui demande à
l'utilisateur de taper 5 entiers et qui affiche leur
Cet exercice a pour but de vérifier les points moyenne. Le programme ne devra utiliser que
techniques suivants :
2 variables.

 L'utilisation de cout et de endl. Solution

Cet exercice a pour but de vérifier les points
Voici le fichier source :
techniques suivants :

#include<iostream>  La notion de variables et leur

using namespace std; déclaration.
int main()  Calcul du moyenne.
{  Utilisation des types int et double.
cout << "Hello world!" << endl;  L'utilisation de cin et de cout.
cout << "Voici un programme
illustrant l'utilisation de cout !" <<  L'affectation.
endl; Voici le fichier source :
return 0;
}
#include<iostream>
using namespace std;
EXERCICE 2 int main()
{
Écrire un programme qui demande à int a;double s=0;
l'utilisateur de taper la largeur et la longueur
d'un champ et qui en affiche le périmètre et la cout<<"Tapez la valeur numero 1 :
surface. ";cin>>a;s=s+a;
cout<<"Tapez la valeur numero 2 :
Solution ";cin>>a;s=s+a;
cout<<"Tapez la valeur numero 3 :
";cin>>a;s=s+a;
#include<iostream> cout<<"Tapez la valeur numero 4 :
using namespace std; ";cin>>a;s=s+a;
int main() cout<<"Tapez la valeur numero 5 :
{ ";cin>>a;s=s+a;
double largeur,longueur,surface,
perimetre; s=s/5.0;
cout<<"La moyenne vaut : "<<s<<endl;
cout << "Tapez la largeur du champ :
"; cin >> largeur; cout << "Appuyez sur une touche pour
cout << "Tapez la longueur du champ : continuer ..." << endl;
"; cin >> longueur; [Link]();
[Link]();
surface = largeur * longueur;
perimetre = 2 * (largeur + longueur); return EXIT_SUCCESS;
}
cout << "La surface vaut : " <<
surface << endl;
cout << "Le perimetre vaut : " << EXERCICE 4
perimetre << endl;
Écrire un programme qui demande à
cout << "Appuyez sur une touche pour l’utilisateur de saisir 2 entiers A et B, qui
continuer." << endl; échange le contenu des variables A et B puis
[Link](); qui affiche A et B.
Solution
Cet exercice a pour but de vérifier les points
techniques suivants : #include <iostream>
#include <limits>
 La notion de variables et leur
int main() {
déclaration.
double prixHT, poids, tauxTva,
 L'utilisation de cin et de cout. totalTTC;
 L'affectation.
 Un "algorithme" rudimentaire : flush( std::cout << "Tapez le prix
échanger le contenu de 2 variables. HT d'un kilo de tomates ");
std::cin >> prixHT;
Voici le fichier source : flush( std::cout << "Combien de
kilos avez-vous achetes ? " );
std::cin >> poids;
#include<iostream> flush( std::cout << "Quel est le
using namespace std; taux de TVA ? " );
std::cin >> tauxTva;
int main()
{ totalTTC = (1. + tauxTva/100.) *
int a,b,temp; prixHT * poids;
std::cout << "Le prix TTC est " <<
cout<<"Tapez la valeur de a : totalTTC << std::endl;
";cin>>a;
cout<<"Tapez la valeur de b : std::cout << "Appuyez sur une
";cin>>b; touche pour continuer ..." <<
std::endl;
temp=a; std::[Link](
a=b; std::numeric_limits<std::streamsize>::
b=temp; max(), '\n' );
std::[Link]();
cout<<"La valeur de a est "<<a<<endl;
cout<<"La valeur de b est "<<b<<endl; return EXIT_SUCCESS;
}
cout << "Appuyez sur une touche pour
continuer ..." << endl;
[Link]();
[Link]();

return EXIT_SUCCESS;
}

EXERCICE 5
Écrire un programme qui demande à
l'utilisateur de taper le prix HT d'un kilo de
tomates, le nombre de kilos de tomates
achetés, le taux de TVA (Exemple
10%,20%,...). Le programme affiche alors le
prix TTC des marchandises.
Solution
Cet exercice a pour but de vérifier les points
techniques suivants :

 La notion de variables et leur

déclaration.
 Le choix d'identificateurs pertinents et
explicites.
 L'utilisation de cin et de cout.
 L'affectation.
 Modélisation d'un problème
"économique".
Voici le fichier source :
EXERCICE 1
for (i=8;i<=23;i++) cout << i <<
Écrire un programme qui demande à endl;
l'utilisateur de taper un entier et qui affiche return 0;
GAGNÉ si l'entier est entre 56 et 78 bornes }
incluses PERDU sinon.
Solution EXERCICE 3
Cet exercice a pour but de vérifier les points Même exercice mais en utilisant un while.
techniques suivants :
Solution
 La notion de variables et leur Cet exercice a pour but de vérifier les points
déclaration. techniques suivants :
 L'utilisation de cin et de cout.
 Le choix d'une structure de  Utilisation rudimentaire d'un while.
contrôle adaptée au problème !
Voici le fichier source :
Voici le fichier source :
#include<iostream>
#include <iostream> using namespace std;
#include <cstdlib> int main()
{
using namespace std;
int i=8;
int main() while(i<=23)
{ {
int a; cout<<i<<endl;
cout << "Tapez un entier : "; i++;
cin >> a; }
if ((a>=56)&&(a<=78)) cout <<
"GAGNÉ" << endl; return 0;
else cout << "PERDU" << endl; }
return EXIT_SUCCESS;
}
EXERCICE 4
EXERCICE 2 Écrire un programme qui demande à
l’utilisateur de taper 10 entiers et qui affiche
Écrire un programme qui affiche tous les leur somme.
entiers de 8 jusqu’à 23 (bornes incluses) en
Solution
utilisant un for.
Cet exercice a pour but de vérifier les points
Solution
techniques suivants :
Cet exercice a pour but de vérifier les points
techniques suivants :  Utilisation d'un for.
 Étude d'un algorithme usuel :
 Utilisation rudimentaire d'un for. calcul d'une somme.
Voici le fichier source : Voici le fichier source :

#include<iostream> #include<iostream>
using namespace std; using namespace std;

int main() int main()

{ {
int i; int i,s=0,x;
  Modélisation d'un problème simple
for(i=0;i<10;i++) issu des mathématiques.
{
cout<<"Tapez un entier : Voici le fichier source :
";cin>>x;
s=s+x; #include<iostream.h>
} using namespace std;
int main()
cout<<"La somme vaut : "<<s<<endl;
{
return 0; int N;
} double somme = 0;
cout << "Entrer un entier : ";
cin >> N;
EXERCICE 5 if (N>=5) {
Écrire un programme qui demande à for (int i=5; i<=N; i++)
somme += i*i*i;
l’utilisateur de taper 10 entiers et qui affiche
}
le plus petit de ces entiers. cout << "Somme des cubes de
Solution 5^3 a " << N << "^3 = " << somme
<< endl;
Voici le fichier source : [Link]();
[Link]();
#include<iostream> return EXIT_SUCCESS;
using namespace std; }

int main()
{ EXERCICE 7
Écrire un programme qui demande à
int i,ppt,x; l'utilisateur de taper un entier N et qui
calcule u(N) défini par :
for(i=0;i<10;i++)
{ u(0)=3
cout<<"Tapez un entier : u(n+1)=3*u(n)+4
";cin>>x; Solution
if(i==0)ppt=x;else
if(x<ppt)ppt=x; Cet exercice a pour but de vérifier les points
} techniques suivants :

cout<<"Le plus petit vaut vaut :  Utilisation simple du for.

"<<ppt<<endl;  Étude d'un algorithme usuel :
calcul des termes d'une suite
return 0; récurrente.
}  Modélisation d'un problème issu
des mathématiques.
EXERCICE 6 Voici le fichier source :
Écrire un programme qui demande à
l'utilisateur de taper un entier N et qui #include<iostream>
calcule la somme des cubes de 5^3 à N^3. using namespace std;
int main()
Solution {
Cet exercice a pour but de vérifier les points int i,u=3,N;
techniques suivants :
cout<<"Tapez N : ";cin>>N;
 Utilisation simple du for.
for(i=0;i<N;i++)
 Étude d'un algorithme usuel :
calcul d'une somme.
 tape une valeur erronée, il faut afficher
u=u*3+4; "erreur" et demander de saisir à nouveau
l'entier.
cout<<"u("<<N<<")="<<u<<endl;
Solution
return 0; Cet exercice a pour but de vérifier les points
} techniques suivants :

EXERCICE 8  Utilisation simple du while.

 Validation des données saisies
Écrire un programme qui demande à par l'utilisateur.
l'utilisateur de taper un entier N et qui
calcule u(N) défini par : Voici le fichier source :
u(0)=1
u(1)=1 #include<iostream>
u(n+1)=u(n)+u(n-1) using namespace std;
Solution
int main()
Cet exercice a pour but de vérifier les points {
techniques suivants : int N;
bool ok;
 Utilisation simple du for.
do
 Étude d'un algorithme usuel :
{
calcul d'une suite récurrente. cout << "Tapez N entre 0
 Modélisation d'un problème simple et 20 :";
issu des mathématiques. cin >> N;
Voici le fichier source : ok = N<=20 && N>=0;
if (!ok) cout << "ERREUR
RECOMMENCEZ" << endl;
#include<iostream> }
using namespace std; while(!ok);

int main() N=N+17;

{ cout<<"La valeur finale est :
int i,u=1,v=1,w,N; "<<N<<endl;

cout<<"Tapez N : ";cin>>N; return 0;

}
w=1;
// meilleur solution sans variable
for(i=2;i<=N;i++) ok
{ // ni commande continue à la fin
w=u+v; de la boucle
u=v; #include<iostream>
v=w; using namespace std;
}
int main()
cout<<"u("<<N<<")="<<w<<endl; {
int nn;
return 0;
} while (1)
{
cout<<"Entrer un entier entre
EXERCICE 9 0 et 20 inclusif :";
cin >> nn;
Écrire un programme qui demande à
l’utilisateur de taper un entier N entre 0 et 20
bornes incluses et qui affiche N+17. Si on
 if ((nn>=0) && (nn<=20)) cout<<"x vaut "<<x<<endl;
break; cout<<"1 : Ajouter 1"<<endl;
cout << " erreur\n"; cout<<"2 : Multiplier par
} 2"<<endl;
cout << "\n"; cout<<"3 : Soustraire
4"<<endl;
cout << nn << " + 17 = " << cout<<"4 : Quitter"<<endl;
nn+17 << "\n ^\n"; cout<<"Votre choix :
[Link](); ";cin>>choix;
return 0;
} switch(choix)
{
case 1 : x++;break;
EXERCICE 10 case 2: x=x*2; break;
case 3: x=x-4;break;
Écrire un programme qui permet de faire des }
opérations sur un entier (valeur initiale à 0). }while(choix!=4);
Le programme affiche la valeur de l'entier
puis affiche le menu suivant : cout<<"La valeur finale de x
1. Ajouter 1 vaut : "<<x<<endl;
2. Multiplier par 2
3. Soustraire 4 return 0;
4. Quitter }

Le programme demande alors de taper un EXERCICE 11

entier entre 1 et 4. Si l'utilisateur tape une
valeur entre 1 et 3, on effectue l'opération, Écrire un programme qui demande à
on affiche la nouvelle valeur de l'entier puis l'utilisateur de taper des entiers strictement
on réaffiche le menu et ainsi de suite jusqu'à positifs et qui affiche leur moyenne.
ce qu'on tape 4. Lorsqu'on tape 4, le Lorsqu'on tape une valeur négative, le
programme se termine. programme affiche ERREUR et demande de
retaper une valeur. Lorsqu'on tape 0, cela
Solution signifie que le dernier entier a été tapé. On
Cet exercice a pour but de vérifier les points affiche alors la moyenne. Si le nombre
techniques suivants : d'entiers tapés est égal à 0, on affiche PAS
DE MOYENNE.
 Utilisation du while. Solution
 Utilisation du switch.
Cet exercice a pour but de vérifier les points
 Gestion d'un programme à l'aide techniques suivants :
d'un menu.
 Modélisation d'un problème simple  Utilisation d'un while de difficulté
sous forme informatique. moyenne.
Voici le fichier source :  Étude d'un algorithme usuel :
calcul d'une moyenne.
#include<iostream> Voici le fichier source :
using namespace std;

int main() #include<iostream>

{ using namespace std;
int x=0,choix;
int main()
do {
{ int x, s=0,nb=0;
double moyenne;
 else for(int i=2;i<=N;i++){w=i*v+
do{ (i+1)*u+i;u=v;v=w;}
cout<<"Tapez un
entier :";cin>>x; cout<<"u("<<N<<")="<<w<<endl;
if(x>0){s=s+x;nb++;}
else if(x<0)cout<<"ERREUR return 0;
"; }

}while(x!=0);
EXERCICE 13
if(nb==0)cout<<"AUCUN ENTIER TAPE
"<<endl<<"PAS DE MOYENNE"<<endl; Écrire un programme qui demande de saisir
else { 10 entiers et qui affiche le nombre
moyenne=(double)s/nb; d'occurrences de la note la plus haute.
cout<<"La moyenne vaut : Solution
"<<moyenne<<endl;
} Cet exercice a pour but de vérifier les points
techniques suivants :
return 0;
}  Utilisation d'un for.
 Étude d'un algorithme usuel de
difficulté moyenne : calcul du
EXERCICE 12 nombre d’occurrence d'une valeur.
Écrire un programme qui demande à Voici le fichier source :
l'utilisateur de taper un entier N et qui
calcule u(N) défini par :
u(0)=3 #include<iostream>
u(1)=2 using namespace std;
u(n)=n.u(n-1)+(n+1).u(n-2)+n
int main()
Solution {
int nb,max,x,i;
Cet exercice a pour but de vérifier les points
techniques suivants : for (i=0; i<10; i++)
{
 Utilisation d'un for. cout << "Tapez un entier :
 Étude d'un algorithme usuel : ";
calcul d'une suite récurrente assez cin >> x;
difficile. if(i == 0)
 Modélisation d'un problème issu {
des mathématiques. max = x;
nb = 1;
Voici le fichier source : }
else if (x == max)
#include<iostream> nb++;
else if (max < x)
int main() {
{ max=x;
int N,u,v,w; nb=1;
}
cout<<"Tapez la valeur de N : }
";cin>>N;
u=3; cout<< "le nombre d'occurences de
v=2; "<< max << " est " << nb << endl;
if(N==0)w=u;
else if(N==1)w=v; return 0;
} using namespace std;

int main()
EXERCICE 14 {
int n;
Écrire un programme qui demande de saisir bool premier=true;
un entier N et qui affiche N!. int d=2;
Solution
cout<<"Veuillez saisir un entier :
Cet exercice a pour but de vérifier les points ";cin>>n;
techniques suivants :
if(n<=1)premier=false;
 Utilisation du for. else
 Étude d'un algorithme usuel : {
calcul d'une factorielle. while(premier==true &&
 Modélisation d'un problème issu d*d<=n)
if(n
des mathématiques.
%d==0)premier=false; else d=d+1;
Voici le fichier source : }
if(premier)cout<<n<<" est
premier"<<endl;
#include<iostream> else cout<<n<<" n'est pas
using namespace std; premier"<<endl;
int main() return 0;
{ }
int N,i,f=1;

cout<<"Tapez un entier : ";cin>>N; EXERCICE 16

for(i=2;i<=N;i++)f*=i;
cout<<N<<"! vaut "<<f<<endl; Écrire un programme qui demande à
l'utilisateur de saisir un entier N et qui affiche
return 0; le nombre de nombres premiers inférieurs
} ou égaux à N.
Solution
EXERCICE 15 Cet exercice a pour but de vérifier les points
Écrire un programme qui demande de saisir techniques suivants :
un entier et qui indique si cet entier est
premier ou non.  Utilisation des
boucles for et while.
Solution
 Imbrication de boucles.
Cet exercice a pour but de vérifier les points  Lire précisément un énoncé.
techniques suivants :
 Modélisation assez complexe d'un
problème issu des
 Utilisation d'une boucle while de mathématiques.
difficulté moyenne.
Voici le fichier source :
 Étude d'un algorithme usuel assez
difficile : primarité d'un entier.
 Modélisation d'un problème issu #include<iostream>
des mathématiques. using namespace std;
Voici le fichier source : int main()
{
#include<iostream> int N,i,nb=0,d;
bool est_premier;
 cout<<"Tapez la valeur de N :
cout<<"Tapez la valeur de N : ";cin>>N;
";cin>>N;
while(nb<N)
for(i=2;i<=N;i++) {
{ i++;
/* ecrire un programme qui est_premier=true;
teste si i est premier*/ d=2;
est_premier=true; while(est_premier &&
d=2; d*d<=i)
while(est_premier && if(i
d*d<=i) %d==0)est_premier=false; else d++;
if(i
%d==0)est_premier=false; else d++; if(est_premier==true)nb++;
}
if(est_premier==true)nb++;
} cout<<"Le N-ième nombre premier
est "<<i<<endl;
cout<<"Le nombre de nombre
premiers inférieurs ou égaux à " return 0;
<<N<<" est "<<nb<<endl; }

return 0;
} EXERCICE 18
Écrire un programme qui demande à
EXERCICE 17 l'utilisateur de saisir un entier N et qui affiche
la figure suivante.
Écrire un programme qui demande à
l'utilisateur de saisir un entier N et qui affiche
le N-ième nombre premier. N=1
*
Solution N=2
**
Cet exercice a pour but de vérifier les points
*
techniques suivants :
N=3
***
 Utilisation des **
boucles for et while. *
 Imbrication de boucles assez
complexe.
et ainsi de suite
 Lire précisément un énoncé.
 Modélisation assez complexe d'un Solution
problème issu des Cet exercice a pour but de vérifier les points
mathématiques. techniques suivants :
Voici le fichier source :
 Utilisation des boucles for.
#include<iostream>  Imbrication de boucles assez
using namespace std; complexe.
Voici le fichier source :
int main()
{
int N,i=2,nb=0,d; #include <iostream>
bool est_premier;
using namespace std;
int main()
{ int main()
int N=0; {
cout<<"Saisissez une valeur int i,j,N;
pour N: ";
cin>>N; cout<<"Tapez la valeur de N :
cout<<endl<<endl; ";cin>>N;
cout<<"N= "<<N<<endl;
for(int i=0;i<N;i++) for(i=1;i<=N;i++)
{ {
for(j=1;j<i;j++)cout<<" ";
for(int j=0;j<(N-i);j+ for(j=1;j<=N+1-i;j+
+) +)cout<<"*";
{ cout<<endl;
cout<<"*"; }
} return 0;
cout<<endl; }
}
cout << "Appuyez sur une
touche pour continuer ..." << EXERCICE 20
endl;
[Link](); On considère la suite hongroise : u(0)=a (a
[Link](); entier)
return 0; si u(n) pair alors u(n+1)=u(n)/2 sinon
} u(n+1)=3*u(n)+1
Pour toutes les valeurs a, il existe un entier
N tel que u(N)=1 (conjecture admise).
EXERCICE 19
a) Écrire un programme qui demande à
Écrire un programme qui demande à
l'utilisateur de taper a et qui affiche toutes
l'utilisateur de saisir un entier N et qui affiche
les valeurs de u(n) de n=1 à n=N.
la figure suivante.
Solution
N=1 Cet exercice a pour but de vérifier les points
* techniques suivants :
N=2
**  Utilisation du while.
*
 Lire précisément un énoncé.
N=3
***  Modélisation assez complexe d'un
** problème issu des
* mathématiques.
Voici le fichier source :
et ainsi de suite
#include<iostream>
Solution
using namespace std;
Cet exercice a pour but de vérifier les points
techniques suivants : int main()
{
 Utilisation des boucles for. int a,n,u;
cout<<"Tapez la valeur de a :
 Imbrication de boucles. ";cin>>a;
 Voici le fichier source : n=0;
u=a;
#include<iostream>
using namespace std; while(u!=1)
 { cout<<"La valeur de A
if(u%2==0)u=u/2; else est :"<<amax<<endl;
u=3*u+1; cout<<"La valeur de N
n++; correspondante est :"<<nmax<<endl;

cout<<"u("<<n<<")="<<u<<endl; return 0;
} }
return 0;
}

b) Écrire un programme qui demande à

l'utilisateur de taper un entier M puis qui
cherche la valeur de a comprise entre 2 et M
qui maximise la valeur de N. On appelle A
cette valeur. La programme doit afficher la
valeur A et la valeur N correspondante. EXERCICE 1
Solution Écrire un programme qui demande à
Cet exercice a pour but de vérifier les points l'utilisateur de saisir 10 entiers stockés dans
techniques suivants : un tableau. Le programme doit afficher le
nombre d'entiers supérieurs ou égaux à 10.
 Utilisation des Solution
boucles while et for.
Cet exercice a pour but de vérifier les points
 Imbrication de boucles. techniques suivants :
 Lire précisément un énoncé.
 Modélisation assez complexe d'un  Utilisation simple de tableaux.
problème issu des  Un algorithme simple sur un
mathématiques. tableau : recherche du nombre
Voici le fichier source : d'éléments vérifiant une propriété.
Voici le fichier source :
#include<iostream>
using namespace std;
#include<iostream>
#include<vector>
int main()
using namespace std;
{
int a,n,u,M,amax,nmax;
int main()
cout<<"Tapez la valeur de M :
{
";cin>>M;
vector<int> tab;
amax=2;
int N;
nmax=2;
for (int i=0; i<10; i++)
for(a=3;a<=M;a++)
{
{
cout << "Tapez un
n=0;
nombre : ";cin >> N;
u=a;
tab.push_back(N);
while(u!=1)
}
{
if(u%2==0)u=u/2; else
N = 0;
u=3*u+1;
for (int i=0; i<10; i++)
n++;
{
}
if (tab[i] >=10) N+
if(n>nmax){amax=a;nmax=n;}
+;
}
}
 if (N==0) cout << "Il n'y a if (tab[i] == V) j+
aucun nombre supérieur ou égal à +;
10." << endl; }
else if (N==1) cout << "Il
y a 1 nombre supérieur ou égal à if(j>0) cout << V << " se
10." << endl; trouve dans le tableau" << endl;
else cout << "Il y a " << N else cout << V << " ne se
<< " nombres supérieurs ou égaux à trouve pas dans le tableau" <<
10." << endl; endl;
return 0; return 0;
} }

EXERCICE 2 EXERCICE 3
Écrire un programme qui demande à Écrire un programme qui demande à
l'utilisateur de saisir 10 entiers stockés dans l'utilisateur de saisir 10 entiers stockés dans
un tableau ainsi qu'un entier V. Le un tableau. Le programme doit ensuite
programme doit rechercher si V se trouve afficher l'indice du plus grand élément.
dans le tableau et afficher "V se trouve dans
Solution
le tableau" ou "V ne se trouve pas dans le
tableau". Cet exercice a pour but de vérifier les points
techniques suivants :
Solution
Cet exercice a pour but de vérifier les points  Utilisation simple de tableaux.
techniques suivants :  Un algorithme simple sur un
tableau : recherche de l'indice du
 Utilisation simple de tableaux. plus grand élément.
 Un algorithme simple sur un Voici le fichier source :
tableau : recherche d'un élément
dans un tableau.
#include<iostream>
Voici le fichier source : using namespace std;

#include<iostream> const int N=10;

#include<vector> int main()
using namespace std; {
const int N = 10;
int main() int tab[N], pge=0, i=0, j;
{
vector<int> tab;
int N, V, j; for (i; i < N; i++)
{
for (int i=0; i<10; i++) cout << "Saisir le
{ nombre " << i+1 << " : ";
cout << "Tapez un cin >> tab[i];
nombre : "; cin >> N; if (i==0 || tab[i]
tab.push_back(N); > pge)
} {
pge =
cout << "choisissez la tab[i];
valeur de V : "; cin >> V; j=i;
}
for (int i=0; i<10; i++) }
{
 cout << "la plus grande cout << "- Nombre
valeur du tableau est " << pge<<" " << i+1 << " = " << tab[i] <<
et son indice est " << j; endl;
return 0; }
} return 0;
}

EXERCICE 4
EXERCICE 5
Écrire un programme qui demande à
l'utilisateur de saisir 10 entiers stockés dans Écrire un programme qui demande à
un tableau ainsi qu'un entier V. Le l'utilisateur de saisir 10 entiers stockés dans
programme doit rechercher si V se trouve un tableau ainsi qu'un entier V et un entier i
dans le tableau et doit supprimer la valeur compris entre 0 et 9. Le programme doit
de V et doit afficher le tableau final. décaler d'une case vers la droite tous les
éléments à partir de l'indice i (en supprimant
Solution
le dernier élément du tableau) et doit mettre
Cet exercice a pour but de vérifier les points la valeur V dans le tableau à l'indice i. Le
techniques suivants : programme doit ensuite afficher le tableau
final.
 Utilisation simple de tableaux. Solution
 Un algorithme simple sur un
tableau : suppression d'un
 Cet exercice a pour but de vérifier
élément avec décalage des
les points techniques suivants :
suivants.
o Utilisation simple de
Voici le fichier source : tableaux.
o Un algorithme simple
#include<iostream> sur un tableau :
using namespace std; insertion dans en
tableau avec
int main() décalage.
{  Voici le fichier source :
int tab[10], r = 0;
for (int i=0 ; i<10 ; i++) #include<iostream>
{ using namespace std;
cout << "Saisir le
nombre " << i+1 << ": "; const int N=10;
cin >> tab[i];
} int main()
{
cout << "Choisissez la int t[N],i,indice,V;
valeur à supprimer : "; cin >> V;
for(i=0;i<N;i++){cout<<"Tapez un
for (int i=0 ; i<10 ; i++) entier ";cin>>t[i];}
{ cout<<"Tapez un indice (de 0 à
if (r==0 && tab[i] 9) : ";cin>>indice;
== V) r=1; cout<<"Tapez la valeur de V :
else tab[i-1] = ";cin>>V;
tab[i];
} if(indice>=0 && indice<=N-1)
for (int i=0 ; i<10-r ; i+ {
+) // 9 nombre si V supprimé, 10 for(i=N-
sinon. 1;i>indice;i--)t[i]=t[i-1];
{ t[indice]=V;
}
 if(croissant && decroissant)
for(i=0;i<N;i++)cout<<t[i]<<endl; cout<<"le tableau est
constant"<<endl;
return 0; if(croissant && !decroissant)
} cout<<"le tableau est
croissant"<<endl;
if(!croissant && decroissant)
EXERCICE 6 cout<<"le tableau est
decroissant"<<endl;
Écrire un programme qui demande à if(!croissant && !decroissant)
l’utilisateur de taper 10 entiers qui seront cout<<"le tableau est
stockés dans un tableau. Le programme doit quelconque"<<endl;
ensuite afficher soit "le tableau est
croissant", soit "le tableau est décroissant", return 0;
soit "le tableau est constant", soit "le tableau }
est quelconque".
Solution Solution 2:

 Cet exercice a pour but de vérifier

// Par Ismail Zouaoui
les points techniques suivants :
#include <iostream>
o Utilisation simple de
tableaux. using namespace std;
o Un algorithme simple
sur un tableau : int const SIZE = 10;
vérifier si le tableau
vérifie une propriété int main()
donnée. {
 Voici le fichier source :
int table[SIZE];
#include<iostream> bool ordre = true;
using namespace std;
cout << "Entre 10 entiers: ";
const int N=10;
for(int i=0; i < SIZE; i++)
int main() {
{ cin >> table[i];
int a[N],i; }

bool if(table[0] < table[SIZE-1])

croissant=true,decroissant=true; {
for(int i=0; i<SIZE-1; i+
for(i=0;i<N;i++) +)
{ {
cout<<"Veuillez taper if(table[i] >
l'entier numero "<<i<<" : table[i+1])
";cin>>a[i]; {
} cout << "le
for(i=0;i<N-1;i++) tableau est quelconque.\n";
{ ordre = false;
break;
if(a[i]>a[i+1])croissant=false; }
}
if(a[i]<a[i+1])decroissant=false; if(ordre == true)
} {
 On cherche l'indice du plus petit élément
cout << "le tableau parmi les indices de 0 à 9 et on échange cet
est croissant.\n"; élément avec t[0].
} On cherche l'indice du plus petit élément
} parmi les indices de 1 à 9 et on échange cet
else if(table[0] > table[SIZE- élément avec t[1].
1]) On cherche l'indice du plus petit élément
{
parmi les indices de 2 à 9 et on échange cet
for(int i=0; i<SIZE-1; i+
élément avec t[2].
+)
{ ... On cherche l'indice du plus petit élément
if(table[i] < parmi les indices de 8 à 9 et on échange cet
table[i+1]) élément avec t[8].
{ Solution
cout << "le
tableau est quelconque.\n";
ordre = false;  Cet exercice a pour but de vérifier
break; les points techniques suivants :
} o Utilisation simple de
} tableaux.
if(ordre == true) o Un algorithme simple
{ sur un tableau : tri
cout << "le tableau d'un tableau.
est décroissant.\n";  Voici le fichier source :
}
} #include<iostream>
else if(table[0] == using namespace std;
table[SIZE-1])
{ const int N=10;
for(int i=0; i<SIZE-1; i+
+) int main()
{ {
if(table[i] != int a[N],i,j,min,imin,tmp;
table[i+1])
{ for(i=0;i<N;i++)
cout << "le {
tableau est quelconque.\n"; cout<<"Veuillez taper l'entier
ordre = false; numéro "<<i<<" : ";cin>>a[i];
break; }
}
} for(i=0;i<N-1;i++)
if(ordre == true) {
{ imin=i;min=a[i];
cout << "le tableau for(j=i+1;j<<N;j++)if(a[j]<min)
est constant.\n"; {min=a[j];imin=j;}
}
}
tmp=a[imin];a[imin]=a[i];a[i]=tmp;
return 0; }
} cout<<"VOICI LE TABLEAU
TRIE :"<<endl;
for(i=0;i<N;i+
EXERCICE 7 +)cout<<"a["<<i<<"]="<<a[i]<<endl;
Écrire un programme qui demande à
l’utilisateur de taper 10 entiers qui seront return 0;
stockés dans un tableau. Le programme doit }
trier le tableau par ordre croissant et doit
afficher le tableau. Solution 2
Algorithme suggéré :
  Voici le fichier source : afficher le tableau.
Algorithme suggéré (tri bulle) :
#include <iostream> On parcourt le tableau en comparant t[0] et
t[1] et en échangeant ces éléments s'ils ne
using namespace std; sont pas dans le bon ordre.
on recommence le processus en comparant
int main() t[1] et t[2],... et ainsi de suite jusqu'à t[8] et
{ t[9].
const int taille = 10; On compte lors de ce parcours le nombre
int tableau[taille]; d'échanges effectués.
int tampon;
On fait autant de parcours que nécessaire
for(int i = 0; i < taille; i+
jusqu'à ce que le nombre d'échanges soit
+) // Remplissage du tableau nul : le tableau sera alors trié.
{ Solution
cout << "Quelle valeur a
l'indice " << i << " : ";
 Cet exercice a pour but de vérifier
cin >> tableau[i];
les points techniques suivants :
}
o Utilisation simple de
int j = 0; tableaux.
o Un algorithme simple
while(j < taille) // Boucle sur un tableau : tri
principale d'un tableau.
{  Voici le fichier source :
int indice = j;
#include<iostream>
for(int i = j; i < taille using namespace std;
- 1; i++) // Boucle de recherche
du plus petit élément const int N=10;
{
if(tableau[indice] > int main()
tableau[i + 1]) {
indice = i + 1; int a[N],i,nb,tmp;
}
for(i=0;i<N;i++)
// On inverse les éléments {cout<<"Veuillez taper l'entier
tampon = tableau[j]; numero "<<i<<" : ";cin>>a[i];}
tableau[j] =
tableau[indice]; do
tableau[indice] = tampon; {
nb=0;
j++; for(i=0;i<N-1;i++)
} if(a[i]>a[i+1])
{
// On affiche le tableau trié
for(int i = 0; i < taille; i+
+) tmp=a[i];a[i]=a[i+1];a[i+1]=tmp;
cout << "Indice " << i << nb++;
" : " << tableau[i] << endl; }
}while(nb!=0);
return 0;
} cout<<"VOICI LE TABLEAU
TRIE :"<<endl;
for(i=0;i<N;i+
EXERCICE 8 +)cout<<"a["<<i<<"]="<<a[i]<<endl;
Écrire un programme qui demande à
l’utilisateur de taper 10 entiers qui seront return 0;
stockés dans un tableau. Le programme doit
trier le tableau par ordre croissant et doit
 EXERCICE 9
}
Écrire un programme qui saisit 2 tableaux de
Solution 2 10 entiers a et b. c est un tableau de 20
entiers. Le programme doit mettre dans c la
 Voici le fichier source : fusion des tableaux a et b. On copiera dans
les 10 premières cases de c le tableau a,
#include <iostream> dans les dix dernières le tableau b. Le
programme affiche ensuite le tableau c.
using namespace std; Solution
int main()
{  Cet exercice a pour but de vérifier
const int taille = 10; les points techniques suivants :
int tableau[taille]; o Utilisation simple de
int tampon; tableaux.
o Un algorithme simple
for(int i = 0; i < taille; i+ sur un tableau : fusion
+) // Remplissage du tableau de 2 tableaux.
{  Voici le fichier source :
cout << "Quelle valeur a
l'indice " << i << " : "; #include<iostream>
cin >> tableau[i]; using namespace std;
}
const int N=10;
bool trie = false; // Vérifie
si un tri a eu lieu int main()
{
while(!trie) // Si aucun tri int a[N],b[N],c[2*N],i;
n'a eu lieu, la boucle se finit
{ cout<<"SAISIE DU TABLEAU a"<<endl;
trie = true; for(i=0;i<N;i++){cout<<"Tapez un
entier ";cin>>a[i];}
for(int i = 0; i < taille
- 1; i++) cout<<"SAISIE DU TABLEAU b"<<endl;
{ for(i=0;i<N;i++){cout<<"Tapez un
if(tableau[i] > entier ";cin>>b[i];}
tableau[i + 1])
{ for(i=0;i<2*N;i+
tampon = +)if(i<N)c[i]=a[i];else c[i]=b[i-
tableau[i]; N];
tableau[i] =
tableau[i + 1]; cout<<"VOICI LE TABLEAU c"<<endl;
tableau[i + 1] = for(i=0;i<2*N;i++)cout<<c[i]<<" ";
tampon; cout<<endl;
trie = false; return 0;
} }
}
}
Pour prévoir un usage futur, avec des tableaux
for(int i = 0; i < taille; i+ de longueur différente, solution 2 :
+) // Affiche le tableau trié
cout << "Indice " << i <<
" : " << tableau[i] << endl; #include<iostream>
using namespace std;
return 0;
} const int Na=10;
const int Nb=10; for(i=0;i<N;i++){cout<<"Tapez un
entier ";cin>>b[i];}
int main()
{ trie=true;
int a[Na],b[Nb],c[Na + Nb],i; i=0;
while(trie && i<N-
cout<<"SAISIE DU TABLEAU a"<<endl; 1)if(a[i]>a[i+1])trie=false; else
for(i=0;i<Na;i++){cout<<"Tapez un i++;
entier ";cin>>a[i];}
if(!trie)cout<<"Le tableau a n'est
cout<<"SAISIE DU TABLEAU b"<<endl; pas trié"<<endl;
for(i=0;i<Nb;i++){cout<<"Tapez un else
entier ";cin>>b[i];} {
trie=true;
for(i=0;i<Na + Nb;i+ i=0;
+)if(i<Na)c[i]=a[i];else c[i]=b[i- while(trie && i<N-
Na]; 1)if(b[i]>b[i+1])trie=false; else
i++;
cout<<"VOICI LE TABLEAU c"<<endl;
for(i=0;i<Na + Nb;i+ if(!trie)cout<<"Le tableau
+)cout<<c[i]<<" "; b n'est pas trié"<<endl;
cout<<endl; else
return 0; {
}
indicea=0;indiceb=0;
for(i=0;i<2*N;i++)
EXERCICE 10 {
Écrire un programme qui saisit 2 tableaux de
if(indicea==N)
10 entiers a et b qui doivent être triés dans
{c[i]=b[indiceb];indiceb++;}
l'ordre croissant. Le programme devra tout
else
d'abord vérifier que les deux tableaux sont if(indiceb==N)
triés. Le tableau c est un tableau de 20 {c[i]=a[indicea];indicea++;}
entiers. Le programme doit mettre dans c la else
fusion des tableaux a et b. Le tableau c if(a[indicea]<b[indiceb])
devra contenir les éléments de a et ceux de {c[i]=a[indicea];indicea++;}
b et devra être trié. Le programme affiche else
ensuite le tableau c. {c[i]=b[indiceb];indiceb++;}
}
Solution
}
}
#include<iostream>
using namespace std; cout<<"VOICI LE TABLEAU c"<<endl;
for(i=0;i<2*N;i++)cout<<c[i]<<" ";
const int N=10; cout<<endl;
int main() return 0;
{ }
int
a[N],b[N],c[2*N],i,trie,indicea,in
diceb; EXERCICE 11
cout<<"SAISIE DU TABLEAU a"<<endl; Écrire un programme qui gère une liste
for(i=0;i<N;i++){cout<<"Tapez un d'entiers grâce au menu suivant :
entier ";cin>>a[i];} 1. Ajouter un entier
2. Afficher la liste des entiers
cout<<"SAISIE DU TABLEAU b"<<endl; 3. Supprimer dernier entier de la liste.
4. Afficher la dernière note tapée
5. Quitter
Il y aura au maximum 10 entiers. Lorsqu'on
rajoute un entier, il sera rajouté à la fin de la
liste. for(i=0;i<nb;i+
+)cout<<t[i]<<" ";
Solution
cout<<endl;
 Cet exercice a pour but de vérifier
les points techniques suivants : }
o Utilisation simple de break;
tableaux.
o Gestion d'une liste case 3 : if(nb>0)
{nb--; cout<<"ENTIER
simple grâce à un
SUPPRIME"<<endl;}
tableau statique.
 Voici le fichier source : else cout<<"LA LISTE EST
VIDE"<<endl;
#include<iostream> break;
using namespace std;
case 4 :
const int N=10; if(nb>0)cout<<"lLE DERNIER ENTIER
int main() EST "<<t[nb-1]<<endl;
{
else cout<<"LA LISTE EST
int t[N],nb=0,choix,e,i; VIDE"<<endl;
bool fini=false; break;

while(fini==false) case 5 : fini=true;

{ break;
cout<<"1. Ajouter un }
entier"<<endl;
cout<<"2. Afficher la liste }
des entier"<<endl; return 0;
cout<<"3. Supprimer le }
dernièr entier de la liste"<<endl;
cout<<"4. Afficher le
dernier entier de la liste"<<endl; EXERCICE 12
cout<<"5. Quitter"<<endl;
cout<<"Votre choix : Écrire un programme qui gère une liste
";cin>>choix; d'entiers grâce au menu suivant :
switch(choix) 1. Ajouter un entier
{ 2. Afficher la liste des entiers
case 1 : 3. Supprimer le premier entier ayant une
cout<<"Tapez un entier : ";cin>>e; valeur donnée.
4. Supprimer tous les entiers ayant une
if(nb<N){t[nb]=e; nb++; valeur donnée
cout<<"ENTIER AJOUTE"<<endl;} 5. Quitter
else Il y aura au maximum 10 entiers. La liste
cout<<"IMPOSSIBLE LE TABLEAU EST devra être en permanence triée : lorqu'on
PLEIN"<<endl;
rajoute un entier, il sera inséré au bon
break;
endroit dans la liste pour que celle-ci reste
case 2 : triée.
if(nb==0)cout<<"LA LISTE EST Solution
VIDE"<<endl;
 Cet exercice a pour but de vérifier
else {
les points techniques suivants :
cout<<"VOICI LA o Utilisation simple de
LISTE"<<endl; tableaux.
 o Gestion d'une liste
triée grâce à un case 2 :
tableau statique. if(nb==0)cout<<"LA LISTE EST
 Voici le fichier source : VIDE"<<endl;

#include<iostream> else {
using namespace std;
cout<<"VOICI LA
const int N=10; LISTE"<<endl;
int main()
{ for(i=0;i<nb;i+
+)cout<<t[i]<<" ";
int
t[N],nb=0,choix,e,V,i,j,trouve; cout<<endl;
bool fini=false;
}
while(fini==false) break;
{
cout<<"1. Ajouter un case 3 :
entier"<<endl; cout<<"Tapez la valeur à
cout<<"2. Afficher la liste supprimer :";cin>>V;
des entier"<<endl;
cout<<"3. Supprimer le trouve=false;
premier entier ayant une valeur
donnée"<<endl; i=0;
cout<<"4. Supprimer tous
les entiers ayant une valeur while(!trouve &&
donnée"<<endl; i<nb)if(t[i]==V)trouve=true; else
cout<<"5. Quitter"<<endl; i++;
cout<<"Votre choix :
";cin>>choix; if(trouve)
switch(choix)
{ {
case 1 : if(nb<N)
for(j=i;j<nb-1;j+
{ +)t[j]=t[j+1];

cout<<"Tapez un entier : nb--;

";cin>>e;
}
i=0; break;

while(i!=nb && t[i]<e)i++; case 4 :

cout<<"Tapez la valeur à
for(j=nb;j>i;j--)t[j]=t[j- supprimer :";cin>>V;
1];
j=0;
t[i]=e;
for(i=0;i<nb;i++)
nb++;
if(t[i]!=V){t[j]=t[i];j+
} +;}
else
cout<<"IMPOSSIBLE LE TABLEAU EST nb=j;
PLEIN"<<endl; break;
break;
case 5 : fini=true;
break;
}
 cout << endl;
}
return 0; return 0;
} }

EXERCICE 13 EXERCICE 14
Écrire un programme qui demande à Écrire un programme qui demande à
l'utilisateur de taper un entier N<=20 et qui l'utilisateur de taper 10 entiers compris entre
affiche la N-ième ligne du triangle de pascal. 0 et 20 qui seront stockés dans un tableau et
ligne 1 : 1 1 qui affiche le nombre de fois qu'on a tapé un
ligne 2 : 1 2 1 0, le nombre de 1, le nombre de 2, ..., le
ligne 3 : 1 3 3 1 nombre de 20.
ligne 4 : 1 4 6 4 1
Solution
et ainsi de suite ...
Solution #include<iostream>
using namespace std;
Cet exercice a pour but de vérifier les points
techniques suivants : int main()
{
 Utilisation simple de tableaux. int a[10], nb[21], i;
 Itération des éléments d'un
tableau. for(i=0 ; i<10;i++)
{
Voici le fichier source : do { cout <<
"Veuillez taper l'entier numéro "
#include<iostream> << i << " : "; cin >> a[i]; }
using namespace std; while (a[i]>20 ||
a[i]<0);
int main() }
{
int a[21],i,j,N; for(i=0 ; i<21 ; i++) nb[i]
= 0;
cout << "Veuillez taper N : for(i=0 ; i<10 ; i++)
"; cin >> N; nb[a[i]]++;
if (N<0 || N>20)
{ for(i=0 ; i<21 ; i++) {
cerr << "Nombre cout << "Il y a " << nb[i] << "
invalide." << endl; fois l'entier " << i << endl; }
return 1; return 0;
} }

a[0]=1;
EXERCICE 15
for(i=1 ; i<=N ; i++) Écrire un programme qui demande à
{ l'utilisateur de taper le contenu d'un tableau
a[i]=1; de réels de 3 lignes et 3 colonnes et qui
for(j=i-1 ; j>=1 ;
affiche ce tableau mais en affichant la
j--)
a[j] = a[j] moyenne des éléments de chaque ligne, de
+ a[j-1]; chaque colonne et la moyenne globale.
} Solution

for(i=0;i<=N;i++) cout << Cet exercice a pour but de vérifier les points
a[i] << " "; techniques suivants :
  Utilisation de tableaux à 2
dimensions.
 Modélisation d'un problème // Affichage
mathématique basique. for(i=0 ; i<N ; i++)
{
Voici le fichier source : for(j=0 ; j<M ; j+
+)
#include<iostream> cout <<
using namespace std; t[i][j] << " ";
cout << " -->
// Taille du tableau Moyenne de la ligne = " << moyL[i]
const int N=3; <<endl;
const int M=3; }
for(j=0 ; j<M ; j++)
int main() cout << moyC[j] <<
{ " ";
double t[N] cout << " <-- Moyenne des
[M],moyL[N],moyC[M],moy; colonnes " << endl;
int i,j;
cout << "Moyenne totale = "
for(i=0 ; i<N ; i++) << moy << endl;
for(j=0 ; j<M ; j+ return 0;
+) }
{
cout <<
"Tapez la valeur de la ligne " <<
i << " colonne " << j << " : ";
cin >> t[i]
[j];
}

// Initialisation
for(i=0 ; i<N ; i++) Exercice 1[modifier | modifier le
moyL[i]=0; wikicode]
for(j=0 ; j<M ; j++)
moyC[j]=0; Écrire une fonction qui a en paramètres une
moy = 0; chaîne de caractères (paramètre en entrée)
et un entier e (paramètre en sortie). Cette
// Ajout des valeurs fonction renvoie un booléen. La fonction
for(i=0 ; i<N ; i++) renvoie true si la chaîne de caractères est
for(j=0 ; j<M ; j+ un entier écrit sous la forme d'une suite de
+) chiffres qui ne commence pas par 0, elle
{ renvoie false sinon. Si la chaîne est correcte,
moyL[i] = la fonction renvoie dans e la valeur de cet
moyL[i] + t[i][j]; entier.
moyC[j] =
moyC[j] + t[i][j]; Solution
moy = moy + Cet exercice a pour but de vérifier les points
t[i][j]; techniques suivants :
}

// Division par le nombre  La manipulation de chaînes de

de valeurs caractères ;
for(i=0 ; i<N ; i++)  la validation d'une chaîne de
moyL[i] /= M; caractères ;
for(j=0 ; j<M ; j++)  transformation d'une chaîne vers
moyC[j] /= N; un autre type.
moy /= (N*M);
Voici le fichier source :
  La manipulation de chaînes de
#include <iostream> caractères ;
 transformation d'une chaîne de
bool valide_entier(char chaine[], caractères ;
int &refNombreEntier) {  majuscules et minuscules.
bool valide = true; Voici le fichier source :
refNombreEntier = 0;
#include <iostream>
valide = !(chaine[0] < '1' ||
chaine[0] > '9');
void minusculesVersMajuscules(char
chaine[]) {
int compteur = 0;
int compteur = 0;
while (valide &&
chaine[compteur]!='\0') {
if (chaine[compteur] >= // Le caractère de la
'0' && chaine[compteur] <= '9') { chaîne n’est pas le marqueur
refNombreEntier = 10 * terminal
refNombreEntier + while(chaine[compteur] !=
(chaine[compteur] - '0'); '\0') {
compteur++;
} else { // Le caractères
valide = false; est une minuscule
} if(chaine[compteur]
} >= 'a' && chaine[compteur] <= 'z')
return valide; {
}
chaine[compteur] =
int main() { chaine[compteur] + ('A'-'a');
}
int nombreEntier; compteur++; // Pour
char chaine[20]; accéder au caractère suivant
}
do { }
std::cout << "Tapez une
chaîne de caractères : "; int main() {
std::cin >> chaine;
} while (! char chaine[255];
valide_entier(chaine,
nombreEntier)); std::cout << "Tapez une
chaîne de caractères à transposer
std::cout << "L'entier vaut : en majuscules : ";
" << nombreEntier << std::endl; std::cin >> chaine;
return EXIT_SUCCESS;
} std::cout << chaine;

Exercice 2[modifier | modifier le minusculesVersMajuscules(chaine);

wikicode]
Écrire une fonction qui a en paramètre une std::cout << "La même
chaîne de caractères (paramètre en entrée chaîne en majuscules est : " <<
et en sortie) et qui transforme toutes les chaine << std::endl;
minuscules de la chaîne en majuscules. return EXIT_SUCCESS;
}
Solution
Cet exercice a pour but de vérifier les points
techniques suivants :
Exercice 3[modifier | modifier le
wikicode]
Écrire une fonction qui a en paramètre une Exercice 4[modifier | modifier le
chaîne de caractères (paramètre en entrée
wikicode]
et en sortie) et qui supprime toutes les
voyelles. Écrire une fonction qui a en paramètres
deux chaînes de caractères ch1 et ch2
Solution
(paramètres en entrée) et renvoie un
booléen indiquant si la chaîne ch2 est
 y est une voyelle dans ce contenue dans la chaîne ch1.
programme ;
 la phrase peut contenir des Solution
espaces mais doit avoir moins de Cet exercice a pour but de vérifier les points
80 caractères incluant le '\0' ; techniques suivants :
 Si une voyelle à un accent, elle
sera traité comme une consonne  La manipulation de chaînes de
(tout comme une voyelle caractères ;
majuscule) ;
 recherche d'une chaîne incluse
 La voyelle est remplacée par un . dans une autre chaîne.
pour afficher la suppression de la
voyelle. Voici le fichier source :

#include <iostream> bool

chainePrincipaleContientSecondaire
void remplaceVoyelle(char (char chainePrincipale[],
chaine[]) {
char chaineSecondaire[]) {
int compteur = 0;
while(chaine[compteur] != '\
int ii, i, j = 0;
0') {
bool estFini, estTrouve =
if((chaine[compteur] ==
false;
'a') || (chaine[compteur] == 'e')
|| (chaine[compteur] == 'i') ||
while (!estTrouve &&
(chaine[compteur] ==
chainePrincipale[ii] != '\0') {
'o') || (chaine[compteur] == 'u')
if(chainePrincipale[ii] ==
|| (chaine[compteur] == 'y')) {
chaineSecondaire[j]){
chaine[compteur] =
ii++;
'.';
j++;
}
if
compteur++;
(chaineSecondaire[j] == '\0') {
}
estTrouve = true;
}
}
} else {
i++;
ii = i;
int main() {
j = 0;
}
char chaine[255];
}
return estTrouve;
std::cout << "Tapez une chaîne
}
de caractères : ";
std::cin >> chaine;
int main() {
char chainePrincipale[255],
remplaceVoyelle(chaine);
chaineSecondaire[255];
std::cout << "Voici la phrase
std::cout << "Tapez une chaîne
avec la modification : "<< chaine
de caractères principale : ";
<< std::endl;
std::cin >> chainePrincipale;
return EXIT_SUCCESS;
}
 std::cout << "Tapez une chaîne std::cout << "Le verbe
de caractères secondaire : "; n'est pas du premier groupe." <<
std::cin >> chaineSecondaire; std::endl;
} else {
chaine[longueurChaine-2] =
if(chainePrincipaleContientSeconda '\0';
ire(chainePrincipale, std::cout << "Je " <<
chaineSecondaire)) { chaine << "e" << std::endl;
std::cout << "La chaine std::cout << "Tu " <<
principale contient la chaine chaine << "es" << std::endl;
secondaire." << std::endl; std::cout << "Il " <<
} else { chaine << "e" << std::endl;
std::cout << "La chaine std::cout << "Nous " <<
principale ne contient pas la chaine << "ons" << std::endl;
chaine secondaire." << std::endl; std::cout << "Vous "<<
} chaine << "ez" << std::endl;
return EXIT_SUCCESS; std::cout << "Ils " <<
} chaine << "ent" << std::endl;
}
return EXIT_SUCCESS;
Exercice 5[modifier | modifier le }
wikicode]
Écrire un programme qui demande à Exercice 6[modifier | modifier le
l’utilisateur de taper un verbe du premier wikicode]
groupe et qui le conjugue à l'indicatif
présent. Écrire un programme qui saisit une chaîne
pouvant contenir des espaces et qui affiche
Solution chaque mot de la chaîne, le séparateur étant
Cet exercice a pour but de vérifier les points l’espace.
techniques suivants : Exemple, on tape : je pense donc je suis
Le programme affiche :
 La manipulation de chaînes de mot 1 : je
caractères ; mot 2 : pense
 la construction d'une chaîne à mot 3 : donc
partir d'une autre. mot 4 : je
mot 5 : suis
Voici le fichier source :
Solution
#include <iostream> Cet exercice a pour but de vérifier les points
#include <cstring> techniques suivants :

int main() {  La manipulation de chaînes de

caractères ;
char chaine[255];  analyse syntaxique d'une chaîne
std::cout << "Tapez un verbe de caractères.
du premier groupe : ";
std::cin >> chaine; Voici le fichier source :

int longueurChaine =
#include <iostream>
strlen(chaine);
if (longueurChaine <= 2 ||
chaine[longueurChaine-1] !
int main() {
= 'r' || chaine[longueurChaine-2]
!= 'e') {
char phrase[50];
char mot[50];
  validation d'une chaîne.

int i, j, indiceDuMot = 0; Voici le fichier source :

int state = 1;
#include <iostream>
std::cout << "Tapez une #include <cstring>
phrase : ";
std::[Link](phrase, 50); int main() {
char chaine[50];
while(phrase[i] != '\0'){ int compteurCroissant = 0;
if (state == 1) {
if (phrase[i]!=' ') { // On part du principe
state = 2; qu’il s’agit d’un palindrome et on
j = 0; va démontrer le contraire
mot[0] = bool
phrase[i]; laChaineEstUnPalindrome = true;
j++;
} std::cout << "Tapez une
} else { chaîne de caractères : "; std::cin
if (phrase[i] != ' ') >> chaine;
{
mot[j] =
int compteurDecroissant =
phrase[i];
strlen(chaine) - 1; // Suppression
j++;
du \0 terminal
} else {
state = 1;
indiceDuMot++; while
mot[j] = '\0'; (laChaineEstUnPalindrome &&
std::cout << compteurCroissant <
"Mot : " << indiceDuMot << " : " compteurDecroissant) {
<< mot << std::endl;
}
} if(chaine[compteurCroissant] !=
i++; chaine[compteurDecroissant]) {
}
if(state == 2) { laChaineEstUnPalindrome =
indiceDuMot++; false;
mot[j]='\0'; } else {
std::cout << "Mot : " <<
indiceDuMot << " : " << mot << compteurCroissant++;
std::endl;
} compteurDecroissant--;
return EXIT_SUCCESS; }
} }

Exercice 7[modifier | modifier le if

wikicode] (laChaineEstUnPalindrome) {
std::cout << "La
Écrire un programme qui demande à chaîne de caractères est un
l’utilisateur de taper une chaîne de palindrome." << std::endl;
caractères et qui indique si cette chaîne est } else {
un palindrome ou non. std::cout << "La
chaîne de caractères n’est pas un
Solution palindrome." << std::endl;
Cet exercice a pour but de vérifier les points }
techniques suivants : return EXIT_SUCCESS;
}
 La manipulation de chaînes de
caractères ;
Éxercice 8[modifier | modifier le
wikicode]
}
Écrire un programme qui demande à
l’utilisateur de taper une chaîne de /* Affichage du nombre
caractères et qui affiche la lettre (minuscule d’occurrences de chaque lettre. On
ou majuscule) la plus fréquente. parcours seulement la moitié
du tableau puisque l’on
Solution va afficher à la fois les
Cet exercice a pour but de vérifier les points minuscules et les majuscules
techniques suivants : */
for(int index = 0; index <
(52 / 2); index++) {
 La manipulation de chaînes de
// Récupération de
caractères ;
la représentation sous forme de
 manipulation sur les majuscules caractère du nombre
ou minuscules ; char minuscule =
Voici le fichier source : (char) index + 'a';
char majuscule =
(char) index + 'A';
#include <iostream> std::cout <<
"Lettre \'" << majuscule << "\' :
int main() { " << poidsDesLettres[index]
<< "\t\tLettre \'"
char chaine[50]; << minuscule << "\' : " <<
int poidsDesLettres[52]; poidsDesLettres[index + 26] <<
std::endl;
std::cout << "Tapez une }
chaîne de caractères : "; std::cin
>> chaine; int nombreMaximal =
poidsDesLettres[0];
// Initialisation des char cmax = 'A';
valeurs du tableau à zéro for(int index = 1; index <
for(int index = 0; index < 52; index++) {
52; index++) {
// Recherche du
poidsDesLettres[index] = 0; maximal
} if (nombreMaximal <
poidsDesLettres[index]) {
int index = 0;
while (chaine[index] != '\ nombreMaximal =
0') { poidsDesLettres[index];

if (chaine[index] //
>= 'A' && chaine[index] <= 'Z') { Réprésentation du maximal sous
forme de caractère
if (index <
poidsDesLettres[chaine[index] - 26) {
'A']++; cmax
} else if = (char)(index + 'A');
(chaine[index] >= 'a' && } else {
chaine[index] <= 'z') { cmax
= (char)(index - 26 + 'a');
}
poidsDesLettres[chaine[index] - }
'a' + 26]++; }
}
index++;
 std::cout << "La lettre la cout<<"Tapez l'ordonnée de B :
plus fréquente est : " << cmax << ";cin>>y2;
std::endl;
return EXIT_SUCCESS; d=distance(x1,y1,x2,y2);
}
cout<<"La distance AB vaut :
"<<d<<endl;
return 0;
}

EXERCICE 2[modifier | modifier le

EXERCICE 1[modifier | modifier le wikicode]
wikicode] Écrire une fonction f ayant comme
paramètres un double x et un booléen ok et
Écrire une fonction distance ayant comme qui renvoie un double par un return. La
paramètres 4 doubles xa,ya et xb,yb qui fonction renvoie par un return la racine
représentent les coordonnées de deux
carrée de (x-1)*(2-x). La fonction renvoie par
points A et B et qui renvoie la distance AB.
l'intermédiaire de la variable ok la
Tester cette fonction.
valeur true si la fonction est définie au point
Solution x, false sinon. Tester cette fonction.
Cet exercice a pour but de vérifier les points Solution
techniques suivants :
Cet exercice a pour but de vérifier les points
techniques suivants :
 Création de fonction simple.
 Passage de paramètres par
 Création de fonction simple.
valeur.
 Passage de paramètres par valeur
 Utilisation de return.
et par référence.
 Appel d'une fonction.
 Utilisation de return.
 Voici le fichier source :
 Paramètres en entrées et en
sorties d'une fonction.
#include<iostream>
 Appel d'une fonction.
using namespace std;
#include<cmath>  Jeu de tests d'une fonction.
Voici le fichier source :
double distance(double xa, double
ya, double xb, double yb)
{ #include<iostream>
double dx,dy; using namespace std;
dx=xa-xb; #include<cmath>
dy=ya-yb;
return sqrt(dx*dx+dy*dy); double f(double x, bool &ok)
} {
double r=0;
int main()
{ if(x>=1 && x<=2){r=sqrt((x-1)*(2-
double x1,y1,x2,y2,d; x));ok=true;}
else ok=false;
cout<<"Tapez l'abscisse de A : return r;
";cin>>x1; }
cout<<"Tapez l'ordonnée de A :
";cin>>y1; int main()
cout<<"Tapez l'abscisse de B : {
";cin>>x2; double x,y;
bool ok; return 0;
cout<<"Tapez x :";cin>>x; }
y=f(x,ok);
if(ok)cout<<"f(x)
vaut :"<<y<<endl; EXERCICE 4[modifier | modifier le
else cout<<"x n'est pas wikicode]
correct"<<endl;
return 0; É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). Tester cette
EXERCICE 3[modifier | modifier le fonction.
wikicode] Solution
Écrire une fonction f ayant en paramètre un Cet exercice a pour but de vérifier les points
entier et qui renvoie par un return un techniques suivants :
booléen : true si l'entier est
premier false sinon. Tester cette fonction.  Création de fonctions simples.
Solution  Appel de fonction.
 Fonction qui appelle une autre
Cet exercice a pour but de vérifier les points
techniques suivants : fonction.
 Voici le fichier source :
 Création de fonction simple.
#include<iostream>
 Appel d'une fonction. using namespace std;
 Validation des données avant
l'appel d'une fonction. bool premier(int x)
 Fonction renvoyant un booléen. {
 Voici le fichier source : bool r=true;
int d=2;
#include<iostream> while(r && d*d<=x)if(x
using namespace std; %d==0)r=false; else d++;
#include<cmath> return r;
}
bool f(int x)
{ int Npremier(int N)
bool r=true; {
int d=2; int nb=0;
while(r && d*d<=x)if(x int i=2;
%d==0)r=false; else d++;
return r; while(nb!=N)
} {
if(premier(i))nb++;
int main() i++;
{ }
int x; return i-1;
bool premier; }
do{
cout<<"Tapez x :";cin>>x; int main()
}while(x<=0); {
premier=f(x); int N,p;
if(premier)cout<<"x est cout<<"Tapez la valeur de N :
premier"<<endl; ";cin>>N;
else cout<<"x n'est pas p=Npremier(N);
premier"<<endl; cout<<"Le N-ième nombre premier
est : "<<p<<endl;
 Cet exercice a pour but de vérifier les points
return 0; techniques suivants :
}
 Écriture d'une fonction ayant
comme paramètre un tableau de
EXERCICE 5[modifier | modifier le taille quelconque.
wikicode]  Recherche d'un élément dans un
Écrire une fonction swap ayant en tableau vérifiant une propriété.
paramètres 2 entiers a et b et qui échange  Utilisation de return.
les contenus de a et de b. Tester cette  Voici le fichier source :
fonction.
Solution #include<iostream>
using namespace std;
Cet exercice a pour but de vérifier les points
techniques suivants : void saisir(int t[],int n)
{
 Création de fonction simple. int i;
for(i=0;i<n;i++)
 Appel d'une fonction.
{
 Passage de paramètres par cout<<"Tapez la valeur numero
références. "<<i<<" : ";
 Voici le fichier source : cin>> t[i];
}
#include<iostream> }
using namespace std;
bool f(int t[], int n)
void swap(int &x, int &y) {
{ bool trouve=false;
int temp; int i=0;
temp=x; while(!trouve && i<n)
x=y; if(t[i]>=0 &&
y=temp; t[i]<=10)trouve=true; else i++;
} return trouve;
}
int main()
{ int main()
int a,b; {
cout<<"Tapez a :";cin>>a; int a[10];
cout<<"Tapez b :";cin>>b; saisir(a,10);
swap(a,b); bool b;
cout<<"a vaut : "<<a<<endl;
cout<<"b vaut : "<<b<<endl; b=f(a,10);
if(b)cout<<"Il existe une valeur
return 0; entre 0 et 10"<<endl;
} else cout<<"Il n'existe pas de
valeurs entre 0 et 10"<<endl;
return 0;
EXERCICE 6[modifier | modifier le }
wikicode]
Écrire une fonction f ayant en paramètres un EXERCICE 7[modifier | modifier le
tableau t de taille quelconque et un entier n wikicode]
indiquant la taille du tableau. f doit renvoyer
par un return un booléen b indiquant s'il Écrire une fonction f ayant en paramètres un
existe une valeur comprise entre 0 et 10 tableau t de taille quelconque et un entier n
dans les n premières cases du tableau t. indiquant la taille du tableau. f doit renvoyer
Tester cette fonction. par un return le nombre de valeurs
comprises entre 0 et 10 dans les n
Solution
premières cases du tableau [Link] cette comprise entre 1 et 10 dans les n premières
fonction. cases du tableau t. Si f renvoie true, v est
Solution égal à la valeur de la première case du
tableau comprise entre 0 et 10. Tester cette
Cet exercice a pour but de vérifier les points fonction.
techniques suivants :
Solution
 Écriture d'une fonction ayant Cet exercice a pour but de vérifier les points
comme paramètre un tableau de techniques suivants :
taille quelconque.
 Compter le nombre d'éléments  Écriture d'une fonction ayant
dans un tableau vérifiant une comme paramètre un tableau de
propriété. taille quelconque.
 Utilisation de return.  Recherche d'un élément dans un
 Voici le fichier source : tableau.
 Utilisation de return.
#include<iostream>  Voici le fichier source :
using namespace std;
#include<iostream>
void saisir(int t[],int n) using namespace std;
{
int i; void saisir(int t[],int n)
for(i=0;i<n;i++) {
{ int i; for(i=0;i<n;i++)
cout<<"Tapez la valeur numero {
"<<i<<" : "; cout<<"Tapez la valeur numero
cin>> t[i]; "<<i<<" : ";
} cin>> t[i];
} }
}
int f(int t[], int n)
{ bool f(int t[], int n, int &v)
int nb=0; {
int i; bool trouve=false;
for(i=0;i<n;i++) int i=0;
if(t[i]>=0 && t[i]<=10)nb++; while(!trouve && i<n)
return nb; if(t[i]>=0 && t[i]<=10)
} {trouve=true; v=t[i];}else i++;
return trouve;
int main() }
{
int a[10]; int main()
saisir(a,10); {
int x; int a[10];
x=f(a,10); bool b;
cout<<"Il y a "<<x<<" valeur(s) int w;
entre 0 et 10"<<endl;
return 0; saisir(a,10);
} b=f(a,10,w);
if(b)cout<<"Il existe une valeur
entre 0 et 10 : "<<w<<" est la
EXERCICE 8[modifier | modifier le première de ces valeurs."<<endl;
wikicode] else cout<<"Il n'existe pas de
valeurs entre 0 et 10"<<endl;
Écrire une fonction f ayant en paramètres un return 0;
tableau t de taille quelconque et un entier n }
indiquant la taille du tableau. f possède un
autre paramètre v , entier passé par
référence. f doit renvoyer par un return un
booléen b indiquant s'il existe une valeur
EXERCICE 9[modifier | modifier le
int main()
wikicode] {
Écrire une fonction f ayant en paramètres un int a[10],b[10];
tableau t1 de taille quelconque et un entier n int nb;
indiquant la taille du tableau, ainsi qu'un
tableau t2 de la même taille que t1. f doit saisir(a,10);
nb=f(a,10,b);
renvoyer par un return un entier nb
cout<<"VOICI LES VALEURS ENTRE 0
indiquant le nombre de valeurs comprises ET 10 : "<<endl;
entre 0 et 10 dans le tableau t1. f doit mettre afficher(b,nb);
dans le tableau t2 les différentes valeurs return 0;
comprise entre 0 et 10 qu'il a rencontrées }
dans le tableau t1.
Solution
EXERCICE 10[modifier | modifier le
Cet exercice a pour but de vérifier les points wikicode]
techniques suivants :
Écrire une fonction f ayant en paramètres un
 Écriture d'une fonction ayant
tableau t de taille quelconque et un entier n
comme paramètre un tableau de indiquant la taille du tableau. f doit renvoyer
taille quelconque. par un return un entier égal à l'indice de la
 Extraction d'un sous-liste première case du tableau (parmi les n
d'éléments. premières) comprise entre 0 et 10. S'il
 Utilisation de return.
n'existe pas de telle valeur, la fonction
renvoie -1. Tester cette fonction.
 Voici le fichier source :
Solution
#include<iostream> Cet exercice a pour but de vérifier les points
using namespace std; techniques suivants :
void saisir(int t[],int n)
{  Écriture d'une fonction ayant
int i; comme paramètre un tableau de
for(i=0;i<n;i++) taille quelconque.
{  Recherche d'un élément dans un
cout<<"Tapez la valeur tableau.
numéro "<<i<<" : ";  Utilisation de return.
cin>> t[i];  Voici le fichier source :
}
} #include<iostream>
using namespace std;
void afficher(int t[],int n)
{ void saisir(int t[],int n)
int i; {
for(i=0;i<n;i++) int i; for(i=0;i<n;i++)
cout<<t[i]<<" "; {
cout<<endl; cout<<"Tapez la valeur numero
} "<<i<<" : ";
cin>> t[i];
int f(int t1[], int n,int t2[]) }
{ }
int i=0,nb=0;
int f(int t[], int n)
for(i=0;i<n;i++)if(t1[i]>=0 && {
t1[i]<=10){t2[nb]=t1[i];nb++;} int i=0,ind=-1;
return nb;
} while(ind==-1 && i<n)
if(t[i]>=0 && t[i]<=10)ind=i;else using namespace std;
i++;
return ind; class Rectangle
} {
public:
int main() Rectangle(unsigned int
{ initLargeur, unsigned int
int a[10]; initHauteur);
int w; ~Rectangle();
unsigned int getLargeur() const
saisir(a,10); { return largeur; };
w=f(a,10); unsigned int getHauteur() const
if(w!=-1)cout<<"Il existe une { return hauteur; };
valeur entre 0 et 10. " unsigned int perimetre() const {
<<"l'indice de la première case return 2*(largeur+hauteur); };
est "<<w<<endl; unsigned int surface() const {
else cout<<"Il n'existe pas de return largeur * hauteur; };
valeurs entre 0 et 10"<<endl; void setLargeur(unsigned int
return 0; newLargeur) { largeur =
} newLargeur; };
void setHauteur(unsigned int
newHauteur) { hauteur =
newHauteur; };
void afficher();

private:
unsigned int largeur;
unsigned int hauteur;
};
EXERCICE 1 :
Rectangle::Rectangle(unsigned int
Rectangle[modifier | modifier le initLargeur, unsigned int
wikicode] initHauteur)
{
Écrire un programme utilisant une classe largeur = initLargeur;
rectangle dont le constructeur prend deux hauteur = initHauteur;
paramètres, largeur et hauteur et qui offre }
les fonctions suivantes :
Rectangle::~Rectangle()
 calcul du périmètre, {
}
 calcul de la surface,
 affichage, void Rectangle::afficher()
 ainsi que les accesseurs et {
mutateurs triviaux (lecture et for(unsigned int i=0; i <
modification de la largeur et de hauteur; i++)
la hauteur). {
Solution for(unsigned int j=0; j <
largeur; j++)
Découverte et travail des classes. Utilisation cout << "*";
d'un constructeur et d'un destructeur. cout << endl;
}
}
#include<iostream>
int main()
#include <cstdlib>
{
Rectangle monRectangle(0,0);
 char choix = '0'; }
unsigned int value; }
return 0;
while(true) }
{
do
{
cout << " Rectangle - Menu"
EXERCICE 2 : Pile
<< endl; d'entiers[modifier | modifier le
cout << "1 - Modifier wikicode]
largeur du rectangle" << endl;
cout << "2 - Modifier Une pile est un ensemble dynamique
hauteur du rectangle" << endl; d’éléments où le retrait se fait d’une façon
cout << "3 - Calculer les particulière. En effet, lorsque l’on désire
propriétés du rectangle" << endl; enlever un élément de l’ensemble, ce sera
cout << "4 - Afficher le toujours le dernier inséré qui sera retiré. Un
rectangle" << endl; objet pile doit répondre aux fonctions
cout << "5 - Quitter" << suivantes :
endl;

cin >> choix;  Initialiser une pile,

}  Empiler un élément sur la pile
while(choix < '1' || choix > (push),
'5');  Dépiler un élément de la pile
(pop).
switch(choix)
{ Pour cela nous allons supposer que les
case '1': éléments à empiler sont de type int.
cout << "Nouvelle
largeur : "; Le programme principal comprend la
cin >> value; définition d'une classe pile et un programme
de test qui crée deux piles p1 et p2, empile
[Link](value); dessus des valeurs entières et les dépile
break; pour vérifier les opérations push et pop.
case '2':
Solution
cout << "Nouvelle
hauteur : ";
cin >> value;  Découverte et travail des classes.
 Utilisation d'un constructeur et
[Link](value); d'un destructeur.
break;
case '3':
cout << "Périmètre : " <<
[Link]() << endl; #include <iostream>
cout << "Surface : " <<
[Link]() << endl; class stack
break; {
case '4':
[Link](); private:
break; int limit;
case '5': int taille;
exit(0); int *pile;
break; public:
default: stack(const size_t &taille);
cout << "Erreur ! Choix ~stack();
invalide." << endl; void push(const int &);
exit(1); int pop();
 EXERCICE 3 :
};
Fichier[modifier | modifier le
wikicode]
Imaginons une application qui traite des
stack::stack(const size_t &taille) fichiers. Ces fichiers vont être lus en
{ mémoire, traités puis sauvegardés. Une fois
pile = (int lu en mémoire, un fichier a deux
*)malloc(sizeof(int) * taille); caractéristiques, une adresse à partir de
this->taille = taille; laquelle se situe le fichier et une longueur,
limit = 0; ce qui se concrétisera par un pointeur et une
} longueur en nombre d’octets. Imaginons la
classe "Fichier" avec un constructeur et un
void stack::push(const int &src) { destructeur et les trois méthodes suivantes :
if (limit < taille) {
limit += 1;
pile[limit] = src;  la méthode "creation" qui va
allouer un certain espace à partir
} else { du pointeur p,
int *tmp = (int  la méthode "remplit" qui va
*)malloc(sizeof(int) * (taille + remplir arbitrairement cet espace
5)); (ces remplissages arbitraires
for (int i = 0; i < taille sont la preuve de la bonne
+ 5; ++i) tmp[i] = pile[i]; gestion mémoire car l’accès à
taille+= 5; une zone non déclarée provoque
pile = tmp; une violation d’accès),
limit += 1;
pile[limit] = src;  la méthode "affiche" qui va
} afficher la zone mémoire pointée
} par p.
Puis écrivons un programme maître qui
int stack::pop() {
instancie notre classe par new, appelle nos
int tmp = pile[limit];
trois méthodes et détruit l’objet par delete.
pile[limit] = 0;
limit -= 1; Solution
return tmp;
} Découverte et travail des classes. Utilisation
d'un constructeur et d'un destructeur.
stack::~stack()
{
free(pile);
#include <iostream>
}
using namespace std;

// déclaration de la classe
Fichier
class Fichier
{
char* p;
unsigned int taille_buffer;

public:
Fichier();
~Fichier();
bool creation(unsigned
int);
 EXERCICE 4 :
void remplit();
void affiche(); Point[modifier | modifier le
}; wikicode]
// constructeur Réaliser une classe point permettant de
Fichier::Fichier() manipuler un point d'un plan. On prévoira :
{
p = NULL;  les coordonnées x et y du point
taille_buffer = 0; en membres privés,
}  un constructeur (vous pouvez
également implémenter les trois
// destructeur
types de constructeur),
Fichier::~Fichier()
{  une fonction
delete[] p; membre déplace effectuant une
} translation définie par ses deux
arguments dx et dy (double),
// méthode Creation  une fonction
bool Fichier::creation(unsigned membre affiche affichant les
int taille) coordonnées cartésiennes du
{ point,
if ((p = new
char[taille])==NULL) return false;  une fonction
taille_buffer = taille; membre saisir permettant de
return true; saisir les coordonnées
} cartésiennes du point,
 une fonction
// Méthode Remplit membre distance effectuant
void Fichier::remplit() calculant la distance entre deux
{ points,
for(unsigned int i=0 ;
 une fonction
i<taille_buffer ; i++) P[i]='a';
} membre milieu donnant le
milieu d'un segment.
// Méthode Affiche On écrira séparément :
void Fichier::affiche()
{
for(unsigned int i=0 ;  un ficher source constituant la
i<taille_buffer ; i++) cout<<P[i]; déclaration et la définition de la
} classe,
 un petit programme d'essai
//-----Programme maître gérant la classe point.
(main)-------------- Solution
int main()
{ Découverte et travail des classes. Utilisation
Fichier* f = new Fichier(); d'un constructeur et d'un destructeur.
if (f->creation(10))
{
f->remplit(); #include <iostream.h>
f->affiche(); #include <math.h>
} class point
delete f; {
return 0; double x;
} double y;
public:
point();
 point(double,double); {
point(point &); double p1,x1,x2;
~point(); x1=(get_x()-
double get_x(); p.get_x())*(get_x()-p.get_x());
double get_y(); x2=(get_y()-
void set_x(double x1); p.get_y())*(get_y()-p.get_y());
void set_y(double y1); //p1=sqrt(((get_x()-
point deplace(double dx, double p.x)*((get_x()-p.x))+((get_y()-
dy); p.y)*(get_y()-p.y)));
void affiche(); p1=sqrt(x1+x2);
void saisir(); return p1;
double distance(point &); }
point milieu(point &); void point::affiche()
{
}; cout<<"les coordonnées
sont:"<<endl;
point::point() cout<<"x="<<get_x()<<endl;
{} cout<<"y="<<get_y()<<endl;
point::point(double a,double b) }
{ void point::saisir()
x=a; {
y=b; cout<<"donnée les
} coordonnées:"<<endl;
point::point(point &p) cout<<"x="<<endl;
{ cin>>x;
set_x(p.get_x()); cout<<"y="<<endl;
set_y(p.get_y()); cin>>y;
} }
point::~point() point point::milieu(point &p)
{} {
double point::get_x() point p1;
{ p1.x=(get_x()+p.get_x())/2;
return x; p1.y=(get_y()+p.get_y())/2;
} return p1;
double point::get_y() }
{
return y; //programme d'essai(main)
}
void point::set_x(double a) #include<iostream.h>
{ #include "pointt.h"
x=a; void main()
}
void point::set_y(double a)
{
y=a;
}
point point::deplace(double
dx,double dy)
{

set_x(get_x()+dx);

set_y(get_y()+dy);
return *this;

}
double point::distance (point &p)
{point p(1,1);
  Utilisation d'un constructeur et
point x(5,5); d'un destructeur.
point c;
Fichier Compteur.h : déclaration de la classe
[Link](); Compteur
[Link](5,5);
[Link](); class Compteur { protected: /*
cout<<"la distance est : i.e. visible des classes dérivées
"<<[Link](x); */
c=[Link](x); int _valeur; public:
[Link](); /* i.e. l'interface de la classe
*/
Compteur(); /*
} le constructeur, invoque a la
création */
void incr();
EXERCICE 5 : void decr();
int valeur(); /*
Compteur[modifier | modifier le permet un accès "read-only" a
wikicode] l'attribut */
};
On souhaite implémenter une classe
représentant un compteur entier. Un tel objet
se caractérise par : Fichier [Link] : implémentation de la
classe Compteur
 Une valeur entière, positive ou
nulle, nulle à l'origine. #include <iostream.h>
 Le fait qu'il ne peut varier que #include "Compteur.h"
par pas de 1 (incrémentation ou
décrémentation). On convient /
qu'une décrémentation d'un **********************************
compteur nul est sans effet. ***************************/
Compteur :: Compteur()
Il s'agit de créer une classe Compteur pour {
rendre le service demandé. On écrira en _valeur = 0;
outre un petit programme de test qui : }

1. créera un compteur et /
affichera sa valeur ; **********************************
***************************/
2. l'incrémentera 10 fois, puis void Compteur :: incr()
affichera à nouveau sa {
valeur ; _valeur ++;
3. le décrémentera 20 fois, }
puis affichera une troisième
fois sa valeur. /
**********************************
La sortie de ce programme doit donner ***************************/
quelque chose comme : void Compteur :: decr()
{
0 if (_valeur>0) _valeur--;
10 }
0
/
**********************************
Solution ***************************/
int Compteur :: valeur()
 Découverte et travail des classes.
 les méthodes suivantes :
{
return _valeur; - void saisie (), permettant la saisie d’un
} étudiant
- void affichage (), permettant l’affichage
Fichier [Link] : implémentation d’un étudiant
de la classe Compteur - float moyenne (), retourne comme résultat
la moyenne des notes d’un étudiant.
#include <iostream.h> - int admis (), retourne comme résultat la
#include "Compteur.h" valeur 1, si un étudiant est admis et la valeur
0, sinon. Un étudiant est considéré comme
/ étant
**********************************
***************************/ admis lorsque la moyenne de ses notes est
int main () { supérieure ou égale à 10.

Compteur c; // - int exae_quo (Etudiant E), retourne comme

Initialisé à 0 par le résultat la valeur 1, si deux étudiants ont la
constructeur. même moyenne et la valeur 0, sinon.
Ecrire la classe Etudiant dans le langage C+
cout << [Link]() << endl; +.
for (int i=0 ; i<10 ; i++)
[Link](); 2/ On voudrait maintenant représenter, à
cout << [Link]() << endl; // l’aide d’une nouvelle classe
Le compteur est passé à 10. Etudiant_en_Maitrise, certains étudiants
for (int i=0 ; i<20 ; i++) // particuliers dans cette
La variable "i" est locale à la
boucle "for" ! institution qui sont les étudiants en dernière
[Link](); // année d’études. Ces étudiants possèdent en
Après avoir atteint 0, les 10 effet un attribut supplémentaire :
dernières itérations sont sans note_memoire,
effet.
cout << [Link]() << endl; // qui représente la note de leur mémoire de fin
Le compteur est redescendu à 0. d’études.
Les méthodes à associer à cette classe sont
return 0; // les suivantes :
Code de sortie de programme pour
l'OS. - void saisie (), permettant la saisie d’un
} étudiant en maîtrise
- void affichage (), permettant l’affichage
d’un étudiant en maîtrise
EXERCICE 6 : Gestion
- float moyenne (), retourne comme résultat
d'étudiants[modifier | modifier le la moyenne des notes d’un étudiant en
wikicode] maîtrise
1/ On voudrait gérer les étudiants d’une - int admis (), retourne comme résultat la
institution à l’aide d’une classe Etudiant valeur 1, si un étudiant est admis et la valeur
définie par : 0, sinon. Un étudiant en maîtrise est
considéré
les attributs suivants :
comme étant admis lorsque, d’une part, la
- nom : nom d’un étudiant
moyenne de ses notes est supérieure ou
- prénom: prénom d’un étudiant égale à 10 et d’autre part la note obtenue
pour son mémoire
- tabnotes : tableau contenant les notes d’un
étudiant, sachant qu’un étudiant a au total de fin d’études est supérieure ou égale à 10.
10 notes.
- int exae_quo (Etudiant_en_Maitrise E),
retourne comme résultat la valeur 1, si deux cout << "Donner le
étudiants ont d’une part la même moyenne prénom :" ;
et d’autre
cin >> prenom ;
part, la même note de mémoire et retourne
la valeur 0, sinon. cout << "Saisie des
notes \n" ;
a) Quelles sont les méthodes qui sont à
redéfinir dans la classe
for (i = 0 ; i < 10 ;
Etudiant_en_Maitrise ? i++)
b) Ecrire la classe Etudiant_en_Maitrise
dans le langage C++. {

Solution cout <<

"Donner la note N°" << i<< " : " ;
Découverte et travail des classes. Utilisation
d'un constructeur et d'un destructeur. cin >>
tabnotes[i] ;

1/ void Etudiant ::affichage ()

class Etudiant { int i ;

{ private: cout << "Le

nom :"<<nom<< endl ;
char nom[50],
prenom[50]; cout << "Le prénom :"
<<prenom<< endl ;
float tabnotes[10] ;
for (i = 0 ; i < 10 ;
public : i++)

void saisie () ; cout <<

"La note N°" << i << "est " <<
void affichage () ; tabnotes[i]<< endl ;

float moyenne() ; }

int admis() ; float Etudiant ::moyenne()

int exae_quo (Etudiant { int i ;

E) ;
float som = 0;
} ;
for (i = 0 ; i < 10 ;
void Etudiant ::saisie () i++)

{ int i ; som + =
tabnotes[i] ;
cout << "Donner le
nom :" ; return (som/10)

cin >> nom ; }

int Etudiant ::admis() { Etudiant :: affichage
() ;
{ if (moyenne() >= 10) return (1);
else return (0);} cout << "La note du mémoire :" <<
note_memoire<< endl ;
int Etudiant ::Exae_quo(Etudiant
E) }

{ if (moyenne() == [Link]()) int Etudiant_en_Maitrise ::admis()

return (1); else return (0);}
{ if ((moyenne() >= 10) &&
2/ (note_memoire >=10))return (1);
else return (0);}
a) Les méthodes qui sont à
redéfinir dans la classe int Etudiant_en_Maitrise
Etudiant_en_Maitrise sont : ::Exae_quo(Etudiant E)
saisie, affichage, admis et
esae_quo. { if ((moyenne() == [Link]())
&& (note_memoire ==
b) E.note_memoire)) return (1); else
return (0);}
class Etudiant_en_Maitrise :
public Etudiant

{ private:

float note_memoire ;

public :

void saisie () ; Exercice 1[modifier | modifier le

void affichage () ; wikicode]
[MOYEN]
int admis() ;
Requis:
int exae_quo
(Etudiant_en_Maitrise E) ;  manipulation de tableaux,
} ;  savoir créer une fonction
template.
void Etudiant_en_Maitrise ::saisie Créez une fonction "trier" pour trier un
() tableau de 10 données avec un tri par
sélection [archive]. Le tableau devra être de
{ Etudiant ::saisie () ;
n'importe quel type. Cette fonction utilisera
une autre fonction, "échanger", pour
cout << "Donner la note du
mémoire :" ; échanger les éléments du tableau.
Aide
cin >> note_memoire ;
Le tri par sélection scan un tableau et met sa
} valeur minimale au début. Il répète l'opération
jusqu'à obtenir un tableau trié.
void Etudiant_en_Maitrise
Solution
::affichage ()
Voici le code source:
template<class T> T * échanger(T
tab[10], int a, int b) 1) Créer une classe Template "Rectangle"
{ prenant en paramètre les coordonnées de
T c = tab[a]; celui-ci sur un graphique(x,y). Évidemment,
tab[a] = tab[b]; le type des attributs et des méthodes
tab[b] = c; renvoyant une valeur (si il y en a)
return tab; dépendront donc du paramètre Template
} rentré au préalable.

template<class T>T * trier(T 2) Créer une méthode retournant sa hauteur

tab[10]) et son aire.
{
int j, min;
for(int i = 0; i < 9; i++) ---AIDE :---
{
Voici comment déclarer votre Objet
for(j = i; j < 10; j++)
Rectangle dans le main() : Rectangle<float>
{
if(j == i) myRectangle(1.2, 2.6, 1.5, 4.1);
min = j;
if(tab[j] < tab[min]) Exercice 4[modifier | modifier le
min = j; wikicode]
}
échanger(tab, i, min); [MOYEN-DIFFICILE]
}
return tab; Requis:
}
 savoir utiliser les pointeurs et
l'allocation dynamique de
Exercice 2 : Fonction mémoire,
 savoir créer une
Template[modifier | modifier le classe template,
wikicode]  savoir créer une structure.
[FACILE] Requis : Savoir créer et utiliser une Créez une classe liste simplement chaînée,
fonction Template avec une classe liste. Cette classe a un
pointeur sur le premier élément de la liste.
Elle a une méthode pour ajouter ou
1) Créer une fonction Template qui supprimer un élément au début de la liste et
permettra de faire une somme entre un int et une pour afficher la liste en entier. Évitez
un float, toute fuite mémoire. Les éléments de la liste
2) faire une spécialisation de la fonction en seront contenu dans la structure element.
std::string, qui retournera la somme de la Aide
taille des deux chaînes.
Utilisez l'instruction new et delete pour
supprimer et créer de nouveaux éléments. Une
liste simplement chaînée est une structure de
donnée. Elle est constituée de blocs où
chaque bloc pointe sur le bloc suivant. Chaque
bloc contient une donnée. Il est conseillé de
réviser les pointeurs.
Exercice 3 : Classe Solution
Template[modifier | modifier le Voici le fichier source décomposé pour plus de
wikicode] lisibilité:

[FACILE-MOYEN] Requis : Savoir créer une En-tête

classe Template
#include <iostream> void supprimer()
using namespace std; {
if(début == NULL)
Structure élément return;
element<T> * p = début;
début = début->suivant;
// Structure élément delete p;
template<class T> element }
{
T var; Afficher
element<T> * suivant;
};
void afficher()
Classe liste {
element<T> * p = début;
while(p != NULL)
// Classe liste {
Template<class T>class liste cout << p->var << endl;
{ p = p->suivant;
public: }
element<T> * début; }
};
Constructeur et destructeur

liste()
{
début = NULL;
}

~liste()
{ EXERCICE 1 : La classe
while(début != NULL)
{ string[modifier | modifier le wikicode]
supprimer(); Soit une chaîne de caractères contenant une
} date (JJ/MM/AAAA) et une heure (HH:NN)
}
sous la forme JJMMAAAAHHNN. Par
exemple 010920091123 représente la date
Ajouter et supprimer
du 1er septembre 2009 à 11h23.
Créer un programme permettant d'extraire
void ajouter(T var)
les différents champs et de les afficher.
{
if(début == NULL) Solution
{
Cet exercice a pour but de vérifier les points
début = new element<T>;
début->suivant = NULL; techniques suivants :
}
else  Manipulation des chaînes de
{ caractères.
element<T> * p = new element<T>; Voici le fichier source :
p->suivant = début;
début = p;
} #include <iostream>
début->var = var; #include <iomanip>
} #include <string>
 Voici le fichier source :
using namespace std;
#include <iostream>
void afficherDateEtHeure(const
#include <fstream>
string& s)
{
int main (int argc, char * argv[])
if ( [Link]() != 12 )
{
cerr << "Chaine invalide."
std::ofstream myfile;
<< endl;
char * filename = "[Link]";
else
[Link] (filename,
{
std::ios::out);
cout << "Date : " <<
if(myfile.is_open())
[Link](0,2) << "/" <<
{
[Link](2,2) << "/" <<
myfile << "Hello world \n";
[Link](4,4) << endl;
myfile << "Voici un
cout << "Heure : " <<
programme illustrant l'écriture
[Link](8,2) << "h" <<
dans un fichier \n";
[Link](10,2) << endl;
}
}
else
}
{
std::cout << "Erreur à
int main(int argc, char** argv)
l'ouverture du fichier "<<
{
filename << std::endl;
string s("010920091123");
}
afficherDateEtHeure(s); //
[Link]();
exemple
return 0;
}
}

EXERCICE 2[modifier | modifier le

wikicode]
Écrire un programme qui lit le fichier
[Link] définit dans l'exemple précédent
et affiche son contenu :
Vous devriez obtenir :

EXERCICE 1[modifier | modifier le Hello world!

wikicode] Voici un programme illustrant
l'écriture dans un fichier
Écrire un programme qui écrit dans le fichier
[Link] le texte:
Solution

Hello world! Cet exercice a pour but de vérifier les points

Voici un programme illustrant techniques suivants :
l'écriture dans un fichier
 L'ouverture d'un fichier en lecture
Solution  Tester si un fichier est ouvert (en
particulier si vous avez les droits
Cet exercice a pour but de vérifier les points de lecture sur le fichier)
techniques suivants :
 Parcourir dans son intégralité un
fichier
 L'ouverture d'un fichier en écriture
 Fermer le fichier une fois la lecture
 Tester si un fichier est ouvert (en terminée
particulier si vous avez les droits
d'écriture sur le fichier) Voici le fichier source :
 Fermer le fichier une fois l'écriture
terminée
  Tester si un fichier est ouvert (en
#include <iostream> particulier si vous avez les droits
#include <fstream> d'écriture sur le fichier)
#include <string>  Écrire des données en binaire
 Fermer le fichier une fois l'écriture
int main () {
terminée
std::string line;
char * filename = "[Link]"; Voici le fichier source :
std::ifstream myfile (filename,
std::ios::in);
#include <iostream>
if (myfile.is_open())
#include <fstream>
{
while (! [Link]() )
int main (int argc, char * argv[])
{
{
getline (myfile,line);
std::ofstream myfile;
std::cout << line <<
char * filename =
std::endl;
"[Link]";
}
[Link] (filename,
[Link]();
std::ios::out | std::ios::binary);
}
if(myfile.is_open())
{
else std::cout << "Erreur à
[Link]("Liste des
l'ouverture du fichier " <<
entiers de 1 à
filename << std::endl;;
1000",29*sizeof(char));
for(int i = 0 ; i <= 1000 ;
return 0;
i++)
}
{

[Link]((char*)&i,sizeof(int)
Les fichiers : Lecture et );
écriture en mode }
}
binaire[modifier | modifier le else
wikicode] {
std::cout << "Erreur à
EXERCICE 1[modifier | modifier le l'ouverture du fichier "<<
wikicode] filename << std::endl;
}
Proposez un programme qui écrit en binaire [Link]();
une chaîne de caractère suivant de la liste return 0;
des entiers de 0 à 1000 : }

Liste des entiers de 1 à 1000 EXERCICE 2[modifier | modifier le

0
1 wikicode]
2 Proposez un programme qui lit le fichier écrit
... en binaire de l'exercice précédent et affiche
1000 son contenu. Vous devriez obtenir :

Solution
Liste des entiers de 1 à 1000
Cet exercice a pour but de vérifier les points 0
techniques suivants : 1
2
 L'ouverture d'un fichier en écriture ...
1000
en mode binaire

Solution
Cet exercice a pour but de vérifier les points
techniques suivants : return 0;
}
 L'ouverture d'un fichier en lecture
en mode binaire
 Tester si un fichier est ouvert (en
particulier si vous avez les droits
de lecture sur le fichier)
 Lecture des données écrites en
binaire
 Fermer le fichier une fois la lecture
terminée
Voici le fichier source :

#include <iostream>
#include <fstream>

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

{
std::ifstream myfile;
char * filename =
"[Link]";
char buffer[29];
int value;
[Link] (filename,
std::ios::in | std::ios::binary);
if(myfile.is_open())
{

[Link](buffer,29*sizeof(char)
);
std::cout << buffer <<
std::endl;
for(int i = 0 ; i <= 1000 ;
i++)
{

[Link]((char*)&value,sizeof(i
nt));
std::cout << value <<
std::endl;
}
}
else
{
std::cout << "Erreur à
l'ouverture du fichier "<<
filename << std::endl;
}
[Link]();