Ce document présente les bases du langage C++, incluant l'entrée et sortie de données, le type booléen, les références, et les fonctions. Il aborde également des concepts avancés tels que la gestion dynamique de la mémoire et les fonctions avec paramètres par défaut ou surcharge. La syntaxe et des exemples sont fournis pour illustrer chaque concept abordé.

1. Chap1 : quelques éléments de
base du C++
M. DIENG Abdoulaye
Introduction au C++

2. Sommaire
1. Entrée et sortie de base
2. Type booléen
3. Référence
4. Fonctions
5. Gestion dynamique de la mémoire

3. Entrée et sortie de base
présentation
• Permettent l’interactivité entre le programme et l’utilisateur
• cin, le flux standard d'entrée associé au clavier
• cout, le flux standard de sortie associé à l’écran
• Ces flux s’utilisent grâce à ces deux lignes :
#include <iostream>
using namespace std;
• L’écriture sur cout se fait à l'aide de l’opérateur d'injection <<.
• La lecture sur cin se fait à l'aide de l’opérateur d'extraction >>.
• Syntaxe
cout << "chaine de caractères" << var ou expr << …
cin >> variable1 >> variable2 >> …

4. Entrée et sortie de base
exemple & application
• Exemple :
#include<iostream>
using namespace std;
int main(){
cout << "Entrez un entier : ";
int i(0);
cin >> i;
cout << "Le carre de " << i
<< " est "<< i*i<< endl;
return 0;
}

5. Le type booléen
• Type : bool
• Valeur : true ou false
• L'opérateur logique (!) peut être utilisé pour changer une valeur
booléenne de true à false, ou de false à true
• Les valeurs booléennes sont évaluées à 1 (true) ou 0 (false)
• L’entier nul vaut false et tout entier non nul vaut true
• Exemple :
bool estDemarree=false;
if (!estDemarree)
cout << "La voiture est eteinte, l'aiguille est a "
<< estDemarree << endl;
else
cout << "La voiture est demarree, l'aiguille est a "
<< estDemarree << endl;

6. Référence
• Une référence est un alias d'une variable.
• Une référence doit être initialisée à sa déclaration.
• Syntaxe de déclaration :
<type> & <identificateur>=<variable>
• Une fois initialisée, une référence ne peut plus être modifiée.
• Exemple :
int unEntier=3;
int & aliasDunEntier=unEntier;
aliasDunEntier=13;// unEntier vaut maintenant 13

7. Les fonctions
passage par référence (présentation)
• Faire suivre le type de l’argument formel d’un & :
<typeRslt> <nomFonction>( typeArg& nomArg, …)
• Pas de copie de l’argument effectif => + de performance.
• Possibilité de modification de l’argument effectif.
• Pour empêcher la modification de l’argument effectif, faire
précéder le type de l’argument formel de const:
<typeRslt> <nomFonction>( const typeArg& nomArg, …)

8. Les fonctions
paramètre par défaut
• Permet de simplifier les appels de fonctions comportant un
(ou des) paramètre(s) qui varie(nt) peu.
• Exemple :
– Déclaration :
float f (char, int=10, char * ="Tout");
– Appels :
f(c,t,"rien")
f(c,t) // <=> f(c,t,"Tout")
f(c) // <=> f(c,10,"Tout")
f() // ERREUR
• Les paramètres par défaut doivent être les derniers de la liste.
float f (char='a', int, char * ="Tout"); // erreur

9. Les fonctions
surcharge
• La surcharge consiste à créer des fonctions de même nom
avec des paramètres différents (en nombre et/ou en type).
• Le compilateur détermine la fonction appelée en se basant
sur le type et/ou le nombre des arguments effectifs.
• Exemple :
float max (float,float);
float max (float,float,float);
float max (int,float []);
void main(){
float x,y,z;
float tab[]={1.2, 2.3, 3.4, 4.5};
x=max(2.5,3.14);
y=max(2.5,3.14,4.6);
z=max(2,tab);
}
• NB : le type de retour n’intervient pas
float max (int,float);
double max (int,float); // erreur

10. Les fonctions
inline
• Le mot inline permet de définir une fonction qui sera
remplacée par son code à chaque appel.
• L'avantage est que l'exécution du programme sera plus rapide
• À n’utiliser que pour des fonctions très courtes
• Le compilateur doit disposer de la définition de la fonction en
ligne au moment de traiter un appel à celle-ci.
• Exemple :
inline int minimum(int a,int b){
return (a<b)?a:b;
}
int main(){
cout << "La plus petite valeur "
<< "entre 2 et 3 est : " << minimum(2,3);
return 0;
}

11. Gestion dynamique de la mémoire
• La gestion dynamique de la mémoire consiste à allouer et
libérer des emplacements mémoire au moment de l’exécution.
• new <type>;
alloue l’emplacement pour un seul élément du type indiqué.
• new <type>[<n>];
alloue l’emplacement pour n éléments du type indiqué.
• Utiliser (nothrow) juste après new permet de gérer l’échec (new
retourne NULL) de la requête d’allocation.
• delete <pointeur>; ou delete [] <pointeur>;
libère un bloc mémoire précédemment alloué via new.