Programmation en C++ C++ de base Programme C++ Variables, objets, types Fonctions Namespace Tests Boucles Pointeurs, références 1
Programme C++ Le programme C++ le plus simple int main() { return 0;... mais il ne fait rien Un programme C++ se compose de Instructions («Statement») Déclarations, expressions De forme libre, ils doivent seulement finir par ; Peuvent être groupés en blocs avec { Fonctions Groupent les instructions (déclarations et expressions) dans une unité nommée Chaque programme C++ doit contenir une fonction main C'est cette fonction qui est exécutée par le programme Elle doit retourner un nombre entier 2
Variables Le C++ est un langage de programmation orientée objet: dans un programme C++, nous allons créer divers objets et les laisser effectuer diverses opérations L'objet créé dans un logiciel est appelé variable Quand le programmeur écrit: Le logiciel crée: La variable a un nom (i) Le nom est tout choisi par un programmeur Elle occupe la mémoire - le contenu actuel de la mémoire est sa valeur La variable i a la valeur 1 La taille de la mémoire allouée et les opérations que nous pouvons faire avec une variable sont définies par son type int i = 1; i: int 1 La variable i est de type int (un nombre entier) 3
Déclaration des variables Déclaration de variable = l'instruction qui a créé la variable Nous pouvons déclarer une variable sans lui donner une valeur initiale, sa valeur est indéfinie int i; Déclaration Nous pouvons également déclarer une variable et lui donner une valeur initiale int i = 1; ou int i(1); Déclaration + initialisation Les deux moyens d'initialisation sont équivalents, on préfère généralement le premier Nous préférons déclarer la variable juste avant son emploi La déclaration const de variable - crée une variable qui ne peut pas être modifiée plus tard const float pi = 3.141592; pi = 5.18; 4
Les types de variables Le type de variable Définit la manière dont l'objet (sa configuration binaire en mémoire) peut être manipulé Il doit être connu lors de la déclaration d'une variable Types fondamentaux Nombres: entier (int), nombre à virgule flottante (float, double) Caractères: char Booléennes: bool - peuvent avoir seulement une de ces deux valeurs : true, false Peuvent être manipulé par les opérateurs: Unaires ou binaire Par exemple. x++, x + y, x = y,... Types d'objets Définis dans le C++ Standard Library et par le programmeur Ont défini leurs propres fonctions, peuvent également avoir défini leur propres opérateurs 5
Manipulation des variables (1) Un exemple de programme C++ avec utilisation de types fondamentaux et leur opérateurs: int main() { int i = 3; // déclaration de variable avec initialisation int j = 5; // déclaration de variable avec initialisation int k; // déclaration de variable sans initialisation k = i; i++; En ce moment... i a valeur 3... j a valeur 5;... k n'a pas valeur!!! // on donne la valeur de la variable i à la variable k // en utilisant l'opérateur = («assignment») // on incrémente la valeur de la variable i k = i + j; // utilisation de l'opérateur binaire + sur les variables // i,j suivie par utilisation de l'opérateur = sur k... return 0; En ce moment... i a valeur 4... j a valeur 5... k a valeur 9 6
Manipulation des variables (2) Un exemple de programme C++ avec utilisation de variables de type objet (std::string) défini dans C++ Standard Library #include <string> int main() { std::string nom = Agatha ; // déclaration de variable // avec initialisation nom.append( Christie ); // appel de fonction append // définit pour le type std::string... nom a valeur Agatha std::string::size_type idx = nom.find( Christie ); nom.insert(idx, ); // appel de fonctions find, insert // définit pour le type std::string... return 0;... nom a valeur AgathaChristie... nom a valeur Agatha Christie 7
Fonctions Déclaration = spécification de l'identificateur et du type de fonction Une promesse (un contrat) que la fonction doit tenir (remplir) Définition = implantation La spécification qui remplit le contrat float Sum(float a, float b); float Sum(float a, float b) { /// Additioner les numéros a, b donnés return a+b; La déclaration et la définition d'une même fonction se trouvent souvent dans des fichiers différents En C++, on préfère des fonctions associées avec des classes dont nous allons parler plus tard 8
... Fonctions Un exemple de programme C++ avec utilisation de fonction: // Définition de fonction pour additionner les numéros a, b donnés float Sum(float a, float b) { return a+b; // La fonction main int main() { float x = 5.0; float y = 0.5; // appel de fonction sur les variables x, y float sum = Sum(x, y); return 0; 9
Namespace L espace de nommage (namespace) permet d'utiliser des noms simples dans de grands programmes (souvent composés de plusieurs bibliothèques) Les définitions de variables, fonctions, types (classes) peuvent se trouver sous un «namespace» Deux fonctions différentes peuvent avoir le même nom si elles se trouvent dans des namespaces différents namespace A { float Sum(float a, float b) { return a+b; ; namespace B { float Sum(float a, float b) { return (a+b)*(a+b); ; int main() { float x = 5.0; float y = 0.5; // appel de fonction du namespace A float sum1 = A::Sum(x, y); // appel de fonction du namespace B float sum2 = B::Sum(x, y); return 0; 10
Tests Syntaxe: Exemple: if ( expression ) { statement;... if ( x < 0 ) { abs = -x; sign = -1; if ( x < 0 ) abs = -x; if ( expression ) { statement;... else { statement;... if ( x < 0 ) { abs = -x; sign = -1; else { abs = x; signe = 1; if ( x < 0 ) abs = -x; else abs = x; Il est bien de choisir un style de découpage et de l'utiliser constamment Les { ne sont pas nécessaires si l'expression ne dépasse pas une ligne 11
Boucles... Syntaxe: Exemple: while ( expression ) {... int i = 0; sum = 0; while ( i < 10 ) { sum += i++; On préfère while quand il est possible que le bloc ne soit pas exécuté do {... while ( expression ); int i = 0; int sum = 0; do { sum += i++; while ( i < 10 ); On préfère do si le bloc doit toujours être exécuté (au moins une fois) for ( init-stmt; cont-expr; increxpr ) {... int sum = 0; for ( int i = 0; i < 10; i++ ) { sum += i; 12
... Boucles break permet de terminer la boucle plus tôt continue permet de sauter une itération for ( int i = 0; i < 10; i++ ) { if ( i == j ) continue; if ( i > k ) break; // faire quelque chose Mais attention il ne faut pas en abuser 13
Pointeurs Pointeur = un objet qui réfère à un autre objet Le type du pointeur formé par le type d'objet pointé et * Ex. int*, float* La valeur du pointeur = l'adresse de l'objet pointé int i = 1; int* p = &i; p: int* i: int 1 Opérateur d'adresse L'accès à l'objet par son pointeur: *p = 5; p: int* i: int 5 Opérateur d'adressage indirect 14
Références Référence = un nom d'emprunt (un alias) pour un objet existant La déclaration de référence: le type d'objet plus & Ex. int&, float& int i = 1; int& ir = i; i: ir: int 1 Les différences entre référence et pointeur: Le pointeur pointe sur un objet, on peut le changer pour qu'il pointe sur un autre objet, il occupe la mémoire (comme le pointeur est aussi un objet lui-même) La référence agit comme un autre nom de l'objet, elle ne peut pas être changée pour pointer sur un autre objet, elle n'occupe pas de mémoire int* p; int* p = 0; int& ir; int& ir = 0; On ne peut pas déclarer la référence sans l'initialiser; la référence ne peut pas être initialisée à 0 15
Types et opérations fondamentales Opérateurs fournis en C++ pour les types prédéfinis Unaire ou binaire Arithmétiques: x ++; ++ x; x --; -- x; + x; - x; x * y; x / y; x % y; x + y; x - y; Relationnels: x < y; x <= y; x > y; x >= y; x == y; x!= y; Logiciels:!x; x && y; x y Bitwise: ~i; i & j; i ^ j; i j; i << n; i >> j; Assignement: = ; +=; -=; *=; /=; %=; >>=; <<=; ^=; = Pointeurs: *p; &x; new T; new T[n]; delete p; delete [] p Conversion de type Si l'opérateur binaire est appelé sur des variables de types différents, la conversion de type automatique est effectuée si possible int i = 1; float x = 15.6; float sum = x + i; Conversion de type int en float 16