[PDF] Cours Programmer en C : apprendre les principaux savoir-faire du langage | Cours c++

(1)

Faculté des Sciences de Monastir

Département des Sciences de l'Informatique

Notes de cours

Programmation Orientée Objet

(

C++

)

Par Karim Kalti

(2)

SOMMAIRE

Partie I :

- Les bases du langage (règles d'écriture, types, variables, opérateurs, structures de contrôle, …) - Les entrées /sorties en C++.

- Les tableaux.

- Les pointeurs et les références. - La gestion dynamique de la mémoire. - Les fonctions.

- Les chaînes de caractères

- Les structures et les énumérations.

Partie II :

- Introduction à la programmation orientée objet.

- Les classes (attributs, méthodes, droits d'accès, instanciation,...) - Constructeurs et destructeur.

- Espaces de noms.

- Membres statiques et membres constants. - Fonctions amies.

- Héritage et polymorphisme. - La surcharge des opérateurs. - Les modèles.

- La gestion des exceptions.

Annexe :

(3)

Les règles d’écriture Programmation orientée objet (C++) _________________________________________________________________________________________________________________

Les règles d'écriture

Premier programme #include <iosrteam.h> void main() { cout<<"bonjour"; }

• Ce programme affiche le mot Bonjour à l'écran. Cet affichage est réalisé à travers l'opérateur d'extraction appliqué à l'objet cout. cout est un objet défini dans la bibliothèque iostream.h. Cette bibliothèque doit être incluse dans le programme.

• En général les déclarations des fonctions standards du langage C++ qui sont susceptibles d'apparaître dans le programme se trouvent dans des fichiers d'entête (header) ayant l'extension .h. Ces fichiers doivent être inclus au début de chaque programme avec la directive du préprocesseur include.

• La fonction main est la fonction principale du programme. C'est elle qui contient le corps du programme. • Les accolades jouent le rôle de "begin" et "end" du Pascal. Elles indiquent le début et la fin d'un bloc de code.

Remarque :

Ce petit programme donne une première idée sur la structure d'un programme C++. D'autres éléments du langage peuvent encore prendre place. Leurs définitions ainsi que leur emplacements seront décrits dans les parties suivantes du cours.

Structure d'un programme C++

D'une manière générale et d'un point de vue structurel, un programme C++ se décompose en deux grandes parties :

• Les déclarations : qui comprennent :

o Les directives de compilation pour l'inclusion des fichiers d'entêtes.

o Les déclarations des données ou des fonctions partagées avec d'autres fichiers. o Les déclarations des types propres au fichier.

o Les déclarations des données globales du fichier.

• Les définitions : il s'agit des définitions des fonctions du fichier et des classes.

Les mots clés

Les mots clés sont réservés par le langage à un usage bien défini et ne peuvent se voir changer de signification, ni être utilisés comme identificateurs.

Les mots clés du C++ sont :

Mots clés communs avec le C :

auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct swich typedef union unisgned void volatile while

Mots clés spécifiques au C++ :

bool catch class delete friend inline new operator private protected public template this throw try virtual

(4)

Les règles d’écriture Programmation orientée objet (C++) _________________________________________________________________________________________________________________

De plus le pré-processeur utilise les mots clés suivants :

#define #elif #else #endif #error #if #ifdef #ifndef #include #inline #pragma #undef

Remarque :

Certains compilateurs peuvent ajouter d'autres mots clés qui lui sont propres.

Les identificateurs

Les identificateurs servent à désigner les différents "objets" manipulés par le programme (variables, fonctions, etc.). Ils se présentent sous la forme de chaînes de caractères alphanumériques (combinaison de caractères alphabétiques et de chiffres), de taille quelconque, dans les limites acceptées par le compilateur.

En C++, les identificateurs doivent respecter les règles suivantes :

• Un identificateur doit toujours commencer par une lettre ou par le caractère underscore _. • Les caractères accentués (é, è, ê, à, â, ç,…) ne sont pas acceptés par le compilateur. • Un identificateur doit être différent des mots clés du langage.

• Les majuscules et les minuscules sont considérées comme des lettres distinctes.

• En générale la taille d'un identificateur ne doit pas dépasser les 32 caractères. Ce nombre varie suivant les compilateurs. Par exemple Borland C++ Version 5.0 utilise 250 caractères comme caractères significatifs. Les caractères situés au delà du nombre significatif ne sont pas pris en considération.

• Les identificateurs servent à donner des noms à divers éléments du langage : les variables, les fonctions, les constantes, les énumérations, les structures…

Exemples d'identificateurs valides :

Nabs n1234_ abc table chaise

Exemple d'identificateurs non valides :

2abc n'est pas un identificateur valide.

Exemples d'identificateurs différents :

Somme ≠ somme ≠ sOmme

Les commentaires

Les commentaires sont fondamentaux pour la compréhension des programmes et donc pour leur maintenance et réutilisation. C'est pourquoi, il est très conseillé de les utiliser autant que c'est possible. Ils se présentent comme des portions de texte qui ne sont pas pris en compte lors de la compilation. Le C++ supporte deux types de commentaires :

• Le commentaire multi-lignes : Il est introduit par /* et se termine par */

• Le commentaire ligne : le commentaire peut s'étendre sur une ligne seulement. Il est introduit par //. Sa fin est indiquée par un retour à la ligne.

Exemple :

/* Ceci est un commentaire sur plusieurs lignes */

// Ceci est un commentaire sur une seule ligne.

Le format libre

Le C++ autorise une mise en page libre. Ainsi une instruction peut s'étendre sur un nombre quelconque de lignes pourvu qu'elle se termine par un point virgule. De même une ligne peut comprendre autant d'instructions que voulues.

(5)

Types de base et déclaration des variables Programmation orientée objet (C++) _________________________________________________________________________________________________________________

Types de base et déclaration des

variables

Toute variable utilisée dans un programme C/C++ doit être déclarée. Une variable possède un nom (identificateur) et un type. Elle contient en général une information bien précise. Lors de l'exécution du programme, une zone mémoire ayant la taille du type de la variable lui sera réservée. Cette zone contiendra cette information.

Les types de données en C++

Les types de base

Les types de base en C++ sont :

Type Description

int Pour les entiers standards. float Pour les nombres réels standards.

double Pour les nombres réels en double précision. char Pour les caractères

bool Pour les variables booléennes

Les types dérivés

A ces types de base s'ajoutent d'autres variantes obtenues en plaçant une spécification supplémentaire devant le type de base. Les mots clés permettant de construire les types dérivés sont :

Mot-clé Signification

long Pour définir des entiers ou des réels de grande taille. long s'applique aux types de base int et

double. Lorsque ce mot est utilisé tout seul il désigne alors par défaut un entier long.

short Permet de manipuler les entiers de petite taille. Il s'utilise avec int ou tout seul (même

signification).

unsigned Il se place devant les types entiers ou caractères qui doivent être considérés comme étant non

signés. Il peut s'employer tout seul. Il désigne alors un entier non signé (unsigned int). La liste complète des types en C++ est alors :

Type Taille Plage de valeurs Caractères _{unsigned char}char 1 ₁ -128 …127 _{0 … 255}

Entiers

short int 2 -32768 … 32768 unsigned short 2 0 … 65535

long int 4 -2 147 483 648 … 2 147 483 647 unsigned long int 4 0 … 4 294 967 295

int 2 ou 4 Comme short ou long

unsigned int 2 ou 4 Comme unsigned short ou unsigned long

Réels

float 4 ±1.175 10-38_{… ±3.402 10}+38

double 8 ±2.225 10-308_{… ±1.797 10}+308

long double 10 ±3.4 10-4932_{… ±1.1 10}+4932

Booléen bool 1 true, false

Remarque 1 :

• Le type int possède toujours la taille d'un mot machine. Par conséquent l'espace qu'il occupe en mémoire dépend de la machine sur laquelle s'exécute le programme. Cette taille est par exemple de 2 octets (identique à celle du type short) pour les µp d'intel 8086 et 80286. Elle est de 4 octets (identique à celle du type long) pour les µp PENTIUM. Pour cela, et pour assurer la portabilité et le bon fonctionnement des programmes sur n'importe quelle machine, il est préférable d'utiliser pour les entiers les types short et long.

(6)

• Tous les autres types correspondent à des tailles fixes et ne dépendent pas des machines.

Remarque 2 :

• La représentation des réels utilise le format suivant : Signe Mantisse 10Exposant.

Remarque 3 :

Le type char peut servir en C/C++ pour le stockage des entiers qui sont compris entre –128 et 127. Les caractères sont d'ailleurs représentés sous forme d'entiers. Ces entiers correspondent aux codes ASCII.

Les variables

Déclaration

TYPE NomVariable; Où :

• Type : désigne le type des données que peut stocker la variable.

• NomVariable : désigne le nom de la variable. La nomination d'une variable doit respecter les régles qui régissent les identificateurs en C++.

Exemple :

float tension; int resistance; float Moyenne;

• Plusieurs variables peuvent être déclarées simultanément si elles ont le même type. Elles sont alors séparées les unes des autres par des virgules.

Exemple :

int a,b,c;

float note, moyenne;

• Une variable est caractérisée par son adresse et par la taille qu'elle occupe en mémoire. L'adresse est automatiquement attribuée par le système alors que la taille dépend du type de la variable.

Lieu de déclaration d'une variable

• Une variable doit être déclarée avant d'être utilisée.

• En C, les variables qui sont utilisées à l'intérieur d'un bloc doivent être déclarées au début de ce dernier. Cette restriction a été éliminée en C++. Il est ainsi possible de déclarer une variable n'importe où dans le bloc pourvu que cette déclaration soit faite avant la première utilisation.

Exemple :

// Code correct en C/C++

{ … … …

double i,j, somme, moyenne; i=5.5; j=6.2; somme = i+j; moyenne = somme/2; … … … } // Code correct en C++ // mais incorrect en C { … … … double i,j; i=5.5; j=6.2; double somme; somme = i+j; double moyenne; moyenne = somme/2; … … … }

(7)

Initialisation des variables

• Une valeur initiale peut être affectée à une variable dès sa déclaration.

int i=4; char C ='a';

bool b1 = true; bool b2 = false;

• La valeur d'initialisation d'une variable peut être le résultat d'un calcul portant sur des constantes.

int i = 4+5; double j=2.5*3.2;

• Le contenu d'une variable non initialisée est indéterminé, sauf pour les variables globales et statiques qui sont automatiquement initialisées à 0.

Affectation d'un contenu à une variable

• L'opérateur qui permet de faire l'affectation d'un contenu à une variable est (=). Il est appelé opérateur d'affectation ou d'assignation. Dans une affectation (exemple : i=5), la constante ou le résultat d'une

opération arithmétique ou logique se trouvant à droite de l'opérateur est copié dans la variable se trouvant à sa gauche.

• Il est possible de faire plusieurs affectations en même temps et ce en enchaînant plusieurs fois l'opérateur (=) de la manière suivante :

int i,j; i = j = 2;

Conversions lors d'assignation

Les assignations entre variables de types différents sont autorisées. Elles engendrent alors des conversions implicites (automatiques) des types de données. Ces conversions sont régies par les règles présentées dans le tableau suivant :

• Les conversions présentées dans le tableau ci-dessus peuvent engendrer des pertes de données. C'est pourquoi les assignations entre variables de types différents doivent être effectuées avec précaution.

La notion de bloc

Un bloc est une suite d'instructions délimitée par une accolade ouvrante et une accolade fermante.

Exemple : { instruction_1; instruction_2; … … … … instruction_n; }

Portée des variables :

• La portée d'une variable est définie par les zones du programme où la variable peut être utilisée ou en d'autres mots les zones où la variable est visible.

• Une variable n'est visible qu'à l'intérieur du bloc dans lequel elle est déclarée.

Conversion Commentaire

char → int

Aucune modification de valeur.

- Pour le type char on a expansion du bit de signe.

- Pour le type unsigned char il n'y a pas d'expansion.

int → char Perte des octets les plus significatifs de l'entier. short → int (4 octets) Pas de modification de valeur

int (4 octets)→ short Résultat tronqué : perte des octets les plus significatifs. unsigned → short Perte des octets les plus significatifs de l'entier.

long → unsigned Les deux octets les plus significatifs du long prennent la valeur 0. int → float Ajout d'une partie décimale nulle (exemple : 15 →15.0f)

float → int Perte de la partie décimale (exemple :2.5f→2)

float → double Pas de problème double → float Perte de précision

(8)

Types de base et déclaration des variables Programmation orientée objet (C++) _________________________________________________________________________________________________________________ Exemple 1 : #include <stdio.h> void main() { int i=5; { int i=1, j=3;

printf("i du bloc :%d\n", i); printf("j du bloc :%d\n", j); }

