CHAPITRE1 : CONCEPTS DE BASE DE LA PROGRAMMATION

I-INTRODUCTION
La programmation consiste à écrire des instructions pour un ordinateur afin qu’il
puisse effectuer des taches. Les programmes informatiques sont écrits dans des
fichiers appelés fichiers sources. Ces fichiers contiennent alors des codes appelés
codes sources. Les programmes informatiques sont écrits sur la base des
algorithmes qui sont par la suite traduits en langages de programmation (C++,
Python, Java, Php etc.)
II-CONCEPTS DE BASE DE LA PROGRAMMATION
1)Les types de données
Les types de données sont des concepts qui décrivent le type ou la nature
d’information qu’une variable peut stocker et les opérations qui peuvent être
effectuée sur ces données. Parmi ces types on peut citer
ALGORITHME C C++
Entier int int, integer
réel Float Float, double
booléen boolean boolean
caractère Char char
Chaine de caractère Char[ ] string

2)Variables
Les variables sont des données manipulées par le programme lors de son
exécution. Le contenu d’une variable peut changer. Les variables occupent des
emplacements au niveau de la mémoire vive (RAM).
-Syntaxe de déclaration des variables
ALGORITHME C++/C
Var Type nomvariable ;
No variable : type Exemples :
Exemples : Int age ;
Var String prénom
Age : entier
Prénom : chaine de caractères

3)Constantes
Les constantes sont des données manipulées par le programme et dont le contenu
ne change pas.
-Syntaxe de déclaration d’une constante
ALGORITHME C++/C
Const Const type nom_constante=valeur
Nom_constantevaleur Exemple :
Exemples : Const float pi=3,14
Const
Pi3,14

4)Instruction d’écriture(affichage)
Cette instruction permet d’afficher un message à la consonne
La syntaxe
ALGORITHME C C++
Écrire (« Message à Printf(« message ») Cout « ‘’Message’’ ;
afficher) Printf(« bonjour… ») Std ::cout << ‘’message’’<< std::endl;
Ex : La fct° appartient à la
Écrire(« Bonjour chers bibliothèque stdio.h Std ::cout<< ‘’bonjour’’ << std ::endl ;
amis) On doit ajouter
#include<stdio.h>
La fonction Cout appartient à la bibliothèque iostream. Il faut l’inclure en ajoutant
#include<iostream>.
5-Instruction de lecture (saisie au clavier) :
Cette instruction permet de récupérer les données saisies au clavier et de les
stocker dans une variable
ALGORITHME C C++
Lire(nom_variable) Scanf(«%x»,&nomvariable) ; Cin >> nomvariable ;
d pour int Exple :
Exple : f pour float Cin >> age ;
Lire(age) c pour char
s pour char [ ]

a#include<iostream>

//déclaration des constantes

//déclaration des variables
int age;
int main( ) {
//Instructions
Return 0;
}
APPLICATION : créer un programme en c++ qui affiche « bonjour chers
amis »

#include<iostream>
int main () {
std ::cout << "Bonjour chers amis"<< std::endl;
return 0;
}
 Chapitre2 : Les structures de contrôle
I)Introduction :
Les structures de contrôle permettent d'agir sur l'ordre où la fréquence
d'exécution des instructions d'un programme
il existe deux grands types de structure de contrôle:
-les structures conditionnelles et les structures répétitives appelées
boucles
II)les structures conditionnelles
Elles permettent d'agir sur l'ordre d'exécution des instructions d'un
programme.
Les blocs de code sont exécutés en fonction de certaines conditions :
1)la condition if
Syntaxe :
if(condition){traitement ;
}
La condition est d'abord évaluée si elle est vraie. Le traitement sera
exécuté sinon il ne sera pas exécuté
2)la condition if-else
La condition est d'abord évaluée, si elle est vraie le traitement1 sera
exécuté il ne sera pas exécuté et donc le traitement2 sera exécuté.

Syntaxe :
 if(condition){traitement1 ;
}
else{traitement2;
}
Exemple : écrire un programme c++ qui vérifie un mot de passe saisie
par l'utilisateur.il affiche correcte si le mot de passe saisi est "toto" où
incorrecte dans le cas contraire

#include <iostream>

using namespace std;

