Chapitre 1 :Notions de base

1.Programmation Structurée et programmation orientée objet:

Programmation Structurée

Algorithme + Données = Programme

un programme c'est une suite d'instructions qui modifient l'état du système

Un problème est décomposé en sous-problèmes, une fonction est écrite pour résoudre chaque
problème. Les fonctions s’appellent entre elles en se passant des paramètres.

Programmation Orientée Objet :

Méthodes + Données = Objet

Programmation orientée objet.Un programme est un ensemble de briques (objets)

logicielles qui interagissent entre elles.
Objets. On identifie les concepts (ou entités) du problème, ainsi que les relations entre ces
concepts. Chacun de ces concepts est ensuite représenté par les données qu’il contient et par
les traitements qu’il est capable d’effectuer.
La POO permet une modelisation plus naturelle des systemes consid´er´es.
2.Rappels sur la programmation c++:
En programmation ordinaire, un programme C++ a une structure similaire à celle du C
standard

#include<iostream>// flux des entrées/sorties

using namespace std;// espace de noms standard

déclaration de fonctions;

main()// fonction principale

{// début du programme

déclaration de variables;

instructions;

system("pause");// figer l'affichage sur l'écran

}// fin du programme

2.1.Syntaxe élémentaire en langage C++

1. Commentaires : un commentaire est un texte ignoré par le microprocesseur lors de

l'exécution. Il sert à rendre le programme source parlant.
 Deux styles de commentaire sont disponibles en C++:
 // permet de mettre en commentaire tout ce qui est après et ce, jusqu’au
prochain saut de ligne;
 /* ... */ permettent de délimiter plusieurs lignes de commentaires.

2. Mots clés : se sont des mots réservés au langage et définissent le code source. Ils
permettent de saisir le programme et ne peuvent pas être utilisés pour définir des variables.
(voir polycopié)

3. Constantes et variables :

une constante est une case mémoire qui ne peut changer de valeur pendant le déroulement
d'un programme. Elle est déclarée par le mot-clé préfixe : const.

Une variable, quant à elle, peut changer de valeur au cours de traitement. Elle est déclarée
selon son type sans aucun préfixe.

La syntaxe pour déclarer une variable en précisant son type est :

type NomDeVariable;

Les types fondamentaux : voici les différents types fondamentaux du C++ :

 Les entiers, par taille-mémoire croissante :

o short, stocké sur 2 octets ; valeurs : de −215 à 215 − 1 (−32768 à 32767),
o long, stocké sur 4 octets ; valeurs : de −231 à 231 − 1,
o int, coincide avec short ou long, selon l’installation.
On trouve parfois le mot unsigned précédant le nom d’un type entier (on parle alors
d’entier non signé ;un tel entier est toujours positif).
o unsigned short, stocké sur 2 octets ; valeurs :0 à 65535
o unsigned int,stocké sur 4 octets ; valeurs :0 à 429467295
 Les reels, par taille-mémoire croissante :
o float, stocké sur 4 octets ; précision : environ 7 chiffres,valeurs : -3.4E-
38 à 3.4E+38
o double, stocké sur 8 octets ; précision : environ 15 chiffres,valeurs : -1.7E-
308 à 1.7E+308
o long double, stocké sur 10 octets ; précision : environ 18 chiffres.valeurs : -
1.2E-4932 à 1.2E+4932

 Les caracteres: servent à représenter des caractères.,

o char , codés sur 1 octet, valeurs : -128 à 127
o unsigned char , codés sur 1 octet, valeurs : 0 à 255 ;

4. Opérateurs : une opération est une loi de composition d'un ou plusieurs variables
(opérandes) et qui renvoie une seule variable.
 20Les opérateurs arithmétiques
+, -, ×, /, %(modulo)
 Les opérateurs de comparaison
< (inférieur), <= (inférieur ou égal), == (égal),
 > (supérieur), >= (supérieur ou égal), != (différent)
 Les opérateurs logiques