printf("i du main : %d\n", i); } Résultat : i du bloc : 1 j du bloc : 3 i du main : 5 Exemple 2 : #include <stdio.h> void main() { int i=5; { int i=1, j=3;

printf("i du bloc :%d\n", i); }

printf("j du bloc :%d\n", j); // ERROR car j n'est pas visible à ce niveau printf("i du main : %d\n", i);

}

• Les variables i et j du bloc ne sont vues qu'à l'intérieur du bloc et perdent par conséquent leur signification à la sortie de ce dernier. Elles sont dites locales au bloc.

• La variable i du bloc cache à l'intérieur de ce dernier le i du main.

Variable globale

• Des variables peuvent être déclarées en dehors de tous les blocs et fonctions. Elles sont dites globales et peuvent être utilisés dans tout le programme.

Exemple : #include <stdio.h> int i; void main() { … … … … … … … …

printf("i vaut : %d\n", i); // i vaut 0 }

La variable i dans ce cas de figure est considérée comme une variable globale puisqu'elle ne fait partie d'aucun bloc. Elle est automatiquement initialisée à 0.

Les constantes

• Une constante est une donnée qui ne peut pas être modifiée. Cette donnée peut être un entier, un réel, un caractère ou une chaîne de caractères.

• C distingue les constantes entières, les constantes à virgules flottantes, les constantes de type caractère et les constantes de type chaîne. C++ introduit en plus les constantes booléennes.

