Algorithme et

programmation
Algorithme
• L’algorithme décrit, de façon non ambiguë, l’ordonnancement des
actions à effectuer dans le temps pour spécifier une fonctionnalité à
traiter de façon automatique dans le but d’obtenir un résultat.

• La conception d’algorithme est une tâche difficile qui nécessite de la

méthode et de la rigueur, ainsi que de la réflexion et un peu
d’intuition
LANGAGES DE PROGRAMMATION
• Chaque ordinateur possède un langage qui lui est propre, appelé
langage machine
• Le langage d’assemblage est un codage alphanumérique du langage
machine. Il est plus lisible que le langage machine. L’exécution d’un
programme écrit en langage d’assemblage nécessite sa traduction
préalable en langage machine par un programme spécial,
l’assembleur
• un programme écrit dans un langage de haut niveau nécessite sa
traduction préalable en langage machine à l’aide d’un programme
spécial, le compilateur
LANGAGES DE PROGRAMMATION
• Il existe de nombreuses méthodes de programmation. Parmi elles,
celles de programmation procédurale et orientée objet sont très
utilisées.
• La programmation procédurale avec laquelle la méthode de
construction des programmes commence par structurer les actions
en premier. Le choix de la structuration des objets vient après.
• La programmation orientée objet structure les programmes d’abord
autour des objets. Les choix de structuration des actions sont fixés
par la suite
L’E.D.I. (Environnement de Développement
Intégré)
• Cf Wikipedia : EDI
• Un EDI comporte un éditeur de texte destiné à la programmation, des
fonctions qui permettent, par pression sur un bouton, de démarrer le
compilateur ou l'éditeur de liens ainsi qu'un débogueur en ligne, qui permet
d'exécuter ligne par ligne le programme en cours de construction.
• Logiciels :
• Visual Studio
• CodeBlocks
Mon premier algorithme
Début
Réel x, carreDeX

afficher "saisir x : "

lire x
carreDeX = x * x //

afficher "le carre de " x " est " carreDeX

Fin
Mon premier programme procédural en C++
#include <iostream>
using namespace std;

int main(void) // ceci est mon premier programme

{
float x, carreDeX;

cout << "saisir x : " << endl;

cin >> x;

carreDeX = x * x;

cout << "Le carre de " << x << " est " << carreDeX << endl;

return 0;
}
Type de données
• Réel : float, double
• Entier : int, long, unsigned int, unsigned long
• Booléen : bool
• Constante : const int pi = 3.14 ou #define pi 3.14
• Caractère : char
• Chaine de caractère : string (inclure la bibliothèque string)
les opérateurs de calcul et d'affectation
+ : addition
- : soustraction
* : multiplication
/ : division réelle (5/3 donne 1.666...)
% : reste de la division (5%3 donne 2)
= : affectation (ATTENTION, NE PAS SE TROMPER ENTRE = ET ==)
les opérateurs de comparaison
== : égalité (ATTENTION, NE PAS SE TROMPER ENTRE = ET ==)
< : inférieur
> : supérieur
<= : inférieur ou égal
>= : supérieur ou égal
!= : différent
les opérateurs logiques
• OU : ||
• ET : &&
• NON : !( condition(s) )
La structure conditionnelle
SI-Alors-Sinon-FinSi
Si (condition(s)) if (condition(s))
Alors {
instruction1 instruction1
... ...
Sinon }
instruction1 else
... {
FinSi instruction1
...
}
Exemple d’utilisation de la structure
 la structure conditionnelle
Selon variable
Selon-Cas-Cas sinon-FinSelon
Switch (choix)
Cas valeur_1 {
instruction1 Case 1: // ou Case ‘c': ou Case ‘+'
... instruction1
Cas valeur_2 ...
instruction1 break;
...
... Case 2: // ou Case ‘d': ou Case ‘-'
... instruction1
Cas valeur_n ...
instruction1 break;
...
Cas Sinon ...
instruction1 ...
...
FinSelon default:
instruction1
...
break;
}
Exemple d’utilisation de la structure
 La structure répétitive
Pour-Allant de-à-Par pas de-FinPour
Pour i Allant de debut à fin Par pas de x
instruction1
... for ( i=debut; i<=fin; i=i+pas )
FinPour {
instruction1
...
}
Exemple d’utilisation de la structure
la structure répétitive Faire-TantQue
Faire do
instruction1 {
... instruction1
TantQue (condition(s)) ...
} while (condition(s));
// ne pas oublier le point-virgule!!!
Exemple d’utilisation de la structure
la structure répétitive TantQue-Faire
TantQue (condition(s)) while (condition(s))
instruction1 {
... instruction1
FinTantQue ...
}
Exemple d’utilisation de la structure
Les tableaux à une dimension
• Déclaration d’un tableau de taille éléments :
• Entier tab[taille] int tab[taille]
• Réel tab[taille] float tab[taille]
• Charactère tab[taille] char tab[taille]
• Les éléments d’un tableau sont accessible de 0 à taille-1
• tab[0] est le premier élément du tableau
• tab[taille-1] est le dernier élément du tableau
Exemple d’utilisation
d’un tableau

