C++ BY AURÉLIEN MODULO MARION

PLAN DES TROIS PRÉSENTATIONS C++ avancé C++ orienté objet Bases de C++

BASES DE C++ Introduction Les outils nécessaires Les variables Les structures de contrôle Les fonctions Les pointeurs Exercices

INTRODUCTION C++ : langage de programmation impératif, orienté objet et générique Auteur : Bjarne Stroustrup Langage libre avec de multiples implémentations sur quasiment tous les systèmes

INTRODUCTION : UTILISATION Langage relativement haut niveau tout en étant extrêmement rapide. Utilisé dans tout ce qui nécessite de hautes performances : Finance Jeux Systèmes embarqués Système d’exploitation Télécoms...

LES OUTILS NÉCESSAIRES Le strict nécessaire : un compilateur et un éditeur de texte Conseillé : un IDE Ex : Code::Blocks (Linux, Mac, Windows), Visual Studio (Windows), Xcode (Mac) Disponibles sur : logiciels.via.ecp.fr

LES VARIABLES  une partie de la mémoire utilisée pour stocker une valeur. En C++, elles ont un type explicite. Déclaration : type variable; Attention : Pas de valeur par défaut pour les variables. Chaque instruction se termine par un ;

LES VARIABLES : TYPES Les différents types possibles sont : Caractères : char Chaines de caractère : string Entiers : short int long (unsigned) Nombres à virgules : float double Booléens : bool (pas de type) : void Tous ceux que vous créez vous-même

LES VARIABLES : ARITHMÉTIQUE // assignation int a = 5; // opérations de base // +, -, *, /, % int c = a % 3; // assignation et opération // +=, -=, *=, /=, %= c *= 3; // incrémenter ++c; //décrémenter --c; NomAdresseValeur a0xF5E45 c0x12B36 NomAdresseValeur a0xF5E45 c0x12B32 NomAdresseValeur a0xF5E45 c0x12B36

LES VARIABLES : DIVISION Attention : division entière pour les types entiers ( int ) et division réelle pour les types à virgule ( double ). double a = 5; double b = a/2; // 2.5 int i = 5; int j = i/2; // 2 // MAIS int k = a/2; // 2 NomAdresseValeur a0xF5E45 b0xC4892,5 i0x12512 j0xBB252 k0x12B32

LES VARIABLES : BOOLÉENS bool a = true; bool b = false; a && b; // false a || b; // true ! a; // false Attention : && (resp. ||) sont court-circuitants. Si le premier terme est false (resp. true ), le deuxième terme n’est pas évalué.

LES VARIABLES : CONDITIONS int a = 5; a > 5; // false a <= 5; // true a == 4; // false a != 4; // true Attention : lors de la comparaison de variables qui n’ont pas le même type lors de la comparaison de double avec == de ne pas confondre assignation ( = ) et test d’égalité ( == )

LES VARIABLES : AFFICHAGE Il faut écrire #include en haut du fichier de code. Ensuite, on peut utiliser : int a = 5; std::cout << "a = " << a << std::endl; // affichera : a = 5 Ceci fonctionne pour tous les types vus jusqu’à présent.

LES VARIABLES : SAISIE Il faut écrire #include en haut du fichier de code. Ensuite, on peut utiliser : int a; std::cin >> a; // demandera un entier à l’utilisateur Ceci fonctionne pour les types numériques vus jusqu’à présent.

LES STRUCTURES DE CONTRÔLE