Les constantes booléennes

(9)

Les constantes entières

Elles peuvent être définies dans les différentes bases du codage. • Format décimal : (0,1,2, …, 9).

• Format octal : (1,2,…7) : Ce format se distingue par l'adjonction du chiffre 0 devant la valeur ou par le préfixe \.

• Format hexadécimal : (0,1,2, …,9,A,BC,D,E,F) : ce format est caractérisé par l'ajout du préfixe 0x ou 0X ou \x devant la valeur.

De plus quand il s'agit :

• D'une constante représentant une valeur négative, il faut faire précéder la valeur de l'opérateur de signe -. • D'une valeur affectée à un entier long, il faut adjoindre à la fin de la valeur la lettre l ou L.

Par rapport au C, le C++ introduit les suffixes u et U pour spécifier qu'une constante est un entier non signé.

Exemples :

Constante Signification

12 Constante entière décimale 12L Constante entière de type long 12U Constante entière non signée

12LU Constante entière non signée de type long 014 Constante entière octale

0xC Constante entière hexadécimale (12 dans la base décimale)

0xCLU Constante entière hexadécimale (12) affectée à un entier long non signé Les constantes flottantes

Deux notations sont possibles pour les constantes flottantes :

• Notation littérale avec virgule flottante seule. Cette notation doit comporter obligatoirement un point (qui correspond à la virgule). La partie entière ou la partie décimale peut être omise (seule une des deux mais pas les deux en même temps).

Exemples :

12.75, -0.58, -.58 , 4. , 0.27, 4.00

• La notation scientifique avec virgule flottante et exposant noté e ou E représentant l'exposant en base 10. (le point peut être absent dans cette notation).

Exemples :

5.69E4 5.69E+4 56.9e3 48e13 48.e13 48.E13 57.3e-5

Remarque :

Par défaut, toutes les constantes flottantes sont codées par le compilateur comme étant de type double. Il est toutefois possible de leur imposer d'être de type :

• float : en les faisant suivre de la lettre f ou F. • long double : en les faisant suivre de la lettre l ou L.

Exemple :

12.34 _{Nombre flottant de double précision (double)} 12.34f _{Nombre flottant de simple précision (float)}

(10)

Les constantes caractères

Les constantes de type caractères peuvent être représentées de deux manières :

