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

Dimension: px

Commencer à balayer dès la page:

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

Lionel Leboeuf
il y a 7 ans
Total affichages :

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

2 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

ils doivent seulement finir par ; Peuvent être groupés en blocs avec { Fonctions Groupent les instructions (déclarations et

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

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

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 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 = ; pi = 5.18; 4

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

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 5

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,.

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

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

append( Christie ); // appel de fonction append // définit pour le type std::string... nom a valeur Agatha std::string::size_type idx = nom.

8 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

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

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

a, float b) { return a+b; // La fonction main int main() { float x = 5.

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

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); ;

11 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

12 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

13 ... 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

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

int*, float* La valeur du pointeur = l'adresse de l'objet pointé int i = 1; int* p =

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

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

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

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;

Documents pareils

IN 102 - Cours 1. 1 Informatique, calculateurs. 2 Un premier programme en C

IN 102 - Cours 1. 1 Informatique, calculateurs. 2 Un premier programme en C IN 102 - Cours 1 Qu on le veuille ou non, les systèmes informatisés sont désormais omniprésents. Même si ne vous destinez pas à l informatique, vous avez de très grandes chances d y être confrontés en