• On ne peut pas recopier un

tableau en écrivant : tab2 = tab1
• Pour recopier un tableau tab1
dans un autre tableau tab2, il faut
effectuer l’affectation pour chacun
des éléments du tableau
Les tableaux de caractères
• Une chaine de caractères peut être un tableau de caractères se
terminant par le caractère spécial ’\0’ qui a 0 pour code ASCII.
• Ce caractère ‘\0’ sert à repérer la fin de la chaine de caractères, cela
est utile lorsque l’on ne connait pas le nombre de caractères de la
chaine.
• le compilateur complète toute chaîne de caractères avec un caractère
nul : ’\0’.
• Il faut donc que le tableau ait au moins un élément de plus que le
nombre de caractères de la chaîne littérale.
Exemple d’utilisation d’un
tableau de caractères
Les fonctions
• Lorsqu’un programme comprend de nombreuses lignes de codes, il
est difficile, voire impossible de mettre toutes les instructions les unes
à la suite des autres dans le programme principal : le programme
serait illisible, il contiendrait trop de variables.
• Comme dans la plupart des langages, on peut en C++ découper un
programme en plusieurs fonctions. Une seule de ces fonctions existe
obligatoirement : c’est la fonction principale appelée main. Cette
fonction principale peut, éventuellement, appeler une ou plusieurs
fonctions. De même, chaque fonction peut appeler d’autres fonctions
ou s’appeler elle-même (dans ce dernier cas, on dit que la fonction
est récursive).
Définition, déclaration et appel d’une fonction
Exemple d’utilisation
d’une fonction
Transmission des paramètres à une fonction
• Les paramètres d’une fonction sont traités de la même manière que
les variables locales.
• Les variables sont les variables déclarées dans une fonction. Lors de
l’appel de la fonction, celle-ci travaille alors uniquement sur cette
copie.
• Cette copie disparaît lors du retour au programme appelant. Cela
implique en particulier que, si la fonction modifie la valeur d’un de
ses paramètres, seule la copie sera modifiée.
• La variable du programme appelant, elle, ne sera pas modifiée.
• On dit que les paramètres d’une fonction sont transmis par valeurs
Exemple de
ce qu’il
ne faut
pas faire
Exemple de
retour avec
une fonction
 Les structures
• Une structure est une suite finie de type différent.
• Chaque élément de la structure, appelé membre ou champ, est désigné par un identificateur
• On accède aux différents membres d’une structure grâce à l’opérateur point (“.”)
• Pour éviter la répétition du mot struct lors de la déclaration des variables de type struct
modele, on peut définir un nouveau type grâce au mot réservé typedef
Avant le main() : Avant le main() :
struct modele typedef struct
{ {
type-1 membre-1; type-1 membre-1;
type-2 membre-2; type-2 membre-2;
... …
type-n membre-n; type-n membre-n;
};
Dans le main() : Dans le main() :
struct modele monModele; modele monModele;
Les pointeurs
• Tout objet manipulé dans un programme est stockée quelque part en
mémoire centrale.
• Cette mémoire est constituée d’octets qui sont identifiés de manière
univoque par un numéro qu’on appelle adresse.
• Pour retrouver un objet, il suffit donc de connaître l’adresse de l’octet
ou il est stocké (ou, s’il s’agit d’un objet qui recouvre plusieurs octets
contigus, l’adresse du premier de ces octets
Les pointeurs
sur les tableaux
Les tableaux de
type structure
 La gestion de la mémoire pour les types
• Tous les programmes que nous avons écrits précédemment, utilisaient des
types ou tableaux avec une taille définie lors de la déclaration des variables.
• Pour les tableaux, la taille était fixée arbitrairement.
• Il est tout à fait possible que nous ne sachions pas combien de valeurs va
contenir un tableaux lors de sa déclaration.
• Il va falloir déclarer un pointeur sur le type désiré et allouer dynamiquement la
mémoire lors de l’exécution du programme.
• Cette technique permet de créer des tableaux dont la taille mémoire est
variable en fonction des besoins et de libérer cette mémoire après utilisation.
• On obtient ainsi des programmes plus performants en termes de
consommation de mémoire