• Pour les caractères imprimables : par la valeur du caractère placée entre deux apostrophes [simples quottes]. • Pour les caractères imprimables ou non (d'une manière générale) : une constante caractère peut être définie

par son code ASCII octal ou hexadécimal précédé d'un antislash le tout placé entre deux quottes. Il est à noter que la représentation à l'aide du code hexadécimal doit être préfixé en plus d'un x.

Exemple :

Le caractère (a) peut être représenté de plusieurs manières :

Base décimale : 'a' Base octale : '\101'

Base hexadécimale : '\x41'

Les caractères spéciaux

Par ailleurs, certains caractères non imprimables possèdent une représentation spéciale utilisant l'antislash. Le tableau suivant présente ces caractères et leur signification.

Notation Code ASCII Signification

\n 0A Génère une nouvelle ligne (saut de ligne). \t 09 Tabulation horizontale

\v 0B Tabulation verticale

\b 08 Retour d'un caractère en arrière (backspace) \r 0D Retour chariot \f 0C Saut de page \a 07 Bip sonore \' 2C ' \" 22 " \? 3F ? \\ 34 \

Les constantes chaînes de caractères

Une chaîne est une séquence de plusieurs caractères. Une constante de ce type peut être définie en délimitant cette séquence par des guillemets.

Exemple :

"Ceci est une constante chaîne de caractères"

Les constantes symboliques

Il est possible d'associer à une valeur particulière un nom identificateur qui permet de faire référence à cette valeur sous forme symbolique en utilisant le mot-clé const.

La déclaration d'une constante symbolique se fait comme suit : const Type NomConstante = Valeur;

Exemple :

const int moyenne = 10;

Remarque :

• En C++, une constante symbolique est évaluée au moment de la compilation. Ce n'est pas le cas pour les constantes symboliques en langage C.

• De ce fait, les constantes symboliques peuvent être utilisées en C++ dans la déclaration des tableaux.

Exemple :

Le code suivant est correct en C++ alors qu'il ne l'est pas en C :

… …

const int MAX = 1000;

En langage C il faut plutôt utiliser le code suivant :

#define MAX 1000 … …

(11)

Les opérateurs Programmation orientée objet (C++) _________________________________________________________________________________________________________________

Les opérateurs

Les opérateurs arithmétiques

Opérateur Signification + Addition

- Soustraction * Multiplication

/ Division entière ou réelle. % Reste de la division entière

Remarques :

• Les opérateurs "+, - , *, / " peuvent effectuer des opérations entre entiers ou entre réels.

• L'opérateur "/" effectue en fonction du type des opérandes soit une division entière soit une division réelle.

• L'opérateur " % " ne s'applique pas aux réels (aussi bien float que double). Il n'est défini que pour des opérandes de type entier.

Exemples :

7/3=2 7%3=1

7/-3= -2 7%-3=1 car (7=-3*-2+1) 7/-3= 2 -7%-3= -1 car (-7= -3*2-1)

Dépassement de capacité des entiers :

Soit l'instruction suivante : short n = 10000*100;

La valeur placée dans n se situe en dehors de la capacité du type short. Le contenu de n sera alors erroné mais il n'y aura pas d'indication d'erreur ni au moment de la compilation ni au moment de l'exécution.

Dépassement de capacité des réels :

Pour les réels ou pour la division par zéro, le dépassement est immédiatement signalé par le message "floating point error : overflow".

Combinaison d'opérandes de types différents

Une opération arithmétique peut faire intervenir des opérandes de types différents. Dans ce cas le compilateur effectue des conversions temporaires et automatiques de types. Ces conversions obéissent aux règles suivantes :

Règles

R0 char → int

Si un des deux types est alors l'autre est converti en

R1 long double long double

R2 double double

R3 float float

R4 unsigned long unsigned long

R5 long long

R6 unsigned int unsigned int

Ces règles possèdent une priorité descendante. (R0 est prioritaire par rapport à R1, R1 est prioritaire par rapport à R2 et ainsi de suite).

Forçage de type (casting)

Il est possible d'imposer d'une manière explicite une conversion de type (forçage ou casting) en préfixant l'élément à convertir du type de destination placé entre parenthèses. La syntaxe du forçage de type se présente comme suit :

(12)

Exemple :

int i=5,j=2; double x; x=i/j;

x=(double)i/j; // x= 2.5

Les opérateurs d'affectation

Les opérateurs d'incrémentation et de décrémentation

Les opérateurs logiques

Ce sont les opérateurs qui effectuent des comparaisons de valeurs ou des opérations logiques usuelles. Ils renvoient une valeur booléenne (true, false).

Opérateur Description

< Le test inférieur entre deux expressions arithmétiques (entières ou flottantes). Cet opérateur renvoie

true si la valeur de l'opérande gauche est inférieur à celle de l'opérande de droite et false si non.

> Le test supérieur. Cet opérateur renvoie true si la valeur de l'opérande gauche est supérieur à celle

de l'opérande de droite et false si non.

<= Le test inférieur ou égal. Cet opérateur renvoie true si la valeur de l'opérande gauche est inférieur

ou égale à celle de l'opérande de droite et false si non.

>= Le test supérieur ou égal. Cet opérateur renvoie true si la valeur de l'opérande gauche est supérieur

ou égale à celle de l'opérande de droite et false si non.

== Le test d'égalité. Renvoie true si l'opérande de gauche est égale à l'opérande de droite et false sinon. && ET logique : renvoie true si les deux opérandes sont évalués à true.

|| OU logique : renvoie true si au moins un des deux opérandes est évalué à true.

! NON logique : renvoie true si l'opérande est évalué à false et false dans le cas contraire.

Remarque :

• Les valeurs (entières, flottantes, caractères, …) non nulles sont évaluées à true. • Les valeurs (entières, flottantes, caractères, …) nulles sont évaluées à false.

Exemple :

int i=0, j=5;

bool b1=i<j; // b1 vaut true

bool b2= i==j && i<j // b2 vaut false

Opérateur Signification

= i=5 ; permet d'affecter le contenu du membre de droite au membre de gauche += i+=5 ⇔ i=i+5

-= i-=5 ⇔ i=i-5 *= i*=5 ⇔ i=i*5 /= i/=5 ⇔ i=i/5

Opérateur Signification

++ i++ ⇔ i=i+1 opérateur d'incrémentation -- i-- ⇔ i=i-1 opérateur de décrémentation

(13)

Priorité des opérateurs

La priorité des opérateurs permet de définir l'ordre dans lequel sont évalués les opérateurs dans une expression lorsque cette dernière en fait intervenir plusieurs. Le tableau suivant donne la priorité des opérateurs les plus utilisés :

Opérateur

:: opérateur de résolution de portée () [] ->

(casting) sizeof & * ! ++ -- new delete * / % + - < <= > >= == != && || ? : = += -= *= /= %= Remarque :

• Les opérateurs présentés dans le tableau ci-dessus possèdent une priorité descendante : les opérateurs de la première ligne sont prioritaires par rapport à ceux de la deuxième ligne et ainsi de suite.

• Les opérateurs d'une même ligne possèdent la même priorité. Si une expression fait intervenir en même temps plusieurs opérateurs qui ont la même priorité alors l'opérateur situé le plus à gauche dans l'expression sera le premier évalué.

Exemple :

Expression Opérations résultat

8/4*6 8*6/4 28/(3*4) 3/4*6 3*6/4 (float)2/4 (float)(2/4) -3+4%5/2 Opérateur conditionnel

Cet opérateur permet de tester une expression et de retourner une valeur suivant le résultat du test. Sa syntaxe est donnée comme suit :

Expression ? Valeur renvoyée si Expression vaut vrai : Valeur renvoyée sinon

Remarque :

Les valeurs renvoyées doivent être du même type.

Exemple 1 :

int i=5,j=6,k=18,m; m=i<j ? k- 2*i : i+j;

Exemple 2 :

Cet exemple montre l'utilisation de l'opérateur conditionnel dans le calcul du maximum de deux entiers :

int FMAX(int a, int b) {

return (a>b ? a : b); }

(14)

Opérateur sizeof( )

L'opérateur sizeof renvoie la taille en octets d'un type ou d'une variable. Le type ou la variable sont passés en argument. Exemple : unsigned i; float j; i = sizeof(short); // i vaut 2 i = sizeof(j); // i vaut 4 i = sizeof(long[12]); // i vaut 48

(15)

Les entrées/sorties en C++ Programmation orientée objet (C++) _________________________________________________________________________________________________________________

Les entrées / sorties en C++

• Les entrées/sorties désignent les opérations de lecture et d'écriture de données.

• Les opérations de lecture se font à partir du fichier standard d'entrée (stdin en C). Par défaut ce fichier est associé au clavier mais il peut être redirigé vers d'autres périphériques ou d'autres fichiers sur le disque. • Les opérations d'écriture se font dans le fichier standard de sortie (stdout en C). Par défaut ce fichier est

associé à l'écran mais il peut être redirigé vers d'autres périphériques tels que l'imprimante par exemple. • Le C++ offre deux objets appelés flux (streams) pour la gestion des opérations d'E/S :

o L'objet cout de type ostream associé à la sortie standard (écran). o L'objet cin de type istream associé à l'entrée standard (clavier). • Ces deux objets sont définis dans la bibliothèque iostream.h.

Les opérations de sortie

• Les opérations de sortie des données sont effectuées à l'aide de l'objet cout auquel est associé un opérateur de redirection noté (<<) qui indique le sens de transfert des données.

• La syntaxe de l'utilisation de l'objet cout avec l'opérateur (<<) est la suivante :

cout<<Donnée;

• Le paramètre Donnée désigne la donnée à afficher. Il peut être une variable, une constante ou une expression. • Le paramètre Donnée peut avoir comme type un des types prédéfinis du C++ (bool, char, int, short, long,

float, double, char*, …).

• L'opérateur (<<) indique que le sens de transfert des informations se fait de Donnée vers le flux de sortie cout. Il est également appelé opérateur d'insertion.

• L'opérateur (<<) peut être surchargé afin de permettre l'affichage de données ayant des types personnalisés (classes, structures, …).

• Contrairement aux fonctions de sortie du C, l'objet cout n'utilise aucun caractère de formatage. La reconnaissance du type des informations à afficher est automatique.

• Il est possible d'enchaîner plusieurs opérateurs de redirection de la manière suivante :

cout<<Donnée1<<Donnée2<<Donnée3;

Exemple 1 : Affichage d'un texte

#include <iostream.h> … … …

cout<<"Ceci est un message";

Exemple 2 : Affichage d'un nombre

int i=12; float j = 2.5f; cout<<"i="<<i<<'\n'; cout<<"j="<<j<<'\n';

Exemple 3 : Affichage d'un caractère

char c='a';

cout<<"le caractère c contient : "<<c<<'\n';

Exemple 4 : Affichage d'une chaîne de caractères

char T[10]="Bonjour"; cout<<T;

Exemple 5 : Affichage du résultat d'une expression

int i =5; int j=7;

(16)

Manipulateurs d'affichage en C++

Il existe un ensemble de manipulateurs en C++ qui offrent différentes possibilités concernant le formatage de l'affichage autres que celles proposées par défaut.

Manipulateur de saut de ligne :

Le manipulateur endl (end line) permet d'insérer un saut de ligne dans le flux de texte envoyé à l'écran.

… … … … cout<<"Bonjour"<<endl<<"Au revoir"<<endl; … … … … // Résultat de l'exécution Bonjour Au revoir

Manipulateurs d'affichage des entiers :

Il est possible de modifier la base dans laquelle est affiché un entier à l'aide des manipulateurs suivants :

Manipulateur Signification

dec _{Affichage dans la base décimale pour les entiers (affichage par défaut).} hex _{Affichage dans la base hexadécimale pour les entiers.}

oct _{Affichage dans la base octale pour les entiers.}

int i=75;

cout<<"Affichage par défaut : "<<i<<endl; cout<<"Affichage hexa : "<<hex<<i<<endl; cout<<"Sans manipulateur : "<<i<<endl; cout<<"Affichage décimal :"<<dec<<i<<endl; cout<<"Sans manipulateur : "<<i<<endl;

// Résultat de l'exécution Affichage par défaut : 75 Affichage hexa : 4b Sans manipulateur : 4b Affichage décimal : 75 Sans manipulateur : 75

L'exemple précédent montre qu'un manipulateur de conversion de la base d'affichage d'un entier reste actif depuis l'endroit de son application et jusqu'à l'application d'un autre manipulateur.

Manipulateur du gabarit d'affichage

Manipulateur Signification

setw(nombre)

Définit le gabarit de la variable à afficher avec une justification à droite par défaut. Si la valeur à afficher est plus importante que le gabarit, alors ce dernier ne sera pas respecté et la variable sera affichée de façon conventionnelle. Le manipulateur setw doit être utilisé pour chacune des informations à afficher.

setfill(caractère) Définit le caractère de remplissage lorsqu'on utilise un affichage avec la gestion de

gabarit. Par défaut, le caractère de remplissage est l'espace. Les manipulateurs setw et setfill sont définis dans la bibliothèque iomanip.h.

#include <iostream.h> #include <iomanip.h> … … … int i=55; cout<<setw(4)<<i<<endl; cout<<setfill('0')<<setw(4)<<i<<endl; … … … // Résultat de l'exécution 55 0055

(17)

Les opérations d'entrée

• Les opérations d'entrée sont effectuées à l'aide de l'objet cin auquel est associé l'opérateur de redirection (>>). • La syntaxe de l'utilisation de l'objet cin avec l'opérateur (>>) est la suivante :

cin>>var;

• Le paramètre var désigne la variable qui va stocker l'information saisie.

• La variable var peut avoir comme type un des types prédéfinis du C++ (bool, char, int, short, long, float, double, char*, …).

• L'opérateur (>>) indique que le sens de transfert des informations se fait du flux d'entrée cin vers la variable var. Cet opérateur est également appelé opérateur d'extraction.

• Tout comme cout, cin n'utilise aucun caractère de formatage. La reconnaissance des types des données à saisir est automatique.

Exemple :

#inlcude <iostream.h> void main( )

{

int i; float f; char c;

cout<<"donnez un entier"<<endl; cin>>i;

cout<<" donnez un réel"<<endl; cin>>f;

cout<<" donnez un caractère"<<endl; cin>>c;

}

• Il est possible d'enchaîner plusieurs opérateurs de redirection avec cin afin de faire la saisie de plusieurs variables en même temps. Dans ce cas les valeurs à faire entrer doivent être séparées au moment de la saisie par un blanc (tabulation, espace ou retour chariot).

Exemple :

int v1,v2;

cout<<"Veuillez saisir deux entiers"; cin>>v1>>v2;

(18)

Les structures de contrôle Programmation orientée objet (C++) _________________________________________________________________________________________________________________

Les structures de contrôle

Introduction

Il existe trois catégories de structures de contrôle :

• Les instructions de branchement conditionnel (alternative). • Les instructions de branchement inconditionnel.

• Les instructions répétitives.

Les instructions de branchement conditionnel

Trois types de branchement conditionnel peuvent être distingués : le branchement conditionnel simple, le branchement conditionnel imbriqué et le branchement conditionnel multiple.

Le branchement conditionnel simple

Ce branchement est réalisé par le mot réservé if de la manière suivante :

• Si la condition testée est vraie alors le programme exécute le bloc d'instructions. Si cette condition est fausse alors le programme saute ce bloc et continue son exécution normalement.

• Il est possible de spécifier un autre bloc d'instructions à exécuter dans le cas où la condition est fausse par l'adjonction de l'instruction else au branchement if. Cette structure de contrôle devient alors :

Remarque :

Si le bloc (bloc 1 ou bloc 2) se réduit à une seule instruction alors les accolades deviennent facultatives.

Application 1 :

Écrire un programme qui permet à partir de la saisie d'un nombre d'afficher un message pour indiquer la possibilité ou non de l'utiliser comme diviseur.

#include<iostream.h> void main() { int i; cout<<"Donner un entier : "; cin>>i; if(i==0)

cout<<"Impossible d'utiliser cet entier comme diviseur"<<endl; else

cout<<"Il est possible d'utiliser cet entier comme diviseur"<<endl; }