int main ()
{
string mdp = "toto";
string mdps ;
cout << "Saisissez le mot de passe :” ;
cin >> mdps;
if (mdp == mdps){

cout << "Correct";

else {

cout << "Incorrect";

return 0;

III)les boucles
Elles permettent d'agir sur la fréquence d'exécution des programmes
1)la boucle for

Syntaxe
for (initialisation ; condition ; itération) {
traitement
}
-initialisation : permet d'initialiser une variable de contrôle.
Par exemple : i=1
-condition : la boucle continue tant que cette condition elle est vraie.
Par exemple : i<=10.On sort de la boucle dès que la condition est fausse
-itération : elle est utilisée pour incrémenter où décrémenter la valeur.
Exemple : for(int i=0;i<5;i++){
cout<<i;
}
APPLICATION : Écrire un programme qui affiche les nombres pairs
entre 1 et 50 #include <iostream>

using namespace std;

int main()

for(int i=1; i <= 50; i++){

if (i % 2 == 0){

cout << i;

Exercice1 : un programme en c++ qui permet cout <<"de

"; saisir deux entier a et

b.il calcul et affiche la valeur de a à la puissance

}
n
}

return 0;
 #include <iostream>

#include <cmath>

using namespace std;

int main() {

// Déclaration des variables

int a, n;

// Saisie de a et n

cout << "Veuillez saisir la valeur de a : ";

cin >> a;

cout << "Veuillez saisir la valeur de n : ";

cin >> n;

// Calcul de la puissance et affichage du résultat

double resultat = pow(a, n);

cout << a << " à la puissance " << n << " est égal à : " << resultat << endl;

return 0;

2)la boucle while

La condition est d'abord évaluée si elle est vraie on rentre dans la
boucle pour exécuter le traitement. Après chaque exécution on revérifie
la condition. Dès que la condition est fausse, on cherche. Le programme
demande à l'utilisateur d'essayer plusieurs tentatives
Exercice : code qui demande à l'utilisateur de saisir un nombre à
deviner
Programme demande à l'utilisateur de trouver le nombre .si le nombre
à deviner est identique ; le programme affiche "bravo vous avez trouvé"
Si le nombre est supérieur au nombre à deviner le programme affiche
EXO : Ecrire un programme qui affiche tous les nombres premiers
compris entre 1 et 100 en utilisant une imbrication de for et while

#include <iostream>

using namespace std;

// Fonction pour vérifier si un nombre est premier

bool est Premier (int n) {

if (n <= 1) {

return false;

for (int i = 2; i * i <= n; i++) {

if (n % i == 0) {

return false;

return true ;

int main () {

cout << "Nombres premiers entre 1 et 100 (boucle for) :" << endl;
 // Utilisation de la boucle for
for (int i = 1; i <= 100; i++) {
if (estPremier(i)) {
cout << i << " ";
}
}

cout << "\n\nombres premiers entre 1 et 100 (boucle while) :" << endl ;

// Utilisation de la boucle while

int j = 1 ;
while (j <= 100) {
if (estPremier(j)) {
cout << j << " ";
}
j++;
}

return 0;
 }

IV-Les types structures

Une structure permet de designer sous un même nom des éléments
pouvant être de types différents
Syntaxe :
Struct nom_structure {
type champ1 ;
type champ2 ;
type champ3 ;
};

Exemple :
Struct Etudiant {
String prénom ;
String nom ;
Int âge ;
};

Après avoir défini un type de structure on peut déclarer des variables

ayant ce type

Exemple de variable
struct Etudiant et ;

EX : Déclarer une structure date(jour, mois, année) et une variable d de

type date.Demandez à l’utilisateur de saisir une date et le programme
affiche la date saisie

using namespace std;

struct date {
int jour;
string mois;
int annee;
};
int main () {
struct date d;
cout<<"saisir le jour\n";
cin>>d.jour;
cout<<"saisir le mois\n";
cin>>d.mois;
cout<<"saisir l'annee\n";
cin>>d.annee;
cout<<"La date saisie est"<<d.jour<<"/"<<d.mois<<"/"<<d.annee;
return 0;
 Soient les tableaux ci-dessous
tcl
codecl Prénom Nom Ville
Cl1 Fatou Diallo Dakar
CL2 Aliou Diouf Thies
CL3 Modou Sene Dakar
CL4 Jean Diouf Touba
CL5 Jérôme Sarr Thies

tfact
Id fact Date fact montant Code cl
ff1 05/02/2023 500 000 Cl2
ff2 17/08/2022 600 000 CL1
ff3 14/12/2023 150 000 CL1
ff4 06/04/2022 700 000 CL3
ff5 16/12/2022 900 000 CL5
ff6 30/10/2023 100 000 CL2
ff7 18/04/2023 245 000 CL3
ff8 07/02/2022 350 000 CL1
ff9 19/04/2022 100 000 CL4
ff10 16/03/2023 240 000 CL1
ff11 12/02/2023 800 000 CL4
ff12 15/06/2023 50 000 CL5
ff13 17/05/2023 200 000 CL2
TAF :
-Déclarer 2 structures (client et facture) !
-Déclarer 2 tableaux Tcl et Tfact !
-Ecrire une procédure remplirtcl qui remplit le tableau Tcl !
-Ecrire une procédure remplirfact qui remplit le tableau Tfact !
-Ecrire une fonction Minfact qui renvoie la facture la moins chère !
-Ecrire une fonction Totalfact qui renvoie le montant total des factures
-Ecrire une fonction somfactDakar qui renvoie le montant total des
factures des clients à Dakar
-Ecrire une procedure listefactAn qui affiche les factures de l’an 2022 !
-Ecrire une fonction montantfact qui renvoie le total des factures pour
l’an 2023
-Ecrire une procédure listefact qui affiche les factures envoyées aux
clients de Dakar
-Ecrire une procédure qui affiche le prénom et nom du client qui a reçu
la facture la plus chère
 CHAPITRE3 : LES FICHIERS
I/Définition
Les fichiers sont utilisés pour lire et écrire des informations sur un
support de stockage (disque dur, clé USB, carte mémoire etc). En c++ les
fichiers sont gérés à l’aide des bibliothèques standards qui sont :
iostream (input output stream) et fstream.
On distingue 2 types de fichiers en c++ :
-Les fichiers de sortie gérés par la bibliothèque iostream ; ces fichiers
sont utilisés pour écrire des données dans un fichier
-Les fichiers d’entrée gérés par la bibliothèque fstream : ces fichiers
sont utilisés pour lire des données à partir d’un fichier
II-Création de fichier en c++
Pour créer un fichier on utilise la classe ofstream en appelant le
constructeur qui a comme paramètre le nom du fichier. On peut
aussi utiliser le constructeur avec un nom de fichier et un mode
d’ouverture.
SYNTAXE :
Ofstream Nom(‘‘Nomdufichier.txt’’) ;
Ex :
Ofstream fichierEtudiant (‘‘etudiant.txt’’) ;
On peut utiliser la méthode is_open pour savoir si l’ouverture du fichier
a réussi ou pas.
Ex : if (fichierEtudiant.is_open) {
Cout >> ‘‘fichier ouvert avec succès’’ ;
}
else
{cout<< ‘‘échec d’ouverture’’ ;
}
APPLICATION :
Ecrire un programme qui crée le fichier nommé ‘‘Myfile.txt’’ .
Vérifiez si la création réussit ou pas

#include <iostream>

#include <fstream>

using namespace std;

int main () {

ofstream monfichier("Myfile.txt");

if (monfichier.is_open()) {

cout << "fichier ouvert avec succès";

else

cout << "échec d'ouverture" ;

return 0;
 #include <iostream>

#include <fstream>

using namespace std;

struct Etudiant {

int id;

string prenom;

string nom;

int age;

};

//CREATION D'UN FICHIER

int main () {

ofstream monfichier("Myfile.txt");

//cerr permet l’affichage en cas d’erreur

if (!monfichier.is_open()) {

cerr << "impossible d'ouvrir '";

return 1;

}
 III-Ecriture dans un fichier
Le principe d’écriture consiste à récupérer les données
d’une variable et les inscrire dans un fichier.

ECRITURE
RAM DISQUE

Syntaxe :
Nomfichier << variable
Ex :
Struct etudiant {
Int id ;
String prenom
int age ;
} etud ;
Ofstream monfichier (« etudiant.txt », ios::app);
monfichier<<etud.id<<” “
#include <iostream>
#include <fstream>
using namespace std;

struct etudiant {
int id;
string prenom;
string nom;
int age;
};
//CREATION D'UN FICHIER
int main () {
ofstream monfichier("Myfile.txt", ios::app); //ios::app permet
d'ouvrir un fichier en mode ajout (mode ajout)

if (!monfichier.is_open()) {
cerr << "impossible d'ouvrir '";
return 1;
}
struct etudiant etud;
cout<< "saisir id: " ;
cin>> etud.id ;
cout<<"saisir le prenom:";
cin>> etud.prenom;
cout<<"saisir le nom:";
cin>> etud.nom;
cout<<"saisir l'age:";
cin>> etud.age;
monfichier <<etud.id <<" "<<etud.prenom<< " "<<etud.nom<< " " <<etud.age <<"
" <<endl;//(méthode pour copier les informations dans 1 fichier)
monfichier.close ();
return 0;

IV-Lecture dans un fichier

La classe ifstream est utilisé pour la lecture. On utilise tout
simplement le constructeur qui a en paramètre le nom du
fichier. On utilisera la méthode getline qui prend en paramètre
le nom du fichier et une chaine de caractère pour contenir le
contenu de la ligne.
Syntaxe : ifstream nom (« nom_fichier) ;
Exemple :
Ifstream etudiantaffiche (« Myfile.txt »)
On utilise souvent la boucle while pour afficher toutes les lignes
avec la méthode getline
Ex :
#include <iostream>
#include <fstream>
using namespace std;

struct etudiant {
int id;
string prenom;
string nom;
int age;
};
//CREATION D'UN FICHIER
int main () {
 ofstream monfichier("Myfile.txt", ios::app); //ios::app permet
d'ouvrir un fichier en mode ajout (mode ajout)

if (!monfichier.is_open()) {
cerr << "impossible d'ouvrir '";
return 1;
}
struct etudiant etud;
cout<< "saisir id: " ;
cin>> etud.id ;
cout<<"saisir le prenom:";
cin>> etud.prenom;
cout<<"saisir le nom:";
cin>> etud.nom;
cout<<"saisir l'age:";
cin>> etud.age;
monfichier <<etud.id <<" "<<etud.prenom<< " "<<etud.nom<< " " <<etud.age <<"
" <<endl;//(méthode pour copier les informations dans 1 fichier)
monfichier.close ();

ifstream myfichier ("Myfile.txt");

string ligne;
while (getline(myfichier,ligne)) {
cout << ligne << endl;
}
return 0;

}
 CHAPITRE4 : LES SOUS PROGRAMMES
I-Introduction
Lorsqu’un programme est long on peut le décomposer en
plusieurs parties plus petites en donnant un nom à chacune de
ces parties et en les assemblant pour former le programme
final. C’est le principe de la programmation modulaire qui
repose sur l’écriture de sous programmes. Un sous-programme
est un petit programme réalisant un traitement particulier et
qui s’exécute à l’intérieur d’un autre programme. A part la
méthode main aucun sous-programme ne peut s’exécuter à lui
seul sans être appelé
II-PROCEDURE ET FONCTION
Un sous-programme est soit une procédure soit une fonction
1-Procédure
Une procédure est un sous-programme qui n’a pas de valeur de
retour mais elle peut renvoyer plusieurs résultats au
programme appelant
Syntaxe : void NomProcédure (type param1, type param2,…){
Traitement ;
}
 Exemple : procédure pour échanger a et b
Void echange (int a, int b) {
int c ;
c=a;
a=b;
b=c;
}
(Une variable locale n’existe qu’à l’intérieur du sous-programme )

#include<iostream>

using namespace std;

void echange(int &a , int &b ){ //& permet de transformer a et b en pointeur

int c;

c=a;

a=b;

b=c;

int main () {

int a = 10 ;

int b = 20 ;

cout << "avant echange a=" <<a << "et b =" <<b<<endl;

//appel de la procédure

echange (a,b);

cout<<"apres echange a="<<a<<"et b="<<b<< endl;

return 0;

}
2-Fonction
2-Fonction
Une fonction est un sous-programme qui retourne un et un seul
résultat au programme appelant à travers une valeur de retour.
Une fonction possède un type : c’est le type de la valeur
retournée
Syntaxe : type nomfonction (type param1, type param2,…){
Traitement ;
Return valeur ;
}
Exemple : calcul du factoriel

#include<iostream>

using namespace std ;

int factoriel (int x){

int fact=1;

int i ;

for (i=1; i<=x;i++) {

fact = fact*i;

return fact;

int main () {

int x;

cout<<"saisir un nombre:"<<endl;

cin>>x;

cout<<"le factoriel de" <<x<<" est:"<<factoriel (x);

Soit un fichier d’utilisateur. Chaque utilisateur est caractérisé
par matricule, prénom, nom, login, password, profile
TAF :
Déclarer la structure utilisateur
-un sous-programme pour remplir le fichier (2 utilisateurs ne
doivent pas avoir le même login
-Un sous-programme qui affiche la liste des utilisateurs
-Un sous programme testloginpassword qui permet de tester le
login et le password sont correct
-Un sous-programme findbyid qui recherche en fonction du
matricule
 CHAPITRE 5 : Les concepts de la programmation
orientée objet
I-Introduction
La POO est un paradigme de programmation reposant sur
les concepts d’objet. Les objets sont créés à partir des classes
par un principe appelé instanciation. Les classes sont des
modèles constitués de données et de méthodes.
La POO repose essentiellement sur l’usage des concepts tels
que class, objet, polymorphisme, encapsulation etc.
II-Concepts
1-classe
Une classe est un modèle qui définit les attributs et les
méthodes communs à tous les objets qui seront instanciés.
En fonction du langage orienté objet les syntaxes de classe
peuvent varier. Les attributs sont déclarés sous forme de
variable qui représentent les données associées à la classe. Ce
sont les caractéristiques de la classe.
Syntaxe d’une classe en c++
Class nomclass{
//déclarer les variables/attributs
//définir les méthodes
 };
a-Attributs, méthodes et visibilité
Les attributs et les méthodes d’une classe peuvent être définis
en utilisant une visibilité qui sont : public, private, protected.
--Les attributs et méthodes déclarés avec la visibilité public sont
accessibles partout.
--Les attributs et méthodes déclarés avec la visibilité private ne
sont visibles qu’à l’intérieur de la classe. En dehors de la classe
on doit passer par des accesseurs c’est-à-dire des méthodes
getter et setter
--Les attributs et méthodes déclarés avec la visibilité protected
sont visibles à tous les objets se trouvant dans le même package
ou par héritage
EX : class personne {
//déclaration de variable avec private
Faut tjrs déclarer les structures avec la visibilité private
Private :
int id;
string prenom;
string nom;
string age
b-Méthodes getter setter
//méthode getter (c’est une méthode publique de même que
setter) la méthode getter permet de renvoyer la valeur
Set permet d’affecter une valeur à une variable

public :
int getID (){
return id ;
}
String getPrenom ( ) {
Return prenom ;
}

//méthode setter
Public :
Void setId (int _id) {
Id=_id;
}
Void setprenom (string _prenom) {
prenom=_prenom ; (on met _ pour différencier)
}

//constructeur
Public :
Personne () { } //Constructeur sans paramètre
//Constructeur avec paramètres
Personne (int _id ; string prenom, string nom, int age){
id=id;
prenom=prenom;
nom=nom;
age=age;
}
//Création d’objet
Nomclasse nomobjet
Ex : personne pers ;
Nom classe monobjet (p1, p2, …) ;
Ex : Personne pers2(5, « jean », « Dione », 20)
c-Les constructeurs
Un constructeur est une méthode publique qui porte le même
nom que la classe avec ou sans paramètre qui est utilisé pour
initialiser les attributs de l’objet.
2-Encapsulation
L’encapsulation consiste à regrouper les attributs et méthodes
qui manipulent les données au sein d’une même classe. Elle
permet de cacher l’implémentation interne de la classe. Elle est
mise en œuvre souvent avec la visibilité private pour les
attributs.
3-Getter et setter
--Les méthodes getter sont utilisées dans une classe pour
permettre d’obtenir la valeur d’un attribut privé. C’est une
fonction qui retourne une valeur de l’attribut.
Ex: public:
String getPrenom() {
Return prenom;
}
--Les setters sont des méthodes qui permettent d’attribuer une
valeur à un attribut
Ex : public :
Void setPrenom(string prenom){
Prenom=prenom ;
}