&& représente l’opérateur “ET”
|| représente le “OU”
! représente le “NON”
 Les opérateurs (++) et (--) permettent respectivement d’incrémenter et décrémenter
une variable.
Pré-incrémentation « t = ++var », l’exécution est équivalente à : (var = var +
1) puis (t = var)
Post-incrémentation« t = var ++ » l’exécution est équivalente à :
(t = var) puis (var = var + 1)

Structures conditionnelles et Boucles

for(instruction_init ; condition ; instruction_suivant)

if (condition)
{
{ bloc d’instructions 1 }
Instruction_repetée ;

while (condition réalisée)

{
liste d'instructions
}
Exemple :

#include <iostream>
using namespace std;
main()
{
int somme 0,i=0;
while ( i<=10)
{
somme = somme + i;
cout<<la somme est =: <<somme<<endl;
i=i+1 ;
}
do

// Instructions de boucle répétées tant que la condition est vrai

while ( [condition] )

instruction continue et break ;

Fonctions:

1. Définition d'une fonction : une fonction est un sous-programme appelé par le

programme principal (ou programme appelant) pour réaliser une tâche élémentaire.
2. Prototype d'une fonction : c'est un protocole entre la fonction appelé et le programme
appelant. Il définit l'ordre et le type de chaque variable d'entrée ou de sortie de la
fonction.
Le prototype de la fonction se met avant la fonction appelante.

Syntaxe: type_sortie nom_fonction (type1,type2,…)

Exemple: float carre(float x)

3. Définition d’une fonction : elle reprend le prototype et précise le contenu ou le corps

(l'ensemble des instructions de la fonction).

Syntaxe: type_sortie nom_fonction (type1 var1,type2 var2,…)

{
déclaration des variables;
bloc d'instructions;
return(résultat du traitement);
}

Exemple: float carre(float x)

{
float resultat;
resultat=x*x;
return(resultat);
}

Le mot-clé return indique le résultat du traitement.

Fonction standard : float fctname (int, double)
Fonction sans argument : float fctname ()

Fonction sans valeur de retour : void fctname (int, double)

1. Le passage des paramètres :
1.1. Le passage par valeur : passage par défaut Par défaut les paramètres d'une
fonction en C++ sont passés par valeur. Cela signifie qu'à l'appel, la valeur des
paramètres effectifs est copiée dans les paramètres formels correspondants. Au
retour d'appel, la valeur des paramètres effectifs est inchangée, même si les
paramètres formels ont été modifiés par la fonction.
Exemple :
#include <iostream>
using namespace std;

int ajouteDeux(int x)
{
x+=2;
return x;
}

main()
{
int a, resultat;
cout << "a= : " ;
cin>>a;
resultat = ajouteDeux(a);

cout << "Le nombre original vaut : " << a << endl;
cout << "Le resultat vaut : " << resultat << endl;
system("pause");

}
1.2. Passage d'arguments par adresses (référence) : Pour créer un paramètre
résultat ou donnée-résultat, il faut utiliser un autre mode de passage de paramètre
: le passage par référence (appelé passage par variable dans d'autres langages).
Pour déclarer un paramètre formel qui doit être passé par référence, on le précède
du signe &. Ainsi, toute modification du paramètre formel se répercute
directement sur le paramètre effectif correspondant. Tout se passe comme si la
fonction agissait directement sur le paramètre effectif.

Syntaxe: type_sortie nom_fonction (&var1,&var2,…)

Exemple : void f(int &i)
{i=2;}
Main()
{int i;
cout<<"donnez un entire";
cin>>i;
f(i);
cout<<"Vous avez introduit: "<<i<<endl;
system("pause");}

Ce programme affiche 2 au lieu de ce qui est introduit au clavier car la fonction f a

modifié sa valeur dans la mémoire.
4. Surcharge d'une fonction :
La surdéfinition ou la surcharge d’une fonction est la définition multiple de celle-ci
avec des paramètres au nombre et au type qui diffèrent.

Un des apports les plus intéressants du C++ par rapport au C, hormis l'ajout du
concept objet, est la possibilité d'appeler plusieurs fonctions avec le même nom, pour peu que
celle-ci aient leurs arguments différents (en type et/ou en nombre).
Ce principe est appelé surcharge de fonction. Il permet de donner le même nom à des
fonctions comportant des paramètres différents et simplifie donc l'écriture de fonctions
sémantiquement similaires sur des paramètres de type différent.
En effet, une fonction est déterminée par ce que l'on appelle sa signature, c'est-à-dire :
son nom et ses paramètres. Il est ainsi possible de définir une fonction réalisant la même
opération sur des variables différentes en nombre ou en type.
Exemple:

int somme(int x,int y){return(x+y);}

float somme(float x,float y){return(x+y);}
float somme(float x,float y,float z){return(x+y+z);}
int somme(float x,int y){return((float)x+y);}

Pointeurs :

1. Définition : un pointeur est une variable destinée à contenir l'adresse (référence)

physique de la case-mémoire d'une autre variable.

Les pointeurs constituent une notion fondamentale du C++. Ils sont utilisés pour passer des
paramètres à une fonction ou pour créer des structures de données complexes comme des
tableaux de taille variable. Ils sont toutefois complexe à utiliser et une source de nombreux
bugs.

2. Déclaration : syntaxe : type *nom ;

Où : type est le type des variables pointées et nom est l'identificateur du pointeur.

Exemple : int *p ; // p est un pointeur vers un entier.

3. Manipulation :

3.1. Référencement : L’opérateur unaire & fournit l’adresse en mémoire d’une variable
donnée.

int a ; // a est une variable ordinaire de type entier

int *x ; // x est un pointeur sur un entier
x=&a ; // opérateur de référencement (x reçoit l'adresse de a)
 3.2. Déréférencement : L’opérateur unaire * fournit la valeur de la l’adresse en mémoire
d’une variable donnée.

int a=25 ; // a contient la valeur 25

int *x ; // x est un pointeur vers un entier
x=&a ; // x contient l'adresse de a
cout<<*x ; // affiche 25 (*x est le contenu de la variable dont l'adresse est contenu dans x)

3.3. Incrémentation/décrémentation : l'incrémentation – décrémentation d'un pointeur

permet l'incrémentation – décrémentation de l'adresse contenue dans celui-ci du
nombre d'octets réservé au type de donnée pointée.
int a=2,*x;
x=&a;
x++;// instruction dangereuse!

Remarques:
Il est préférable d’initialiser le pointeur avant de l’utiliser pour éviter les bugs!
L'incrémentation – décrémentation d'un pointeur est utile uniquement pour la manipulation de
tableaux.
L’incrémentation (décrémentation) exprime le fait qu’on veuille atteindre l’élément suivant
(précédent).
Le résultat n’est correct que si l’élément pointé est situé dans le même tableau.
L’addition de deux pointeurs n’a pas de sens !
La soustraction de deux pointeurs (ayant le même type) situés dans le même tableau retourne
le nombre d’éléments qui les séparent.
Un pointeur ne peut être comparé qu’à un pointeur du même type ou un pointeur NULL.
On ne doit affecter à un pointeur qu’une valeur de pointeur ayant le même type sinon on doit
s'attendre à un bug.

4. Pointeur NULL : La constante « NULL » définit la valeur d’un pointeur ne pointant

sur rien. Sa valeur est l’entier 0. Elle est utilisée pour des raisons de lisibilité et de
sécurité.

Le pointeur est détruit mais pas l'élément pointé. Si rien ne pointe plus sur lui, on peut perdre
sa trace dans la mémoire de l'ordinateur ce qui entraînerait des fuites de mémoire !