if(Condition est vraie) {

Bloc 1 d'instructions à exécuter }

else {

Bloc 2 d'instructions à exécuter }

if(Condition est vraie) {

Bloc d'instructions à exécuter }

(19)

Application 2 :

Écrire un programme qui permet de déterminer si un nombre entier saisi au clavier est pair ou impair.

#include<iostream.h> void main() { int i; cout<<"Donner un entier : "; cin>>i; if(i%2)

cout<<"L'entier saisi est impair"<<endl; else

cout<<"L'entier saisi est pair"<<endl; }

Les branchements conditionnels imbriqués

En pratique, il est souvent utile de pouvoir enchaîner un ensemble de tests pour examiner plusieurs valeurs possibles. Ceci peut être réalisé en imbriquant les if et les else de la manière suivante :

Remarque :

Lors de l'imbrication de plusieurs instructions de branchement conditionnel simple, un else se rapporte toujours au dernier if rencontré auquel aucun else n'a été encore attribué.

Exercice

Écrire un programme qui demande à l'utilisateur son age et lui indique le niveau du cours qu'il doit suivre en se basant sur les critères suivants :

• Si l'age est entre 7 et 15 il lui affiche "vous avez besoin du cours du premier niveau". • Si l'age est entre 16 et 20 il lui affiche "vous avez besoin du cours du deuxième niveau". • Si l'age est entre 20 et 25 il lui affiche "vous avez besoin du cours du troisième niveau". • Si l'âge est inférieur à 7 il lui affiche " vous êtes encore jeune".

• Si l'âge est supérieur à 25 il lui affiche " vous êtes trop âgé".

if(test_1 est vrai) { Bloc_1 }

else

{ if(test_2 est vrai) { Bloc_2 }

else

{ if(test_3 est vrai) { Bloc_3 }

else …… ……

else{ if(test_n est vrai) { Bloc_n } else { Bloc_n+1 } } …… …… } } if(test_1 est vrai)

{ Bloc_1 }

else if(test_2 est vrai) { Bloc_2 }

else if(test_3 est vrai) { Bloc_3 }

…… ……

else if(test_n est vrai) { Bloc_n }

else

{ Bloc_n+1 }

Ce code est équivalent à celui-ci:

(20)

Branchement conditionnel multiple

Les branchements imbriqués utilisant le if et le else donnent à un programme un aspect peu lisible, en plus des risques d'erreurs qu'ils peuvent engendrer surtout lors du placement des accolades. C'est pourquoi, lorsqu'il s'agit de traiter plusieurs alternatives on leur préfère la structure switch définie de la manière suivante :

• La structure de contrôle switch compare généralement la valeur d'une variable de type entier ou assimilé (char, int, unsigned, long, …) à un ensemble de constantes. Lorsque cette valeur correspond à l'une des constantes alors le bloc d'instructions associé à cette dernière est exécuté.

• Le bloc défini par le mot-clé default est un bloc facultatif (non obligatoire) qui désigne un ensemble d'instructions qui seront exécutés par défaut.

• Le mot-clé break permet une sortie immédiate de la structure swtich et évite alors au programme de tester toutes les autres alternatives après avoir exécuté un bloc i donné. Cette instruction n'est pas obligatoire.

Exercice:

En utilisant la structure de contrôle switch, donner un programme qui demande à l'utilisateur de saisir un nombre. Si ce nombre est égale à 0, il lui affiche "vous avez saisi une valeur nulle". S'il est égale à un, il lui affiche "vous avez saisi un". Si ce nombre est différent de 1 et de 0 il lui affiche un message d'erreur "valeur incorrecte".

#include <stdio.h> void main()

{

int i;

printf("Donner une valeur entière 0 ou 1:"); scanf("%d",&i);

switch( i ) {

case 0:

printf("\n vous avez saisi une valeur nulle \n"); break;

case 1:

printf("\n vous avez saisi un "); break;

default:

printf("\n valeur incorrecte "); } } switch(variable ou expression) { case constante_1: Bloc 1 d'instructions break; case constante_2: Bloc 2 d'instructions break; …… …… case constante_n: Bloc n d'instructions break; default:

bloc d'instructions par défaut }

(21)

Résultat de l'exécution :

• Si le nombre saisi est 6: le message de sortie sera → "valeur incorrecte". • Si le nombre saisi est 1: le message de sortie sera → "vous avez saisi un".

• Si on élimine le break du case : 1.

o Si le nombre saisi est 6: le message de sortie sera → "valeur incorrecte".

o Si le nombre saisi est 1: le message de sortie sera → "vous avez saisi un " suivi du message "valeur incorrecte ".

• Si le nombre saisi est 0 le message de sortie sera "vous avez saisi une valeur nulle". • Si on élimine le break du case 0 et on préserve celui de case 1:

o Si le nombre saisi est 6, le message de sortie sera → "valeur incorrecte". o Si le nombre saisi est 1 le message de sortie sera → "vous avez saisi un ".

o Si le nombre saisi est 0 le message de sortie sera → "vous avez saisi une valeur nulle", "vous avez saisi un".

• Si on élimine le break du case 0 et celui de case 1:

o Si le nombre saisi est 6, le message de sortie sera → " valeur incorrecte ". o Si le nombre saisi est 1 le message de sortie sera → " vous avez saisi un ".

o Si le nombre saisi est 0 le message de sortie sera → "vous avez saisi une valeur nulle", "vous avez saisi un", "valeur incorrecte".

o Si on supprime les instructions break, le programme traitera tous les cas qui suivent la première correspondance entre la valeur et une des constantes de test. Pour l'exemple précèdent, si on supprime les break et on saisit 0, le programme affichera les messages suivants : → "vous avez saisi une valeur nulle", "vous avez saisi un", "valeur incorrecte".

Remarque :

L'instruction switch possède l'inconvénient de limiter les comparaisons à des valeurs constantes et ne peut pas traiter des intervalles.

Les instructions répétitives

Le langage C++ dispose de trois structures pour le contrôle répétitive: while, do … while et for. Théoriquement, ces structures sont interchangeables, c.-à-d. il serait possible de programmer toutes sortes de boucles conditionnelles en n'utilisant qu'une seule des trois structures.

La boucle while

La syntaxe de cette boucle est :

La boucle while exécute un bloc d'instructions tant que le test qui lui est associé est vrai. Si ce bloc se réduit à une seule instruction alors les accolades deviennent non obligatoires.

Exercice :

Écrire un programme qui affiche tous les multiples d'un entier de référence qui sont inférieurs à une valeur maximale. L'entier de référence et la valeur maximale seront donnés par l'utilisateur.

while(Test est vrai) {

Bloc d'instructions à exécuter }

(22)

#include <stdio.h> void main( ) {

unsigned long ValeurMax,NbRef;

printf("Donnez l'entier de référence : "); scanf("%lu", &NbRef);

printf("Donnez la valeur maximale : "); scanf("%lu", &ValeurMax); while(ValeurMax >= NbRef) { if(ValeurMax % NbRef == 0) printf("%d\t", ValeurMax); ValeurMax--; } printf("C'est fini\n"); }

La boucle do… while

Cette structure est similaire à la boucle while mais avec une petite différence qui réside dans le fait qu'elle assure l'exécution au moins une fois des instructions du bloc.

En pratique, l'utilisation de la structure do - while n'est pas aussi fréquente que while; mais dans certains cas, elle fournit une solution plus élégante. Une application typique de do - while est la saisie contrôlée de données.

Exemple 1 :

Donner un programme qui permet de contrôler la saisie d'un entier compris entre 1 et 10.

… … … int N; do {

printf("Introduisez un nombre entre 1 et 10 :"); scanf("%d", &N);

}

while (N<1 || N>10); … … …

Exemple 2 :

On veut écrire un programme qui demande à l'utilisateur s'il veut continuer ou arrêter une tâche donnée. • Si l'utilisateur tape le caractère o alors le programme quitte et termine la tâche.

• S'il tape le caractère n alors le programme continue l'exécution de la tâche. • S'il tape tout autre caractère le programme repose la même question à l'utilisateur.

#include <stdio.h> void main( ) { char c; do {

printf("voulez vous terminer et quitter ?"); scanf("%c",&c);

fflush(stdin);

}while (c!='o' && c!='n');

if(c=='o')

printf("la tâche se termine tout de suite\n"); else

printf("OK on continue\n"); }

do {

Bloc d'instructions à exécuter }while(Test est vrai);

(23)

La boucle for

La structure de la boucle for se présente comme suit :

• <expr1> est évaluée une seule fois et ce avant la première itération de la boucle. Elle est utilisée pour initialiser les données de la boucle.

• <expr2> est évaluée avant chaque itération de la boucle. Elle représente généralement une condition qui est utilisée pour décider si la boucle fera une itération supplémentaire ou non.

• <expr3> est évaluée à la fin de chaque itération de la boucle. Elle est utilisée pour réinitialiser les données de la boucle.

Remarque :

• La boucle for constitue une alternative syntaxique à la boucle while dans laquelle tous les éléments relatifs au contrôle de la boucle sont regroupés ensemble d'une manière lisible dans l'entête. En effet, les trois expressions de contrôle présentées ci-dessus peuvent être placées dans la boucle while de la manière suivante :

• Le plus souvent, la boucle for est utilisée comme boucle de comptage :

for(initialisation ; condition de continuité ; compteur) {

<bloc d'instructions> }

Exercice :

Écrire un programme qui affiche les nombres entiers de 0 jusqu'à 100.

#include <stdio.h> void main( ) { int i; for(i=0;i<101;i++) printf("%d\t",i); } Remarques :

• Chacune des trois instructions de la boucle for est facultative. Ainsi la boucle de l'exercice précèdent peut être écrite de la manière suivante:

• Lorsque <expr2> est absente, alors la condition de continuation sera considérée comme étant toujours vraie et for (<expr1>;<expr2>;<expr3>) { <bloc d'instructions> } i=0; for( ;i<101;i++) printf("%d\t",i); i=0; for( ;i<101; ) { printf("%d\t",i); i++; } ou également: <expr1>; while ( <expr2> ) { <bloc d'instructions> <expr3>; }

(24)

Le branchement inconditionnel

Le langage C++ dispose de trois instructions pour le branchement inconditionnel : break, continue et goto. L'instruction break

• En plus de son utilisation en association avec switch, l'instruction break peut être utilisée dans n'importe quelle boucle. Cette instruction provoque alors une interruption et une sortie immédiate de la boucle.

• L'exécution du programme continue alors au niveau de l'instruction située tout juste après la boucle.

Exemple: void main() { int i; for(i=1;i<=10;i++) {

printf("Début de l'itération %d\n",i); printf("Bonjour\n");

if(i==3) break;

printf("Fin de l'itération %d\n",i); }

printf("Après la boucle"); }

Remarque :

En cas de boucles imbriquées, l'instruction break fait sortir seulement de la boucle la plus interne. L'instruction continue

L'instruction continue intervient également pour interrompre l'exécution des boucles. Mais contrairement à break, elle ne provoque pas la sortie complète de la boucle mais plutôt l'interruption de l'itération courante et le passage à l'itération suivante de cette boucle.

Exemple 1: #include <stdio.h> void main( ) { int i; for(i=1;i<=4;i++) {

printf("Début itération %d\n",i); if(i < 3) continue;

printf("bonjour\n"); }

}

Exemple 2 :

Le programme ci-dessous demande à l'utilisateur de saisir un entier positif et lui affiche son carré. Si l'entier est négatif alors le programme redemande à l'utilisateur de saisir un autre entier. L'exécution s'arrête lorsque'un entier nul est saisi.

#include <stdio.h> void main( ) {int n; do

{ printf("\n donnez un entier n > 0: "); scanf("%d",&n);

if(n<0)

{ printf("\n donnez un n positif\n"); continue ;

}

printf(" le carré de n est : %d\n",n*n); }while(n) ; } Remarque : Exécution: Début de l'itération 1 Bonjour Fin de l'itération 1 Début de l'itération 2 Bonjour Fin de l'itération 2 Début de l'itération 3 Bonjour Après la boucle Exécution: Début itération 1 Début itération 2 Début itération 3 bonjour Début itération 4 bonjour

