1 Programmation en C++ C++ de base ● Programme C++ ● Variables, objets, types ● Fonctions ● Namespace ● Tests ● Boucles ● Pointeurs, références.

Présentation au sujet: "1 Programmation en C++ C++ de base ● Programme C++ ● Variables, objets, types ● Fonctions ● Namespace ● Tests ● Boucles ● Pointeurs, références."— Transcription de la présentation:

1 1 Programmation en C++ C++ de base ● Programme C++ ● Variables, objets, types ● Fonctions ● Namespace ● Tests ● Boucles ● Pointeurs, références

2 2 Programme C++ ● Le programme C++ le plus simple ● 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 int main() { return 0; }... mais il ne fait rien

3 3 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 ● La variable i est de type int (un nombre entier) i: int 1 i: int 1 int i = 1;

4 4 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 ● Nous pouvons également déclarer une variable et lui donner une valeur initiale – 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; int i; Déclaration int i(1); int i = 1; Déclaration + initialisation ou

5 5 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

6 6 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; // on donne la valeur de la variable i à la variable k // en utilisant l'opérateur = (« assignment ») i++; // 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 3... j a valeur 5;... k n'a pas valeur !!! En ce moment... i a valeur 4... j a valeur 5... k a valeur 9

7 7 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 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 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 “Agatha”... nom a valeur “AgathaChristie”... nom a valeur “Agatha Christie”

8 8 Fonctions float Sum(float a, float b); ● 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) { /// 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

9 9... 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; }

10 10 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; } }; 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; } namespace B { float Sum(float a, float b) { return (a+b)*(a+b); } };

11 11 Tests if ( expression ) { statement;... } if ( expression ) { statement;... } else { statement;... } if ( x < 0 ) { abs = -x; sign = -1; } if ( x < 0 ) { abs = -x; sign = -1; } else { abs = x; signe = 1; } ● Syntaxe: ● Exemple: – 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 if ( x < 0 ) abs = -x; if ( x < 0 ) abs = -x; else abs = x;

12 12 Boucles... while ( expression ) {... } int i = 0; sum = 0; while ( i < 10 ) { sum += i++; } int sum = 0; for ( int i = 0; i < 10; i++ ) { sum += i; } ● Syntaxe: ● Exemple: – On préfère while quand il est possible que le bloc ne soit pas exécuté – On préfère do si le bloc doit toujours être exécuté (au moins une fois) do {... } while ( expression ); for ( init-stmt; cont-expr; incr-expr ) {... } int i = 0; int sum = 0; do { sum += i++; } while ( i < 10 );

13 13... Boucles for ( int i = 0; i < 10; i++ ) { if ( i == j ) continue; if ( i > k ) break; // faire quelque chose } ● break – permet de termin er la boucle plus t ô t ● continue – permet de sauter une itération – Mais attention il ne faut pas en abuser

14 14 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é i: int 1 p: int* int i = 1; int* p = &i; Opérateur d'adresse ● L'accès à l'objet par son pointeur: *p = 5; Opérateur d'adressage indirect i: int 5 p: int*

15 15 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& i: ir: int 1 int i = 1; int& ir = i; ● 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

16 16 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; – Logiciels: !x; x && y; x || y – Bitwise: ~i; i & j; i ^ j; i | j; 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