LES STRUCTURES DE CONTRÔLE : IF if( condition ) { // code } else if( condition2 ) { // code } else { // code } if( condition ) // une seule instruction Comme il n’y a pas de else, rien ne se produira si la condition est false.

LES STRUCTURES DE CONTRÔLE : WHILE while( condition ) { // code } while( true ) // une seule instruction Attention aux boucles infinies.

LES STRUCTURES DE CONTRÔLE : FOR for( init; condition; increment ) { // code } for( int i = 0; i < 5; ++i ) // une seule instruction

LES FONCTIONS Permettent de créer des blocs de code réutilisables au comportement paramétrable. typeRetour nom(type1 param1, type2 param2) { // code return variable; } Autant de paramètres qu’on veut Une seule variable peut-être renvoyée. Si pas de variable renvoyée, utiliser : void

LES FONCTIONS : EXEMPLES double pi() { return ; } void afficherNombre(int num) { std::cout << num << std::endl; } int addition(int a, int b) { return a + b; }

LES FONCTIONS : UTILISATION double a = pi(); if(a > addition(2,1)) afficherNombre(a); On peut les utiliser partout où on pourrait utiliser la variable qu’elles renvoient. Il suffit d’écrire son nom et de lui fournir ses paramètres si nécessaire.

LES FONCTIONS : DÉCLARATION Une fonction ne peut appeler que des fonctions déclarées au dessus d’elle. Pour éviter cela, on pré- déclare toutes nos fonctions : double pi(); void afficherNombre(int num); int addition(int a, int b); Ces pré-déclarations sont écrites dans les fichiers.h. Ils peuvent ensuite être inclus partout où on veut utiliser les fonctions avec : # include "monFichier.h"

PREMIER EXEMPLE DE PROGRAMME // dans le fichier main.cpp #include int main() { for(int i = 1; i < 100; i++) if( i%2 ) std::cout << i << std::endl; return 0; } Fonction main : point d’entrée de tout programme en C++ Renvoie un code d’erreur (0 si pas d’erreur).

LA COMPILATION

LES POINTEURS  une variable qui contient l’adresse mémoire d’une autre variable int a = 5: int b = 0; int* ptr = &a; *ptr = 6; // a = 6 NomAdresseValeur a0xF5E45 b0x93B60 ptr0x45870xF5E4 NomAdresseValeur a0xF5E46 b0x93B60 ptr0x45870xF5E4

LES POINTEURS // grosse erreur! ptr = 6; // pointe maintenant vers b ptr = &b; // b = 7 *ptr = 7; NomAdresseValeur a0xF5E45 b0x93B60 ptr0x45876 NomAdresseValeur a0xF5E46 b0x93B67 ptr0x45870x93B6

LES POINTEURS : REMARQUES déclare un pointeur sur type type* déclare un pointeur sur type* type** permet de récupérer l’adresse de la variable var &var permet d’accéder à la variable pointée par ptr (= déréférencer le pointeur ptr ) *ptr accéder à une adresse qui n’appartient pas au programme erreur de segmentation

LES POINTEURS : TABLEAUX int tab[3] = { 0, 2, 5}; tab[0] = 2; // tab[5] = 15; // erreur! Ensemble d’éléments du même type Numérotés de 0 à (taille - 1). La taille du tableau doit être connue à la compilation. NomAdresseValeur tab0xF5E40 0xF5E52 0xF5E65

LES POINTEURS : ALLOCATION DYNAMIQUE int* a = new int(5); // a initialisé à 5 // code qui utilise le pointeur a delete a; a = nullptr; int* tab = new int[n]; // code qui utilise le tableau tab delete[] tab; tab = nullptr;

LES RÉFÉRENCES  une variable qui se comporte comme un alias pour une autre variable (nom supplémentaire pour la variable) int a = 5: int b = 0; int& ref = a; ref = 6; // a = 6 ref = b; // a = 0 // ref est toujours attaché à a NomAdresseValeur ref = a0xF5E45 b0x93B60

LES FONCTIONS : PASSAGE PAR VALEUR void doubler(int a) { a *= 2; } int main() { int a = 5; doubler(a); // a = 5 return 0; }

LES FONCTIONS : PASSAGE PAR POINTEUR void doubler(int* a) { *a *= 2; } int main() { int a = 5; doubler(&a); // a = 10 return 0; }

LES FONCTIONS : PASSAGE PAR RÉFÉRENCE void doubler(int& a) { a *= 2; } int main() { int a = 5; doubler(a); // a = 10 return 0; }

ELÉMENTS NON MENTIONNÉS Structures de contrôle : switch, do while.Surcharge de fonctionsParamètres optionnels d’une fonctionParamètres de la fonction mainLe mot-clé constLes macros : define

DES QUESTIONS ? UNE ADRESSE :

EXERCICES 1. Installer un IDE C Ecrire un programme qui affiche et somme les 150 premiers nombres multiples de Ecrire un programme qui demande 5 nombres à l’utilisateur, les stocke dans un tableau, les trie et les affiche. 4. Idem que l’exercice 3, en demandant à l’utilisateur un nombre n, et ensuite, en demandant n nombres au lieu de 5.