(25)

L'instruction goto

L'instruction goto provoque un branchement immédiat du programme à un endroit prédéfini. Les boucles, les tests sont interrompues. L'endroit où reprend le programme est défini par une étiquette suivie du symbole : La syntaxe globale de cette instruction est :

goto NomEtiquette; ……… NomEtiquette: Exemple: #include <stdio.h> void main( ) { int i; for(i=1;i<=10;i++) {

printf("Début de l'itération %d\n",i); printf("Bonjour\n");

if(i==3) goto Sortie;

printf("Fin de l'itération %d\n",i); }

Sortie: printf("Après la boucle"); } Exécution: Début de l'itération 1 Bonjour Fin de l'itération 1 Début de l'itération 2 Bonjour Fin de l'itération 2 Début de l'itération 3 Bonjour Après la boucle

(26)

Les tableaux Programmation orientée objet (C++) _________________________________________________________________________________________________________________

Les tableaux

Introduction

• Un tableau est un type particulier de variables qui permet d'associer sous le même nom, un ensemble fini de valeurs de même nature (type).

• Tous les types de base et tous les types personalisés construits en C/C++ peuvent servir à définir des tableaux.

Déclaration d'un tableau

La syntaxe permettant la déclaration d'un tableau est la suivante : Type NomTableau[Taille];

Où :

• Type désigne le type des éléments du tableau, • NomTableau désigne son nom,

• Taille désigne le nombre de ses éléments.

Exemples:

Déclaration:

int TableauEntiers[15]; double TableauFlottants[40];

• La taille maximale d'un tableau dépend de la configuration de l'environnement de travail (compilateur). • La taille d'un tableau doit être une constante ou une expression constante, cependant elle ne peut pas être une

variable.

#define N 10 int M =10;

int Tab1[10]; // Déclaration correcte int Tab2[N]; // Déclaration correcte int Tab3[M]; // Déclaration incorrecte float Tab4[2*N+1]; // Déclaration correcte

• La dimension peut également être une constante symbolique (Ceci est possible en C++ mais pas en C).

const int N=10;

int Tab[N]; // Déclaration correcte en C++ mais incorrecte en C

Accès aux éléments d'un tableau

• L'accès à la valeur d'un élément du tableau se fait à travers son numéro d'ordre ou indice de la manière suivante:

NomTableau[Indice]

• Un tableau est toujours numéroté à partie de 0. Ainsi dans un tableau de N éléments, le premier a pour indice 0 et le dernier a pour indice N-1.

• La référence d'un élément du tableau qui n'existe pas (par exemple T[N+2] pour un tableau de taille N) n'est signalée comme erreur ni à la compilation ni à l'exécution. En effet, le programme fait comme si cet élément existait. La seule manifestation de cette erreur de référence réside dans l'obtention de résultats imprévisibles.

(27)

Tableaux à plusieurs dimensions

En plus des tableaux à une dimension (vecteur), le C++ autorise la déclaration des tableaux à plusieurs dimensions. Cette déclaration se fait pour un tableau de N dimensions de la manière suivante :

Type NomTableau[TailleD_1][TailleD_2]…[TailleD_N]; Où TailleD_i désigne la taille de la ième dimension.

A ce titre, une matrice est déclarée d'une manière générale comme suit : Type NomTableau[NombreLigne][NombreColonne]; Exemples:

int T[2][3];

L'arrangement en mémoire des cases est comme suit :

float TabF[3][6]; char TabCh[4][5][6];

Initialisation des tableaux

Tableaux à une dimension

Type NomTableau[N] = {Valeur1, Valeur2,…, Valeur_N-1};

Exemple 1:

int Tab[3] = {1,7,4};

• Le nombre des valeurs d'initialisation ne peut pas dépasser la taille du tableau mais il peut être inférieur. Dans ce cas les éléments non explicitement initialisés seront automatiquement initialisés à 0.

Exemple 2:

int Tableau[5] = { , ,5, ,3};

• Lors de l'initialisation d'un tableau, la spécification de sa taille est facultative.

• Dans le cas où elle est absente, la taille est automatiquement déterminée d'après le nombre des valeurs d'initialisation.

Exemple 3 :

int Tableau[ ] = {1,7,4} // La taille est du tableau est égale à 3

Tableaux à deux dimensions

Exemples :

int Tab[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};

int Tab[3][4] = { {1,2,3,4}, {5,6,7,8}, {9,10,11,12}};

Il est également possible d'omettre quelques valeurs qui seront automatiquement initialisées à 0.

int Tab[3][4] = { {1,2, ,4}, , {9, ,11,12}};

(28)

Affectation des valeurs aux éléments d'un tableau

Exemple :

int Tab[10];

Tab[0]=500; // affecte au premier élément 500 Tab[5]=100; // affecte au sixième élément 100 Tab[9]=50; // affecte au dernier élément 50 char T[5][3];

T[0][2] = 'a';

Quelques règles d'écriture

• Les éléments d'un tableau peuvent être incrémentés ou décrémentés:

Tab[4] = 5; Tab[4]++ // tab[4] vaut 6.

• Les indices peuvent être des expressions arithmétiques: T[2*i-1] ou Tab[i-3][j+k]

• Il n'est pas possible d'affecter d'une manière globale un tableau à un autre :

int T1[5]; int T2[5];

T1 = T2; // instruction incorrecte.

Exercice :

Donner un programme qui fait la copie des éléments d'un tableau d'entiers initialisé, dans un deuxième tableau de même taille. #include<stdio.h> void main() { int i; int T1[3] = {5,6,23}; int T2[3]; for(i=0;i<3;i++) T2[i]=T1[i]; }

Saisie et affichage des éléments d'un tableau

La saisie et l'affichage d'un élément d'un tableau se fait de la même manière que pour n'importe quelle variable possédant le même type que celui du tableau.

Exercice :

Donnez un programme qui fait la saisie des éléments d'un tableau de caractères de taille 5 et qui les affiche ensuite. #include<stdio.h> void main() { int i; char T[5]; /* Saisie */ for(i=0;i<5;i++) {

printf("\n Donner le caractère numéro %d: ", i+1); scanf("%c", &T[i]); } /* Affichage */ for(i=0;i<5;i++) printf("%c \t", T[i]); }

(29)

Exercice :

Écrire un programme qui fait la saisie des éléments d'un tableau d'entiers à deux dimensions 3x4 et qui les affiches sur 3 lignes et 4 colonnes.

#include<stdio.h> void main() { int i,j; int T1[3][4], T2[3][4]; for(i=0;i<3;i++) for(j=0;j<4;j++) scanf("%d",&tab[i][j]); /* Affichage */ for(i=0;i<3;i++) { for(j=0;j<4;j++) printf("%d\t", tab[i][j]); printf("\n"); } }

(30)

Les pointeurs et les références Programmation orientée objet (C++) _________________________________________________________________________________________________________________

Les pointeurs et les références

1 - Introduction

• Un pointeur est une donnée (constante ou variable) qui représente l'adresse d'une variable.

• Pour que l'adresse stockée dans un pointeur soit exploitable, il faut connaître le type de l'information qui se situe au niveau de cette adresse afin de pouvoir l'interpréter convenablement. C'est pour cette raison qu'un pointeur doit être toujours associé à un type donné.

• Les pointeurs, tout comme les tableaux, les références et les structures sont considérés comme des outils de construction de types étendus (types construits sur la base d'autres types).

• Un pointeur est dit qu'il pointe (ou renvoie) vers la variable dont il stocke l'adresse.

2 - Déclaration

Formellement la syntaxe de déclaration d'un pointeur est la suivante : Type * NomPointeur ;

NomPointeur désigne le nom d'une variable de type pointeur.

Exemples :

char *pc; // définit un pointeur vers une donnée de type caractère. int * pi; // définit un pointeur vers une donnée de type int

double * pdr; // définit un pointeur vers une donnée de type réel double

unsigned long * pli; // définit un pointeur vers une donnée de type unsigned long

Remarque :

Les pointeurs occupent tous la même taille en mémoire indépendamment de la taille du type de l'objet pointé. Cela signifie par exemple qu'une variable de type pointeur sur un long double possède la même taille en mémoire qu'une variable de type pointeur sur un caractère.

Déclaration multiple

int *p1, *p2; // p1 et p2 sont deux pointeurs sur des entiers.

int *p1, p2; // p1 est un pointeur sur un entier alors que p2 est une variable entière. int p1, *p2 // p1 est une variable entière alors que p2 est un pointeur sur un entier.

3 - Initialisation des pointeurs

• Comme pour les autres variables, il est possible d'initialiser les variables de type pointeur. La valeur initiale est dans ce cas, l'adresse d'une donnée possédant comme type, le type vers lequel pointe le pointeur en question.

• L'initialisation d'un pointeur ne peut s'effectuer qu'en lui affectant comme valeur l'adresse d'une variable déjà existante.

Exemple :

short s; short *ps1 = &s;

(31)

Les pointeurs et les références Programmation orientée objet (C++) _________________________________________________________________________________________________________________

Remarque :

Si l'on indique comme valeur d'initialisation pour un pointeur l'adresse d'une variable ayant un autre type de données que celui vers lequel le pointeur peut renvoyer, le compilateur affiche alors une erreur lors de la compilation.

Exemple :

long l, *pl=&l;

unsigned long *pul=&l; // erreur: pul n'est un pointeur vers un long

4 - Affectation des pointeurs et conversion

Une variable de type pointeur peut obtenir sa valeur non seulement par une initialisation, mais également par une opération d'affectation.

Exemples :

float f1; float *pf1,*pf2;

pf1 =&f1; // pf1 contient l'adresse de f1. pf2=pf1; // pf2 contient l'adresse de f1.

Conversion

Il n'existe aucune conversion implicite d'un type pointeur vers un autre type pointeur. Le seul moyen pour faire des conversions entre types pointeurs est le casting.

int i,*pi=&i; unsigned int *pui; pui = pi; // erreur pui=&i; // erreur

pui=(unsigned int *)pi; // OK

5 - Accès indirect aux variables

• Il est possible d'accéder à une variable à travers un pointeur qui pointe vers cette variable. Il suffit d'utiliser pour cela l'opérateur * de la manière suivante :

Type Variable, *NomPointeur=&Variable;

Variable ⇔⇔⇔ * NomPointeur ⇔

• L'opérateur * est appelé dans ce cas opérateur d'indirection car il permet d'accéder d'une manière indirecte au contenu de la variable (à travers le pointeur).

Exemple 1 :

int i; int *pi; i =1234;

pi= &i // pi contient l'adresse de i

// *pi désigne d'une manière indirecte le contenu de i cout<<i;

cout<<*pi;

Exemple 2 :

Cet exemple montre la saisie et l'affichage de la valeur d'une variable à travers un pointeur :

int i,*pi=&i; scanf("%d",pi); printf("%d",*pi);

Ou également en utilisant les fonctions d'E/S du C++

int i,*pi=&i; cin>>*pi; cout<<*pi;