Épisode III Le langage C++

Transcription

Épisode III Le langage C++
'
$
Épisode III
Le langage C++ - les bases
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 1/120
%
$
Le langage C++ : Introduction
"Le moment est venu," dit le Morse
"de parler de diverses choses."
– L. Caroll
➔ C++ est né officiellement en 1983, fruit du travail de Bjarne Stroustrup ;
➔ Au départ, introduit comme une extension "Objet" du langage C ;
➔ Permet de passer en douceur aux objets, tout en réutilisant les bibliothèques C existantes ;
➔ Parfois utilisé à minima comme "un meilleur C" :
c’est au programmeur de se décider à "programmer objet" ;
➔ Le site de B. Stroustrup donne de nombreuses références aux livres, articles qu’il a écrits ;
➔ Normalisation du C++ :
normes publiées par le comité ISO "JTC1/SC22/WG21 - The C++ Standards Committee"
(normes "ISO/IEC 14882 : 1998", et "ISO/IEC 14882 : 2003").
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 2/120
%
'
$
Le langage C++ : Introduction
Principales caractéristiques du C++ qui en font un langage orienté objet (d’après Stroutrup) :
Abstraction capacité de représenter des concepts dans un programme, de cacher des détails
d’implémentation derrière des interfaces bien définies ;
Encapsulation une abstraction ne peut être utilisée qu’en accord avec sa spécification (crucial
pour protéger les abstractions de toute corruption) ;
Polymorphisme même interface pour des objets procurant des implémentations différentes ;
Héritage nouvelles abstractions à partir d’abstractions existantes ;
Généricité possibilité de paramétrer des types et des fonctions avec des types ou des valeurs ;
Co-existence avec d’autres langages ;
Performance vitesse d’exécution et compacité du code ;
Sécurité toutes les variables et les expressions C++ sont typées => le compilateur peut réaliser
toutes les vérifications de type possibles et imaginables.
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 3/120
%
$
C++ de base : Introduction
Exemple de programme C++ élémentaire qui affiche "Hello, World!" à l’écran :
0 // Exemple elementaire
1 #include <iostream>
2 int main()
3 {
4
std::cout << "Hello, World!\n";
5
return 0;
6 }
➔ Pour être exécutable, un programme C++ doit définir une fonction main ;
➔ Les accolades { et } sont utilisées en C++ (comme en C) pour délimiter un bloc :
début /fin du corps de la fonction main ;
➔ ligne 0 - Tout ce qui suit ’// ’ est un commentaire C++ jusqu’à la fin de la ligne ;
➔ ligne 1 - Directive de compilation -> inclusion des déclarations d’entrées/sorties contenues
dans le fichier iostream (sans ces déclarations, std::cout < < ... ne voudrait rien dire) ;
➔ ligne 4 - Avec l’inclusion du fichier iostream, le compilateur sait que std::cout désigne un
objet de l’espace de nom std doté d’un opérateur ’< <’ qui affiche à l’écran l’argument qui le
suit ;
- Le caractère ’\’ (backslash) introduit un caractère spécial (exemple : \n -> "saut de ligne").
➔ ligne 5 - Fin du programme et renvoi de la valeur 0 comme valeur de retour.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 4/120
%
'
$
C++ de base : commentaires et mise en page
C++ supporte les commentaires :
➔ "à la C" (/* ....
*/ ),
➔ spécifiques commençant par un "double slash" (//)
// Commentaire jusqu’à la fin de la ligne
/*
commentaire "à la C" pouvant tenir sur
plusieurs lignes
*/
➔ Un programme source est un ensemble ordonné de lignes (mots séparés par un séparateur) ;
➔ Séparateur C/C++ : espace, tabulation, retour à la ligne, commentaire, ou combinaison de
séparateurs ;
➔ La mise en page est libre : on peut insérer autant d’espaces, de sauts de ligne, ... que l’on veut
(le compilateur ignore la répétition des séparateurs).
Le programme simple Hello-World pourrait aussi bien être écrit :
// Exemple de programme
#include <iostream>
int main(){std::cout << "Hello, World!\n"; return 0;}
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 5/120
%
$
C++ de base : Les mots clefs
➔ C++ comprend un certain nombre de mots clefs réservés interprétés par le compilateur
comme des éléments particuliers du langage.
➔ Certains de ces mots clef sont issus du C ANSI :
&
asm
auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
handle
if
int
long
new
register
return
short
assigned
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 6/120
%
'
$
C++ de base : Les mots clefs - suite
➔ Mots clefs spécifiques du C++ :
&
Conception et Programmation OO
'
bool
catch
class
const_cast
delete
dynamic_cast
explicit
false
friend
inline
mutable
namespace
new
operator
private
protected
public
reinterpret_cast
static_cast
template
this
throw
true
try
typeid
typename
using
virtual
wchar_t
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 7/120
%
$
C++ de base : Les identificateurs
➔ Dans un programme C++ un identificateur représente un nom de variable, de type ou de
fonction ;
➔ Règles de construction des identificateurs :
✓ Le premier caractère est une lettre non accentuée, ou le caractère ’_’ ("tiret bas") ;
✓ Le reste des caractères est composé des caractères alphanumériques du code ASCII 7bits
(caractères alphanumériques non accentués) ;
✓ Pas de limites en nombre de caractères ;
✓ Il y a une différence entre caractère majuscule et minuscule
(le compilateur est sensible à la casse) ;
✓ Un identificateur ne peut pas être identique à un mot clef du C++.
couleur_objet, InterPolationNode, Element5 : identificateurs valides ;
6tron, résultat, int : non valides (respectivement, chiffre comme premier caractère,
caractère accentué et mot clef).
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 8/120
%
'
$
C++ de base : Déclaration/Définition des identificateurs
➔ C++ est un langage à typage fort : tout identificateur, toute expression doit posséder un type
associé (entier, flottant, pointeur, tableau de flottants, classe, ...) ;
➔ Le type d’un identificateur ou d’une expression permet au compilateur de déterminer :
✓ La taille de la zone mémoire nécessaire pour représenter l’identificateur ;
✓ La nature des opérations applicables à cet identificateur ;
✓ La façon dont ces opérations doivent être exécutées.
➔ La déclaration d’un identificateur est l’instruction qui permet au compilateur de lui associer
un type ;
➔ La définition d’un identificateur est une déclaration où le compilateur alloue de la mémoire :
- pour contenir les données du type associé (cas d’une variable),
- pour contenir le code compilé (cas d’une fonction) ;
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 9/120
%
$
C++ de base : Déclaration/Définition des identificateurs
➔ Une définition produit un objet en mémoire, alors qu’une déclaration ne fait qu’annoncer
qu’un tel objet sera créé plus loin, ou dans un autre fichier ...
➔ La déclaration/définition d’un identificateur se fait selon la syntaxe :
[descripteur]
Type
déclarateur
[=initialisateur]
✓ descripteur est un mot clef optionnel (const, extern, virtual, ....)
précisant un attribut autre que le type ;
✓ Type est un des types supportés par le langage : type de base (int, char, float, ...),
type synonyme ou type défini par l’utilisateur (classe) ;
✓ déclarateur se compose d’un identificateur et d’un opérateur de déclaration
optionnel ;
Les opérateurs de déclaration les plus utilisés sont :
: pointeur (utilisé en préfixe) ;
*
*const : pointeur constant (utilisé en préfixe) ;
&
: référence (utilisé en préfixe) ;
[]
: tableau (utilisé en suffixe) ;
()
: fonction (utilisé en suffixe).
✓ initialisateur est une expression optionnelle constante ou non qui permet
d’initialiser une variable lors de définition.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 10/120
%
'
$
C++ de base : Déclaration/Définition des identificateurs
➔ Un programme C++ ne peut contenir qu’une seule définition d’un même identificateur ;
➔ Un programme C++ peut contenir plusieurs fois la déclaration d’une même entité ;
✓ Exemples de déclarations :
extern int n;
// n est un entier défini ailleurs.
extern int n;
// inutile, mais autorisé.
double power(double x, int n); // power est une fonction définie ailleurs.
✓ Exemple de définitions :
int n;
int n;
double power(double x, int n)
{
// code de la fonction;
}
&
Conception et Programmation OO
'
// n est un entier défini, non initialisé.
// Erreur compilation : re-définition de n.
// définition de la fonction power.
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 11/120
%
$
C++ de base : Déclaration/Définition des identificateurs
➔ La déclaration d’un identificateur induit souvent sa définition implicite.
Exemple d’instructions C++ qui sont à la fois des déclarations et des définitions :
char c;
int i;
double x[100];
int count = 1;
//
//
//
//
//
char *file = "data.txt"
//
//
struct cplx {float re,im;}; //
//
enum {up, down};
//
//
c est un caractère, défini, non initialisé.
i est un entier, défini, non initialisé.
x est un tableau défini de 100 réels x[0] à x[99].
count est un entier, défini et initialisé
à la valeur 1.
file est un pointeur défini, pointant sur une chaîne
de caractères initialisée.
cplx est une structure définie comportant
2 flottants.
up et down sont 2 valeurs énumérées initialisées :
up=0, down=1.
Exemple d’instructions qui ne sont que des déclarations
(pas de définition -> pas d’allocation en mémoire) :
extern int nb_node;
int f(int);
typedef unsigned int U_Int;
struct S;
class Node;
&
Conception et Programmation OO
//
//
//
//
//
//
//
nb_node est un entier, défini ailleurs.
f : fonction qui prend un entier en argument,
qui retourne un entier, définie ailleurs.
U_Int est un ’type défini’ identique à un entier
non signé.
S est une structure non définie.
Node est une classe non définie.
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 12/120
%
'
$
C++ de base : Déclaration/Définition des identificateurs
➔ Déclaration de plusieurs identifiants en une seule déclaration :
liste de déclarateurs séparés par des virgules
[descripteur] Type déclarateur1 [=init1], déclarateur2 [=init2], ...
➔ Attention, les opérateurs de déclaration ( *,&,[] et ()) portent sur un seul nom, pas sur tous
les noms d’une liste :
int
int
int
int
*p, q;
x, *y;
v[10], w;
*a, *b, *c;
&
Conception et Programmation OO
'
//
//
//
//
<=>
<=>
<=>
<=>
int
int
int
int
*p; int q;
x; int *y;
v[10]; int w;
*a; int *b; int *c;
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 13/120
%
$
C++ de base : La déclaration comme instruction
➔ En C++, la déclaration d’une variable est considérée comme une instruction :
✓ une déclaration peut apparaître dans le code source partout où peut figurer une instruction ;
✓ C++ permet de placer les déclarations n’importe où dans le programme
(là où on en a besoin par exemple ! ) ...
✓ ... contrairement au C où les déclarations des variables doivent apparaître en début de bloc ;
Par exemple, si une variable ne sert qu’à compter des tours de boucle :
for (int i=0; i <= Imax; ++i)
{
// corps de boucle : i est un entier défini
}
// à partir d’ici, la variable i de la boucle n’est plus définie
...
✓ Les expressions figurant au titre de valeur initiale n’ont pas besoin d’être constantes : elles
peuvent utiliser des termes qui ne seront connus qu’à l’exécution ;
✓ La définition d’une variable peut déclencher des traitements complexes liés à l’évaluation
de la valeur d’initialisation ;
Il est donc pertinent de parler de l’exécution de la définition de variable !
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 14/120
%
'
$
C++ de base : Portée d’une déclaration
➔ La déclaration d’une variable associe un identificateur qui possède une portée globale ou
locale :
✓ Un identificateur a une portée globale s’il est déclaré en dehors d’une fonction, d’une
classe ou d’un espace de nom ;
✓ La portée d’un identificateur global s’étend du point de déclaration à la fin du fichier ;
✓ Un identificateur a une portée locale s’il est déclaré dans une fonction, ou dans un bloc ;
✓ La portée d’un identificateur local s’étend depuis le point de déclaration
jusqu’à la fin du bloc où se trouve cette déclaration ;
✓ La définition d’une variable locale est exécutée lorsque le contrôle atteint le point où elle
est écriteé ;
✓ Un identificateur global peut être masqué par un identificateur local ;
✓ Un identificateur local peut être masqué par un identificateur déclaré dans un sous-bloc ...
✓ On peut faire référence à un identificateur global masqué grâce à l’opérateur de
résolution de portée ’::’.
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 15/120
%
$
C++ de base : Portée d’une déclaration
Exemple :
int x=100;
void f()
{
int y=x;
int x=1;
y=x;
{
int x;
x=20;
y=x;
}
x=x+1;
x=::x;
// Déclaration de x (identificateur global), initialisé à 100.
//
//
//
//
//
y reçoit la valeur 100 (x référence le x global puisqu’aucune autre
variable de nom x n’a encore été déclarée.
x est local à la f, et masque le x global (::x)
y reçoit la valeur du x local à la fonction,
qui masque le x global (y=1).
//
//
//
//
//
//
Nouveau bloc,
et déclaration d’un x local à ce nouveau bloc, masquant
le x local à f et le x global.
affectation du x local au bloc.
y reçoit la valeur du x local au bloc (y=20).
Fin du bloc (toutes les variables locales sont détruites).
// x local à la fonction est incrémenté et vaut maintenant 2
// x local à la fonction vaut maintenant 20 (::x référence le x global)!
}
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 16/120
%
'
$
C++ de base : Les Initialisations
➔ La définition d’un identificateur peut fournir un initialisateur explicite, sinon :
✓ Une variable globale, ou locale statique est initialisée avec la valeur nulle de son type ;
✓ Les variables locales et les objets créés dynamiquement ne sont pas initialisés par défaut ;
int a;
double d;
void f() {
int x;
}
// a est initialisé à 0 (valeur nulle du type int).
// d est initialisé à 0.0 (valeur nulle du type double).
// variable locale : x a une valeur quelconque !
➔ Les membres des tableaux et des structures sont initialisés par défaut ou non,
selon que le tableau ou la structure sont statiques ou non ;
➔ Complexité des règles d’initialisation par défaut => initialiser explicitement les objets
avant de s’en servir !
➔ Les classes ont une initialisation définie par une fonction spéciale (constructeur) ;
➔ Les objets plus compliqués nécessitant initialisation par une liste de valeurs peuvent utiliser la
syntaxe entre accolades (issue du C) :
int a[]={1,2,3,4};
Point z(0.1, 4.5);
&
Conception et Programmation OO
'
// a est un tableau de 4 entiers initialisés.
// Point désigne une classe qui possède un constructeur
// prenant 2 coordonnées réelles.
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 17/120
%
$
C++ de base : Objet, lvalue et rvalue
➔ Un objet (sens général) est une région contiguë de la mémoire qui peut être lue où écrite ;
➔ lvalue "left value" : quelque chose qui peut être du côté gauche d’une affectation ;
✓ Dans a=2*x+3, a est une lvalue ;
✓ Une lvalue est une expression qui fait référence à un objet ;
✓ Attention : une lvalue ne permet pas toujours de modifier l’objet référencé
(un objet const a une lvalue non-modifiable) ;
➔ rvalue "read value" ou "right value" : quelque chose qui peut être du côté droit d’une
affectation ;
✓ Dans a=2*x+3, l’expression 2*x+3 est une rvalue, dont la valeur est affectée à a ;
✓ Une rvalue désigne la valeur d’un objet ;
➔ Une variable possède une lvalue (son adresse), et une rvalue (sa valeur);
Une constante n’a qu’une rvalue.
x = 5; // OK : 5 est une rvalue, x peut être une lvalue.
5 = x; // KO : instruction illégale. Une constante n’est pas adressable
//
et ne peut donc pas etre une lvalue.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 18/120
%
'
$
C++ de base : Les types de base
➔ Les types fondamentaux (issus de ceux du C, plus le type booléen) :
✓ booléen (bool) ;
✓ caractère (char) ;
✓ entier (int) ;
✓ virgule flottante float) ;
✓ virgule flottante double précision (double) ;
✓ void, type "vide" utilisé pour marquer l’absence d’information.
✓ booléen, caractère et entier constituent le type intégral
(pouvant contenir des valeurs entières) ;
➔ Les types définissables par l’utilisateur :
✓ Les types énumérés (enum) pour représenter des ensembles de valeurs spécifiques ;
✓ Les types structure (struct), union (union) et classe (class).
➔ Les types dérivés :
✓ Pointeur sur un type de base (int *) ;
✓ Tableau d’éléments d’un type de base (int [])
✓ Référence sur un type de base (int &)
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 19/120
%
$
C++ de base : Le type booléen
Le type booléen :
➔ Spécifique au C++, comporte 2 valeurs : true et false ;
➔ Le résultat d’une opération logique ( &&, ||, ...) est de type booléen ;
➔ Il est déconseillé de prendre des entiers pour les booléens, et réciproquement ;
int x;
...
if (x)
// écriture très courante en C, déconseillé en C++
if (x !=0 ) // version conseillée en C++
...
bool is_greater(double x, double y)
{
const double epsilon=1.e-6;
return x >= y + epsilon;
// le résultat de >= est un bool
}
//
➔ Conversion implicite : dans les expressions mélangeant booléens, entiers et flottants,
les booléens sont convertis en entièrs :
✓ true correspond à la valeur 1 ;
✓ false correspond à la valeur 0.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 20/120
%
'
$
C++ de base : Le type booléen
➔ Réciproquement, un entier (ou un pointeur) peut être converti en booléen :
✓ un entier (ou un pointeur) non nul est converti en booléen true ;
✓ un entier (ou un pointeur) nul est converti en booléen false.
void g()
{
bool a = true;
bool b = true;
int i, j;
i = a ;
j = a + b;
bool c = a/b;
}
&
Conception et Programmation OO
'
// conversion implicite booléen->entier : i vaut 1
// conversion implicite booléen->entier : j vaut 1+1=2
// conversion implicite booléen->entier : j vaut 1/1=1
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 21/120
%
$
C++ de base : Les types caractère
Le type caractère char :
➔ Permet de stocker un caractère appartenant au "jeu de caractères" utilisé ;
➔ Occupe un octet en mémoire (dans la plupart des implémentations !!) ;
➔ Peut être signé (valeur négatives autorisées) ou non, selon l’implémentation ;
➔ Il est (presque toujours) garanti que le jeu de caractères utilisés comprend au minimum :
✓ les chiffres 0 à 9 ;
✓ les 26 caractères alphabétiques de l’anglais (a à z), en minuscule et en majuscule ;
✓ "quelques autres caractères" de base : +, -, #, <, >, /, !, [, ],& ...
➔ Chaque caractère ASCII possède une valeur entière
(représentable sur un octet -> code ASCII) ;
Les types caractère signé et caractère non signé :
➔ le type signed char désigne un caractère
codé sur un octet signé de 8 bits (valeur décimale entre -128 et 127) ;
➔ Le type unsigned char désigne un caractère
codé sur un octet non-signé de 8 bits (valeur décimale entre 0 et 255) ;
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 22/120
%
'
$
C++ de base : Constantes littérales de type caractère
➔ Écriture entre quotes simples, directe, octale, hexadécimale, ou spéciale (caractère ’\’) :
’a’
’\ooo’
’\xhh’
’\0’
’\n’
’\t’
’\v’
’\b’
’\r’
’\f’
’\a’
’\\’
’\?’
’\’’
’\"’
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
Cte
Cte
Cte
Cte
caractère,
caractère,
caractère,
caractère,
notation directe : un caractère entre quotes
notation octale (o : chiffre entre 0 et 7)
notation hexadécimale (h : chiffre hexadécimal)
notation spéciale (ASCII NULL)
saut de ligne
tabulation horizontale
tabulation verticale
backspace
retour chariot (carriage return)
saut de page (form feed)
alerte
backslash
point d’interrogation
apostrophe
guillemet
➔ Exemples de déclarations de variables de type caractère utilisant des constantes littérales :
char
char
char
char
char
&
car=’A’;
c=’\101’;
d=65;
e=’\x41’;
*p_car=&c ;
//
//
//
//
//
car est une variable
c : variable de type
d : variable de type
e : variable de type
p_car : pointeur sur
Conception et Programmation OO
'
de type char, initialisée à ’A’
char, initialisée à ’A’ (octal \101)
char, initialisée à ’A’ (décimal 65)
char, initialisée à ’A’ (hexadécimal 41)
caractère, pointant sur la variable car
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 23/120
%
$
C++ de base : Les types entiers
➔ Les types entiers du C++ sont :
✓ l’entier (int) : représente un entier ordinaire signé
(valeurs entières positives ou négatives) ;
✓ l’entier court (short int) ;
✓ l’entier long (long int) ;
✓ l’entier signé (signed int) ;
✓ l’entier non-signé (unsigned int) ;
➔ Les mots clefs signed et unsigned permettent de préciser explicitement si un int est
signé ou pas ;
➔ le type unsigned int est parfaois utilisé pour gérer la mémoire comme un tableau de bits ;
➔ Les valeurs littérales entières peuvent être écrites en base 10, 8 ou 16 :
int
int
int
int
&
p=123;
q=-100;
i=0237;
j=0x3f9b;
Conception et Programmation OO
// valeur entière décimale
//
"
// valeur entière octale non signée (commence par un zéro)
// valeur entière hexadécimal non signée (commence par 0x)
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 24/120
%
'
$
C++ de base : Taille des types entiers et caractère
➔ La taille mémoire des types entier et caractère n’est pas spécifiée dans la norme,
dépend de l’implémentation du compilateur C++ ;
➔ Indications de la norme C++ :
✓ Le plus petit type entier est le type char ;
✓ Le type int est celui qui permet de stocker les entiers au format natif du micro-processeur
utilisé (2 octets pour des processeurs 16 bits, 4 octets pour des proceseurs 32 bits, 8 octets
pour des processeurs 64 bits, ...) ;
➔ Dans la plupart des cas, on observe les résultats suivants:
Architecture micro-processeur
&
Conception et Programmation OO
Type
16 bits
32 bits
64 bits
char
8 bits
8 bits
8 bits
short int
16 bits
16 bits
16 bits
int
16 bits
32 bits
32 bits
long int
32 bits
32 bits
64 bits
OO3.tex v1.1 imprimé le 23 Octobre 2006
'
page 25/120
%
$
C++ de base : Les types virgule flottante
➔ Les nombres décimaux, rationnels ou réels sont représentés en virgule flottante,
avec plusieurs précisions possibles :
✓ Le type float représente des flottants simple précision (norme ISO/IEEE 754) ;
✓ Le type double représente des flottants double précision (norme ISO/IEEE 754) ;
✓ Le type long double représente des flottants en précision étendue,
(codage selon l’implémentation).
➔ Les valeurs flottantes sont écrites sous la forme :
[signe] chiffres [.[chiffres]][e|E [signe] exposant] [f|F|l|L] ;
➔ Par défaut une constante numérique contenant un point décimal est interprétée comme un
double par le compilateur ;
1.3E-6
2.7e6
3.12E9f
3.12E9F
1.33l
1.33L
&
Conception et Programmation OO
//
//
//
//
//
//
Cte flottante (type double par défaut)
Cte
"
Cte flottante (type float)
Cte
"
Cte flottante (type long double)
Cte
"
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 26/120
%
'
$
C++ de base : Le type void
➔ Bien que void soit un type fondamental, il n’existe pas à proprement parler d’objet de type
void ;
➔ Le type void peut être utilisé :
✓ Pour spécifier qu’une fonction ne retourne rien ;
✓ Pour préciser qu’un pointeur pointe sur un type non précisé.
➔ C : tout pointeur quelconque "T *" peut être converti explicitement ou implicitement vers le
type "void *" et réciproquement ;
➔ C++ : seule la conversion de "T *" vers "void *" est permise.
void a;
void f();
void *pv;
int *pi;
pv=pi;
pi=pv;
// erreur : il n’existe pas de variable de type void
// OK : déclaration d’un fonction f qui ne retourne rien
// OK : déclaration d’un pointeur sur un type inconnu
// pointeur sur un entier
// OK en C et en C++
// Erreur en C++, OK en C.
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 27/120
%
$
C++ de base : Les constantes littérales
➔ Toute constante littérale possède un type associé ;
➔ Une constante littérale entière est associée par défaut au type int ;
➔ Une constante littérale entière commençant par :
✓ Un zéro (0), désigne un entier non-signé en base 8;
✓ Un 0x ou (0X), désigne un entier non-signé hexadécimal ;
✓ Un caractère différent de zéro, désigne un entier (en base 10).
20
024
0x22
// constante littérale entière décimale
// constante littérale entière octale ( valeur décimale : 2*8+4=20)
// constante littérale entière hexadécimale (valeur décimale : 2*16+2=34)
➔ Constante littérale entière longue ou signée :
✓ Un l (ou L) à la fin désigne un entier long (long int)
(la notation L (majuscule) est préferable, car l ressemble trop au chiffre 1);
✓ Un u (ou U) à la fin désigne un entier non-signé (unsigned int) ;
20u
20L
20Lu
&
// constante littérale entière décimale non signée
// constante littérale entière décimale longue
// constante littérale entière décimale longue non signée
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 28/120
%
'
$
C++ de base : Les constantes littérales
➔ Une constante littérale en virgule flottante est associée par défaut au type flottant double
précision (double) ;
➔ Une constante littérale flottante peut être écrite :
✓ en notation décimale : par exemple 3.14 ;
✓ en notation avec exposant :
1.25e3 désigne 1.25 103 (l’exposant peut être noté ’e’ ou ’E’) ;
➔ Constante littérale simple précision ou précision étendue ;:
✓ un f (ou F) à la fin désigne un flottant simple précision (float) ;
✓ un l (ouL) à la fin désigne un flottant précision étendue (long double).
0.1f
0.1L
&
Conception et Programmation OO
'
// constante littérale flottante simple précision (float)
// constante littérale flottante double précision (long double)
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 29/120
%
$
C++ de base : Les constantes littérales
➔ Une constante littérale caractère est associée au type caractère (type char) ;
➔ Une constante littérale caractère peut être écrite :
✓ Explicitement entre quotes (apostrophes) : par exemple ’a’, ’\n’ ;
✓ En notation octale ’\ooo’, où ooo représente au plus trois chiffres en base 8
par exemple ’\123’ ;
✓ En notation hexadécimale ’\xhh’, où hh représente au plus deux chiffres hexadécimaux
par exemple ’\x5e’ ;
➔ une constante littérale chaîne de caractères est donnée entre guillemets :
par exemple "Donner une valeur" ;
➔ Les chaînes de caractères sont traitées comme des tableaux de caractères consécutifs ;
➔ La fin d’une chaîne est marquée par le caractère ASCII nul (’\0’) ;
➔ Une chaîne de caractères occupe en mémoire un octet de plus que sa longueur utile ;
➔ On peut affecter une constante chaîne de caractère à un pointeur de caractères (char *) ou à
un tableau de caractères (char []) :
char *v1 = "Paris"; // v1 pointe sur une zone mémoire (non modifiable)
// de 6 octets : |P|a|r|i|s|0|
char v2[]= "Paris"; // v2[0]=P, v2[1]=a, v2[2]=r, v2[3]=i, v2[4]=s et v2[5]=0.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 30/120
%
'
$
C++ de base : Les constantes littérales
➔ Remarques :
✓ Le compilateur ajoute automatiquement le caractère nul à la fin d’une chaîne écrite entre
guillemets ;
✓ La constante littérale ’a’ occupe un octet (le caractère a),
la constante littérale "a" occupe 2 octets (a+\0) ;
✓ Le compilateur alloue de la mémoire statique à une constante littérale chaîne de caractères :
- on ne peut pas la modifier directement ;
- on peut retourner une constante littérale chaîne depuis une fonction.
✓ Si l’on veut modifier une constante littérale chaîne de caractères, il faut la copier dans un
tableau :
char *v1 = "Paris";
char v2[]= "Paris";
v1[0]=’p’; // Erreur : v1 ne permet pas de modifier
// la copie de la chaîne de caractère.
v2[0]=’p’; // OK : v2 le permet.
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 31/120
%
$
C++ de base : Taille des type / Opérateur sizeof
➔ L’opérateur sizeof retourne la taille en octet d’un objet ou d’un type :
#include <iostream>
using namespace std;
int main()
{
cout << "Sizeof (en octets): " << endl;
cout << "char
: " << sizeof(char) << endl;
cout << "short int : " << sizeof(short int) << endl;
cout << "int
: " << sizeof(int) << endl;
cout << "long int
: " << sizeof(long int) << endl;
cout << "float
: " << sizeof(float) << endl;
cout << "double
: " << sizeof(double) << endl;
cout << "long double: " << sizeof(long double) << endl;
return 0;
}
À l’exécution sur un PC :
Sizeof (en octets) :
char
: 1
short int : 2
int
: 4
long int
: 4
float
: 4
double
: 8
long double: 12
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 32/120
%
'
$
C++ de base : Intervalle des types de base
➔ L’implémentation des types de base détermine la gamme des valeurs possibles ;
➔ En C, les fichier limits.h, et float.h donnent (sous forme de macros) les valeurs
numériques caractéristique (min, max, ...) des types entiers et flottants :
#include <iostream>
#include <float.h>
#include <limits.h>
using namespace std;
int main()
{
cout << " short int (min, max) : " <<
cout << "
int (min, max) : " <<
cout << "Float (min, max, epsi) : " <<
<<
cout << "Double (min, max, epsi): " <<
<<
}
SHRT_MIN <<
INT_MIN <<
FLT_MIN <<
FLT_EPSILON
DBL_MIN <<
DBL_EPSILON
", " <<
", " <<
", " <<
<<endl;
", " <<
<<endl;
SHRT_MAX <<"\n";
INT_MAX <<"\n";
FLT_MAX <<", "
DBL_MAX
<<", "
à l’exécution sur un PC :
short int (min, max) :
int (min, max) :
Float (min, max, epsi) :
Double (min, max, epsi):
&
Conception et Programmation OO
'
-32768, 32767
-2147483648, 2147483647
1.17549e-38, 3.40282e+38, 1.19209e-07
2.22507e-308, 1.79769e+308, 2.22045e-16
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 33/120
%
$
C++ de base : Intervalle des types de base
➔ En C++, on peut utiliser les fichiers du C, ou utiliser la classe template numeric_limits :
- prend comme paramètre template un nom de type ;
- possède des méthodes (min(), max(), ...) retournant les valeurs caractéristiques ;
#include <iostream>
#include <limits>
using namespace std;
int main()
{
cout << "
short int (min, max) : " <<
<<
cout << "
int (min, max) : " <<
<<
cout << " Float (min, max, epsi): " <<
<<
<<
cout << "Double (min, max, epsi): " <<
<<
<<
numeric_limits<short int>::min() <<", "
numeric_limits<short int>::max() <<"\n";
numeric_limits<int>::min()
<<", "
numeric_limits<int>::max()
<<"\n";
numeric_limits<float>::min()
<<", "
numeric_limits<float>::max()
<<", "
numeric_limits<float>::epsilon() <<endl;
numeric_limits<double>::min()
<<", "
numeric_limits<double>::max()
<<", "
numeric_limits<double>::epsilon()<<endl;
}
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 34/120
%
'
$
C++ de base : Le type énumération
➔ Le type énumération enum représente un ensemble de valeurs entières (les énumérateurs) ;
➔ En C++ une énumération devient un nouveau type défini par l’utilisateur ;
➔ Contrairement au C, il n’est pas nécessaire de rajouter le mot clef enum pour utiliser un
identifiant de type énuméré ;
➔ L’énumération permet de définir des constantes entières nommées
(constante entière symbolique) ;
➔ Par défaut, la valeur des énumérateurs est attribuée par le compilateur par valeur croissante à
partir de 0 :
enum {faux, vrai}
enum RGB {Red, Green, Blue};
enum RGB Red_color=Red;
RGB Blue_color=Blue;
//
//
//
//
//
//
//
énumération anonyme, faux=0 et vrai=1.
En C
: le type est "enum RGB",
en C++ : le type est "RGB".
Red, Green et Blue sont des constantes
entières nommées (Red=0, Green=1, Blue=2).
C
: Red_color a le type "enum RGB"
C++ : Blue_color a le type "RGB" (c’est un enum).
➔ Le même énumérateur ne peut pas être utilisé deux fois dans un même espace de visibilité :
enum Couleur {Vert, Orange, Rouge};
enum Fruit {Pomme, Poire, Orange};
&
Conception et Programmation OO
'
// Erreur : "Orange" déja défini
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 35/120
%
$
C++ de base : Le type énumération
➔ On peut initialiser un énumérateur avec une expression-constante de type intégral
(bool, char ou int) :
enum
enum
enum
enum
Status { KO=-1, OK=0, Unknown=999 };
{vrai=true, faux=false);
Car {A=’a’, B=’b’, NL=’\n’};
Code {d0=10,d1,d2,c0=100,c1,c2};
// vrai=1, faux=0
// d1=11, d2=12, c1=101, c2=102
➔ Conversion implicite enum <-> int ;
✓ Un énumérateur peut être converti implicitement en type entier en prenant simplement sa
valeur entière ;
✓ Par contre, il n’y a pas de conversion implicite du type entier vers un type énuméré ;
➔ Conversion explicite enum <->int :
✓ Un énumérateur peut être converti explicitement en entier;
✓ Un valeur de type intégral peut être converti explicitement en énumérateur si elle
appartient à l’intervalle de l’énumération ;
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 36/120
%
'
$
C++ de base : Le type énumération
➔ L’intervalle d’une énumération contient toutes les valeurs des énumérateurs,
arrondi à la puissance de 2 supérieure, moins 1 ;
➔ Cet intervalle part de 0, si le plus petit énumérateur est positif,
ou de la puissance de 2 négative la plus proche, si le plus petit énumérateur est négatif ;
enum e1 {a=3, b=5};
enum e2 {a,b,c=9};
// intervalle 0,7
// intervalle 0,15
enum flag {x=1,y=2,z=4,e=8}; // intervalle 0,15
// Conversions implicites :
int x1=x;
// OK
: conversion implite enum -> entier (x1=1)
flag f1=5;
// erreur : pas de conversion implicite int -> enum
// Conversions explicites :
int yy=int(y);
// OK : conversion explicite d’un enum en int
int zz=static_cast<int>(z); // OK : idem
flag f2=flag(5);
// OK : conversion explicite d’un int en flag (5 est
// dans l’intervalle de l’enum "flag")
flag f3=flag(12);
// OK : idem (12 est dans l’intervalle de l’enum)
flag f4=flag(99);
// indéfini : 99 n’est pas dans l’intervalle de l’enum
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 37/120
%
$
C++ de base : Le type structure
➔ Une structure est un agrégat d’éléments de types arbitraires ;
➔ Les éléments de la structure sont les champs (les membres) ;
➔ En C++, une structure est une classe dont tous les membres sont public par défaut ;
➔ On déclare une structure avec le mot-clef struct, suivi de la liste typée des membres entre
accolades ;
struct id_struct
{
type nom_membre1;
...
type nom_membreN;
} [var1, var2, ...];
// Déclaration de la structure "id_struct"
// Définition optionnelle de variables de type "id_struct"
➔ La déclaration d’une structure sans identificateur déclare une structure anonyme ;
➔ Noter le ’;’ terminant la déclaration d’une structure
(rare cas en C++ où l’on a un ’;’ après une accolade fermante).
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 38/120
%
'
$
C++ de base : Le type structure
➔ En C++ l’identifiant placé après struct devient un nouveau nom de type
(en C le nom du type est struct id_struct) :
struct Point
// Déclaration de la structure Point
{
// le type C est "struct Point", le type C++ est "Point"
Point *next;
Point *prev;
char *ident;
double x;
double y;
};
//
// Définition de variables de type Point
//
Point p1;
// Définition de la var. p1 de type "point" (non initialisée)
➔ On peut initialiser une structure lors de sa définition :
✓ La liste des données est fournie entre accolades ;
✓ L’initialisation doit respecter le même ordre que celui de la déclaration :
Point p2={&p1,0,"P2",1.e2,-1e2};
&
Conception et Programmation OO
'
// Déf. de p2 de type "Point", initialisée
// &p1 désigne l’adrese de la var. p1
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 39/120
%
$
C++ de base : Le type structure
➔ Une déclaration anticipée (forward declaration) déclare l’identifiant d’un type structure,
mais ne défini pas pas son contenu ;
➔ Utile pour déclarer des pointeurs sur le type de la structure :
struct Personne;
// Déclaration incomplète du type structure "Personne",
struct Voiture
{
int puissance;
Marque marque;
Personne *propriétaire;
Personne *conducteur;
}
&
Conception et Programmation OO
// propriétaire : pointeur sur le type Personne
//
idem
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 40/120
%
'
$
C++ de base : Le type structure
➔ L’accès aux membres d’une structure se fait en utilisant la syntaxe :
identifiant.nom_du_membre
ou
identifiant->nom_du_membre
suivant que identifiant représente une structure, ou un pointeur sur une structure.
//
// accès aux membres de la structure par l’opérateur ’.’
//
Point p3;
p3.next=p3.prev=0;
p3.ident="P3";
p3.x=p3.y=1.e2;
//
// accès aux membres d’un pointeur de structure par l’opérateur ’->’
//
Point * p_p2=&p2;
// &p2 désigne l’adresse de p2
cout << "p2->ligne = " << p2->ligne << endl;
cout << "p2->next = " << p2->next << endl;
cout << "p2->prev = " << p2->prev << endl;
cout << "p2->x = " << p2->x << endl;
cout << "p2->y = " << p2->y << endl;
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 41/120
%
$
C++ de base : Le type structure
➔ On peut déclarer qu’un membre d’une structure n’occupe que sur quelques bits
(on parle de champ de bits) ;
➔ La taille d’un champ de bits ne peut pas excéder la taille d’un entier ;
➔ Un champ de bits se déclare comme un membre d’une structure se terminant
par le caractère ’:’ suivi du nombre de bits du champ :
struct BitAccess
{
int bit0:1;
int bit1:1;
int bit2:1;
int bit345:3;
int bit67:2;
};
&
Conception et Programmation OO
//
//
//
//
//
1
1
1
3
2
bit
bit
bit
bits
bits
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 42/120
%
'
$
C++ de base : Le type union
➔ Une union désigne une structure de données dont tous les membres partagent le même
emplacement mémoire ;
➔ On ne peut donc, à tout instant, n’utiliser qu’un seul des membres de l’union ;
➔ La déclaration d’une union est identique à celle d’une structure, avec le mot clef union :
union id_union
{
type nom_membre1;
...
type nom_membreN;
} [var1, var2, ...];
// Déclaration de l’union "id_union"
// Définition optionnelle de variables de type "id_union"
id_union nom_variable; // Définition
d’une var. de type "id_union"
➔ La déclaration d’une union sans identificateur déclare une union anonyme ;
➔ La quantité de mémoire utilisée par une union se limite à la taille de son membre le plus large ;
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 43/120
%
$
C++ de base : Le type union
➔ Les unions ne sont utilisées que dans des cas spécifiques :
✓ Pour économiser de la mémoire (!!) ;
✓ Pour interpréter différemment des données selon le contexte :
enum TypeEntree {Int, Float, Double};
struct Entree {
// Entree lue au clavier
TypeEntree type;
union {
// union anonyme
int Ivalue;
double Dvalue;
};
};
Entree entree;
...
// Exemple d’utilisation
//
switch (entree.type)
{
case Int:
cin >> entree.Ivalue; // cin : entrée clavier
break;
case Float:
cin >> entree.Dvalue;
break;
}
...
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 44/120
%
'
$
C++ de base : Les alias de type
➔ L’opérateur typedef définit de nouveaux noms de types comme synonyme de types
existants :
➔ L’opérateur typedef ne crée pas de nouveaux types, seulement des noms synonymes ;
typedef type_existant nom_synomyme;
typedef unsigned char uchar;
typedef char *p_char;
// uchar est un synonyme pour unsigned char.
// p_char est est synonyme de char *.
➔ Les noms synonymes sont utilisés pour simplifier l’écriture des programmes, ou améliorer leur
lisibilité (!!) ;
typedef int M10x10[10][10];
//
//
typedef union {int i; p_char pc} IPC; //
typedef double (*PF)(double, double); //
//
//
M10x10 est synonyme pour une matrice
d’entiers 10x10
IPC : synonyme de l’union {entier; char *}
PF : synonyme d’un pointeur sur une
fonction qui retourne un double et
prend 2 arguments double.
➔ La déclaration des typedef peut parfois prendre des formes syntaxiquement difficiles à
déchiffrer (!!) ;
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
'
page 45/120
%
$
C++ de base : Les tableaux
➔ C et C++ proposent une implémentation "bas niveau" des tableaux (tableaux intégrés),
suite contiguë de données de même type ;
➔ Préférer les tableaux plus évolués de la bibliothéque standard C++ :
- vector, conteneur générique à une dimension,
- valarray, tableau numérique ...
➔ Déclaration d’un tableau :
Type identifiant [nb_elements]
ou
Type identifiant []
➔ C++ : la taille d’un tableau peut être donnée par une expression non constante ;
➔ Les tableaux du C++ et du C commencent à l’indice 0 (zéro) ;
int i=10
const int size=10;
enum {Size=10};
int t1[i];
int t2[size];
int t3[Size];
int t[3];
Point *tab_pt[5];
&
Conception et Programmation OO
//
//
//
//
//
//
//
//
//
i : entier non constant.
size : constante entière.
Size : énumération entière.
OK, la valeur de i est prise pour dimensionner t1,
mais dangereux car i peut changer après!
OK, size est une constante.
OK, Size est une constante énumérée.
tableau de 3 entiers :t[0], t[1] et t{2]
tableau de 5 pointeurs sur Point
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 46/120
%
'
$
C++ de base : Les tableaux
➔ Un tableau peut être initialisé à la déclaration par une liste de valeurs entre accolades ;
➔ Une liste incomplète est complétée avec l’élément null du type des éléments (dangereux !!) ;
➔ Une liste trop longue provoque une erreur de compilation ;
➔ On peut laisser le compilateur évaluer la dimension d’un tableau :
int t1[3]={10,20,30};
int t2[3]={10};
int T2[]={1,2,3,4};
// Initialisation à la déclaration.
// t2[0]=10, t2[1]=0, t2[2]=0 (initialisation incomplète)
// Tableau de 4 entiers (la dimension du tableau est
// calculée par le compilateur).
int mat[3][2]={{1,2},{2,3},{3,4}}; // Tableau de 3 tableaux de 2 entiers chacun
// <=> matrice 3 lignes, 2 colonnes.
//
col 0
Col 1
//
1
2
ligne 0
//
2
3
ligne 1
//
3
4
ligne 2
➔ C++ ne propose pas d’affectation de tableau avec une liste de valeurs :
t1={11,21,31};
// Erreur : pas d’affectation possible avec une liste de valeurs.
➔ L’opérateur d’indexation "[]" permet d’accéder à un élément particulier d’un tableau :
tab[0]=12;
mat[2][1]=13;
&
// affectation du premier élément du tableau
// affectation de l’élément ligne 2, colonne 1
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 47/120
%
$
C++ de base : Les tableaux
➔ Un tableau à plusieurs dimensions (matrice ...) est un tableau de tableaux ...
➔ La première dimension d’un tableau multi-dimensionnel peut être une expression non
constante, ou être déduite d’une initialisation :
double matrice[3][2];
//
//
matrice[2][1]=1.
//
//
int m[][3]={{1,1,1},{2,2,2}}; //
un tableau de 3 tableaux de 2 float,
<=> matrice de 3 lignes de 2 colonnes.
Double indexation pour référencer
un élément de la matrice.
mat : matrice 2 lignes 3 colonnes.
➔ Sauf raison particulière (écriture de code bas niveau : driver par exemple), il est préferable
d’utiliser des tableaux multi-dimensionnels évolués (classes) proposés par les bibliothèques
spécialisées (Blitz++, Boost, ...).
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 48/120
%
'
$
C++ de base : Les pointeurs
➔ Une adresse mémoire est une valeur entière : on peut la stocker dans une variable ;
➔ Un pointeur est une variable qui contient l’adresse d’un objet (il "pointe" sur l’objet) ;
➔ Les pointeurs ont un type : celui de l’objet pointé ;
➔ Le typage d’un pointeur permet au compilateur de vérifier les opérations réalisées avec ce
pointeur ;
➔ Pour un type quelconque T, la notation "T *" signifie "pointeur sur une variable de type T" ;
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
'
page 49/120
%
$
C++ de base : Les pointeurs
➔ Deux opérateurs sont liés à l’usage des pointeurs :
✓ l’opérateur unaire d’adressage &) retourne l’adresse d’une variable ;
✓ l’opérateur unaire d’indirection (*) donne un accès lecture/écriture à la variable pointée ;
int *p1, *p2, p3; // * doit être répété :
// p3 est un int, pas int *.
char c=’a’;
char *p=&c;
// p : pointeur de char, prend l’adresse de c.
char c1=*p;
// *p : dé-référencement, retour la valeur
//
pointée (c1 reçoit ’a’)
p
&c
...
c
’a’
mémoire
➔ L’opération d’indirection est aussi appelée dé-référencement ;
➔ Les pointeurs de pointeur, tableaux de pointeurs, pointeurs de tableaux
et pointeurs de fonctions requièrent une notation spécifique :
char **ppc;
int *m[10];
int (*M)[10];
float (*fp)(int);
&
Conception et Programmation OO
//
//
//
//
//
ppc : pointeur sur un pointeur de caractère.
m : tableau de 10 pointeurs sur entier.
M : pointeur sur un tableau de 10 entiers.
fp : pointeur sur une fonction qui prend un
argument entier et qui retourne un float.
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 50/120
%
'
$
C++ de base : Pointeur void *
➔ Le type "void *" permet de déclarer un pointeur générique désignant une adresse machine ;
➔ Un pointeur "void *" peut recevoir l’adresse de n’importe quel type d’objet :
Point p2={&p1,0,"P2",1.e2,-1e2};
void *pv=&p2;
➔ En C++, un pointeur typé ne peut pas recevoir la valeur d’un pointeur "void *" :
Point *p_pt=pv;
// erreur.
➔ On doit utiliser un opérateur de transtypage pour forcer un pointeur typé à recevoir un
pointeur "void *" :
Point *p_pt=static_cast<Point *>(pv); // OK, conversion forcée d’un "void *"
// en "Point *".
Point *p_pt=(Point *)pv;
// OK, idem façon C.
➔ Le dé-référencement et les opérations arithmétiques (addition, soustraction et indexation)
ne sont pas autorisés sur un pointeur "void *".
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 51/120
%
$
C++ de base : Pointeur de fonction
➔ Déclaration d’un pointeur de fonction :
type_retour (*identifiant)(type [arg1] [,type [arg2] ...])
float (*fp)(int);
...
float f(int j) {
// fp : pointeur sur une fonction qui prend un
// argument entier et retourne un float.
// f : fonction f prenant en argument un entier,
// et retournant un float.
return j*j;
};
fp = f;
// le pointeur fp pointe sur la fonction f.
➔ Appel de la fonction pointée :
fint i=(*fp)(2);
int j=fp(2);
// façon C : dé-référencement explicite de fp
// façon C++
➔ Remarque : un nom de fonction est synonyme d’un pointeur constant sur cette fonction.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 52/120
%
'
$
C++ de base : Arithmétique de pointeurs
➔ Les opérateurs +, -, ++ et -- peuvent être utilisés avec des pointeurs ;
➔ Soit le pointeur p de type "T *" :
✓ p+a ajoute a fois la taille du type T à p (p devient p+a*sizeof(T)) ;
✓ p-a retranche a fois la taille du type T à p (p devient p-a*sizeof(T)) ;
✓ l’opérateur ++ (resp. --), augmente (resp. diminue) p de sizeof(T) ;
double *p;
...
p=p+4;
p++;
p=p-2;
p--;
//
//
//
//
<=>
<=>
<=>
<=>
p=p+4*sizeof(double), soit : p=p+4*4=p+16 octets.
p=p+sizeof(double);
p=p-2*sizeof(double), soit : p=p-2*4=p-8 octets.
p=p-sizeof(double);
➔ Si le pointeut p pointe sur un élément d’un tableau :
✓ p+a déplace p de a éléments vers la fin du tableau ;
✓ p-a déplace p de a éléments vers le début du tableau ;
✓ p++ déplace p d’un élément vers la fin du tableau ;
✓ p-- déplace p d’un élément vers le début du tableau ;
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 53/120
%
$
C++ de base : Arithmétique de pointeurs
➔ Attention :
✓ le compilateur n’a aucun moyen de vérifier si les déplacements de pointeur prévus par le
programmeur conduisent à dépasser les limites du tableau en mémoire ;
✓ c’est au programmeur de le vérifier, faute de quoi on peut s’attendre à de superbes
plantages à l’exécution (!!) ;
✓ L’addition de 2 pointeurs n’est pas définie en C++ ;
✓ La soustraction de 2 pointeurs n’a de sens que s’ils vers le même tableau (nombre
d’éléments entre les 2 pointeurs).
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 54/120
%
'
$
C++ de base : Relation entre pointeur et tableau
➔ Il existe une relation étroite entre pointeurs et tableaux :
☞ un tableau peut être vu comme un pointeur constant pointant sur le premier élément ;
☞ les éléments d’un tableau sont donc accessibles avec des opérations sur les pointeurs.
➔ En C et C++, le nom d’un tableau est équivalent à l’adresse du premier élément du tableau :
01 int main()
02 {
03
const int size=5;
04
int tab[size];
// tab est <=> &tab[0]
05
cout << " tab :" << tab << endl;
06
cout << " &tab[0] :" << &tab[0] << endl;
07
int *px=&tab[0];
08
int *py=&tab[4];
09
int *pz=&tab[5];
10
for (int i=0; i<=size; ++i)
11
{
12
bool test = (*(px+i) == tab[i]);
13
if (test)
14
cout << "*(px+"<< i << ") == tab[" ;
15
cout << i <<"], " << px+i << endl;
16
}
17
int *pz=&tab[50];
18
*pz=10;
19
return 0;
20 }
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 55/120
%
$
C++ de base : Relation entre pointeur et tableau
➔ ligne 17 : le code source accède à l’élément tab[50] d’un tableau de 5 éléments (!!) ;
☞ le compilateur ne surveille pas les débordements des tableaux intégrés ;
☞ à l’exécution, on peut s’attendre à des surprises, surtout en cas d’écriture (!!) :
tab :0xbfa84218
&tab[0] :0xbfa84218
*(px+0) == tab[0], 0xbfa84218
*(px+1) == tab[1], 0xbfa8421c
*(px+2) == tab[2], 0xbfa84220
*(px+3) == tab[3], 0xbfa84224
*(px+4) == tab[4], 0xbfa84228
*(px+5) == tab[5], 0xbfa8422c
Erreur de segmentation
➔ On constate bien que :
✓ tab == &tab[0] : le nom du tableau <=> adresse du premier élément du tableau ;
✓ *(px+i) <=> tab[i] : on peut accéder aux éléments par arithmétique de pointeur ;
✓ l’écriture de l’élément tab[50] provoque le plantage du programme (!!).
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 56/120
%
'
$
C++ de base : Les références
➔ Les références existent en C++, pas en C ;
➔ Autre façon de manipuler les adresses des objets placés en mémoires ;
➔ Une référence est un synonyme permettant d’utiliser une variable sous un nom différent de
celui de sa déclartion ;
➔ Une référence doit être initialisée à sa déclaration, avec un objet existant en mémoire (lvalue) ;
➔ Toute opération effectuée sur une référence agit directement sur l’objet référencé ;
➔ Déclaration d’une référence sur une variable d’identifiant id_var est :
Type &id_ref = id_var
➔ Dans la déclaration d’une référence, & ne s’applique qu’à l’identificateur qui le suit :
int i=1, j=2;
int &r=i, s=j;
r=j;
//
//
//
//
//
r est une référence sur i, un synonyme de i.
s n’estpas une référence : c’est un entier initialisé
avec la valeur de j (2).
ceci ne transforme pas r en référence sur j,
mais copie la valeur de j dans i (i vaut 2).
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 57/120
%
$
C++ de base : Les références
➔ Une référence peut donner un nom à un objet qui n’en a pas :
int t[10];
int &first_t=t[O];
int &last_t=t[9];
first_t=last_t=0;
// first_t est un nom pour t[0].
// last_t est un nom pour t[9].
// <=> t[0]=t[9]=0
➔ Les références permettent une écriture plus simple des passage par adresse des arguments de
fonctions :
// version avec références
//
void swap(double &a, double &b)
{
double temp=a;
a=b;
b=temp;
}
// exemple d’appel :
double x, y[100];
...
swap(y[10],x);
&
Conception et Programmation OO
// version avec pointeurs
//
void swap(double *a, double *b)
{
double temp=*a;
*a=b;
*b=temp;
}
// exemple d’appel
double x, y[100];
...
swap(&y[10],&x);
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 58/120
%
'
$
C++ de base : Fonction retournant une référence
➔ Une fonction peut renvoyer une référence comme résultat ;
➔ Attention à ne pas retourner une référence sur un objet local, qui disparaît avec la fonction :
Matrice &produit(const Matrice &a, const Matrice &b) {
Matrice res; // res est une variable locale à la fonction.
...
return res; // PB : res est un objet local détruit quand on quitte produit()
}
➔ On peut définir une référence sur une expression constante, le résultat d’un calcul, ..., à
condition d’utiliser le modificateur const
(le compilateur crée un objet lvalue temporaire adressé par la référence) :
int &r = 100;
double &pi = atan(1);
const int &r = 100;
const double &pi = atan(1);
void f1(int &r);
void f2(const int &r);
int x;
f1(x);
f1(2*x+3);
f2(x);
f2(2*x+3);
&
Conception et Programmation OO
'
//
//
//
//
Erreur
Erreur
OK
OK
//
//
//
//
//
OK
Erreur l’évaluation de 2*x+3 donne
une expression constante
OK
OK
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 59/120
%
$
C++ de base : Constantes / Modificateur const
➔ Le mot clef const est un modificateur de type qui indique que l’objet déclaré est constant ;
➔ Un objet const ne peut pas être modifié :
il peut seulement être utilisé comme rvalue, pas comme lvalue ;
➔ Un identificateur déclaré const ne pouvant être modifié, doit obligatoirement être initialisé
lors de sa déclaration ;
➔ On peut modifier la déclaration de n’importe quel type avec le modificateur const,
y compris les pointeurs et les références ;
➔ Donnée constante
const type identificateur = valeur;
☞ on ne peut plus changer la valeur
const double PI=3.141592;
const int ic=10, jc=20;
int i;
ic=20;
// Erreur : ic est const, ne peut être modifié.
ic=i;
// Erreur : idem.
ic++;
// Erreur : idem.
ic=jc;
// Erreur : idem.
i=ic;
// OK : on peut affecter la valeur de ic à i.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 60/120
%
'
$
C++ de base : Constantes / Modificateur const
➔ Pointeur constant
type *const identificateur = adresse_objet;
☞ on ne peut pas changer d’objet pointé
int i, j;
int *const pci=&i;
*pci=100;
pci=&j;
j=*(pci++);
//
//
//
//
OK : le pointeur const pci doit être initialisé
OK : pci est const, pas la variable pointée
Erreur : pci est un pointeur const non modifiable
Erreur : idem
➔ Pointeur sur un objet constant
const type *identificateur;
☞ pointeur non-constant pointant sur un objet vu comme constant
☞ on ne peut pas utiliser ce pointeur pour modifier l’objet pointé
☞ le pointeur en lui-même n’étant pas constant n’est pas obligatoirement initialisé
☞ on peut lui affecter autant de fois qu’on veut l’adresse d’un objet
const int *pic;
const int ic=10;
int i;
pic=&ic;
pic=&i;
*pic=100;
&
Conception et Programmation OO
'
//
//
//
//
//
//
//
pic : pointeur sur un int constant.
ic : entier constant.
i : entier non-constant.
OK : ic est const, pic est un pointeur sur entier const.
OK : mais i est vu comme constant quand on utilise pic.
Erreur : le dé-référencement d’un pointeur sur const
est une variable cont (non-modifiable);
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 61/120
%
$
C++ de base : Constantes / Modificateur const
➔ Pointeur constant sur donnée constante
const type *const identificateur = adresse_objet;
☞ pointeur constant (on ne peut pas changer d’objet pointé)
☞ pointant sur un objet considéré comme une constante
(on ne peut pas modifier l’objet pointé)
const int ic=10;
const int *pic;
// pic : pointeur sur un int constant.
int i, *pi;
// pi : pointeur sur un int.
const int *const pcic=&i; // pcic : pointeur constant sur un int constant.
pi=pcic;
// Erreur : l’affectation entre pointeurs viole l’aspect
// pointeur sur const.
pi=pic;
// Erreur : idem.
pcic=&ic;
// Erreur : pcic est un pointeur const non modifiable.
// Erreur : le dé-référencement d’un pointeur sur const
*pcic=100;
// est une variable cont (non-modifiable).
pic=pcic;
// OK : l’affectation entre pointeurs respecte l’aspect pointeur
// sur const.
i=*pcic;
// OK.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 62/120
%
'
$
C++ de base : Constantes / Modificateur const
➔ Référence sur un objet constant
const type &identificateur = objet;
☞ référence sur un objet vu constant quand on l’accède par le biais de cette référence
☞ n’implique pas que l’objet lui-même soit const
int i;
//
const int ic=10; //
int &ri1 = i;
//
int &ri2 = ic;
//
const int &ric1=i;//
ric1=100;
//
const int &ric2=ic;
i : entier non-constant.
ic : entier constant.
OK , ri1 est une référence sur un int (i).
Erreur : l’initialisation de ri2 viole l’aspect const de ic.
OK , mais ric1 ne permet pas de modifier i.
Erreur
// OK, référence const sur un int const, RAS.
➔ Une référence const donne une "vue const" de l’objet référencé ;
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 63/120
%
$
C++ de base : Constantes / Modificateur const
➔ L’emploi du modificateur const est très recommandé, et doit être envisagé le plus tôt
possible lors de la conception ;
➔ Effets secondaires de l’usage de const :
✓ la portée d’un identificateur const est réduite au fichier où il est déclaré ;
✓ les expressions où un identificateurconst apparaît sont évaluées par le compilateur ;
➔ L’usage d’objets const est toujours préférable à celui des macros du C (#define) :
✓ un objet constant possède un type, contrairement à une macro ;
✓ le compilateur peut fournir l’adresse d’un objet constant (si besoin) :
const int buf_size = 14024;
int * p = &buf_size;
const int *p_size = &buf_size;
int & r = buf_size
const int &r_size = buf_size;
&
Conception et Programmation OO
//
//
//
//
//
//
//
//
buf_size : identificateur de type entier,
constant
Erreur : p n’est pas un pointeur sur un
entier const
OK
Erreur : r n’est pas une référence sur
un entier const
OK
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 64/120
%
'
$
C++ de base : Conversions implicite/explicite de type
Conversion implicite :
➔ Dans les expressions les types fondamentaux peuvent être mélangés librement ;
➔ Partout où c’est possible, le compilateur convertit les valeurs de façon à ne pas perdre
d’information ;
➔ On parle alors de promotion de type : par exemple, les expressions flottantes sont évaluées
comme des double.
Conversion explicite de type :
➔ Une opération de onversion explicite de type (transtypage) permet de préciser au compilateur
qu’un identificateur doit être considéré avec un type différent de celui de sa déclaration ;
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 65/120
%
$
C++ de base : Conversions implicite/explicite de type
Conversion explicite dans le style C (à éviter) :
➔ En C++, on peut toujours utiliser la conversion explicite du C :
(type) (expression) ou (type) expression
float x;
...
int i=(int)x
int i=10;
const int *p_i=&i;
// x est converti explicitement en entier (troncature).
//
//
const int &r_i=i;
//
//
//
*(int *)p_i =9;
cout << "i : " << i << endl; //
(int &)r_i = 8;
//
cout << "i : " << i << endl; //
p_i est un pointeur sur un int constant (i):
il ne permet pas de modifier i (normalement !).
r_i est une référence sur un int constant (i):
elle ne permet pas de modifier i (normalement !).
Danger : on neutralise l’aspect const de p_i !!!
Affiche 9 !!
Danger : on neutralise l’aspect const de p_i !!!
Affiche 8 !!
➔ Le PB des conversions explicites :
✓ pas toujours faciles à repérer dans le code ;
✓ aucun contrôle autre que celui du programmeur.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 66/120
%
'
$
C++ de base : Conversions implicite/explicite de type
➔ Le C++ permet d’écrire l’opération de conversion explicite vers les types fondamentaux avec
une "syntaxe de constructeur" :
type ( expression )
float x;
...
int i=int(x)
char c=’z’;
int code_z=int(c);
// x est converti explicitement en entier (troncature).
// c est converti explicitement en entier.
➔ Le C++ offre d’autres opérateurs de transtypage aux noms délibérément longs et voyants,
faciles à retrouver dans le code (traités plus loin);
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 67/120
%
$
C++ de base : Allocation de mémoire
Trois classes d’allocation : statique, automatique et dynamique.
➔ L’allocation statique concerne les objets :
✓ globaux, déclarés en dehors de toute fonction ou méthode de classe ;
✓ déclarés static explicitement dans une fonction ou une méthode de classe ;
➔ Un objet alloué statiquement :
✓ garde sa valeur d’un appel de la fonction / méthode à l’autre ;
✓ est créé dès le lancement du programme ;
✓ est détruit automatiquement en fin d’exécution du programme.
➔ L’allocation automatique concerne les objet créés sur la pile (stack) :
✓ variables temporaires définies dans une fonction / méthode ;
✓ objets renvoyés par une fonction / méthode, momentanément stockés sur la pile.
➔ Un objet automatique :
✓ est créé à chaque lancement de la fonction / méthode où il est déclaré ;
✓ est détruit automatiquement dès le retour à l’appelant.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 68/120
%
'
$
C++ de base : Allocation dynamique de mémoire
➔ L’allocation dynamique concerne les objets créés sur le tas (heap) ;
➔ Un objet alloué dynamiquement :
✓ est créé par appel explicite à l’opérateur new ;
✓ doit être détruit explicitement par un appel à l’opérateur delete ;
✓ n’est accessible que par un pointeur.
Bibliothèque C standard :
➔ Les fonctions malloc, calloc, free et realloc de la bibliothèque C standard restent
accessibles en C++ ;
➔ Il est conseillé de leur préférer les nouveaux opérateurs proposés par la bibliothèque C++
standard ;
Bibliothèque C++ standard :
➔ La bibliothèque standard du C++ propose les opérateurs new et delete pour les opérations
d’allocation/libération mémoire.
➔ Attention à ne pas mélanger entre eux : new, delete et malloc, free, ... (plantages
garantis !!) ;
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 69/120
%
$
C++ de base : Opérateur new
➔ L’allocation dynamique est faite dans la partie de la mémoire appellée "le tas" (heap) ;
➔ L’opérateur new renvoie :
✓ en cas de réussite, un pointeur du type demandé, pointant sur la zone mémoire allouée non
initialisée ;
✓ en cas d’échec, un pointeur nul ;
➔ Syntaxe :
Type *t = new Type
Type *t = new Type[n]
// allocation dynamique de mémoire pour un objet.
// allocation mémoire dynamique d’un tableau
// de n éléments de type Type.
int *pi = new int;
char **tab_p_char = new char *[100]
double *tab = new double [NB_DBLE];
//
//
//
//
//
allocation dynamique
allocation dynamique
de 100 pointeurs sur
allocation dynamique
de NB_DBLE flottants
d’un entier
d’un tableau
des chaines.
d’un tableau
double précision.
➔ Si Type ne possède pas de constructeur par défaut, le compilateur génère une erreur ;
➔ La dimension d’un tableau peut être donnée par une variable dont la valeur n’est pas connue à
la compilation ;
➔ L’échec de new produit le lancement d’une exception C++ (bad_alloc) ;
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 70/120
%
'
$
C++ de base : Opérateur delete
➔ L’opérateur delete libère (détruit) la mémoire allouée dynamiquement par l’opérateur new ;
➔ Il prend en argument un pointeur sur une zone mémoire allouée par new ;
➔ Pour un tableau, on doit utiliser la forme delete [] :
delete adresse
// libère la mémoire occupée par un objet
delete [] adresse; // libère la mémoire occupée par un tableau
➔ Le pointeur adresse peut être null, dans ce cas delete ne fait rien ;
➔ Par contre, c’est une erreur de libérer de la mémoire déjà libérée ;
int *p_int=new int;
// allocation d’un entier
typedef char *T10C[10];
// T10C : synonyme d’un tableau de pointeurs char *.
char **p_T10C=new char *[10]; // allocation dyn. de mémoire pour 10 pointeurs
// "char *", renvoi d’un pointeur char **.
T10C tab;
// allocation statique d’un tableau T10C.
delete [] p_T10C;
// Libération de la mémoire allouée.
int *p_null=0;
delete p_null;
// Pas de PB : delete 0 ne fait rien.
delete p_int;
// libération de l’adresse p_int.
delete p_int;
// liberation d’une adresse déjà libérée !!!
// PB à l’exécution :
//
*** glibc detected *** double free or
//
corruption (fasttop): 0x0804b9e8 ***
&
➔ Une bonne habitude est de mettre à zéro les pointeurs après libération mémoire.
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
'
page 71/120
%
$
C++ de base : Les principaux opérateurs
➔ Les principaux opérateurs de base du C++ sont classés ci-après par ordre de priorité
décroissante : chaque encadré regroupe des opérateurs de même priorité.
➔ Les opérateurs unaires et les opérateurs d’affectation sont associatifs à droite:
a=b=c est interprété comme a=(b=c)
*p++ est interprété comme *(p++) et non pas comme (*p)++
➔ tous les autres sont associatifs à gauche :
a+b+c est interprété comme (a+b)+c, et non pas a+(b+c).
&
Conception et Programmation OO
::
résolution de portée
classe::membre
::
global
::nom
.
sélection de membre
objet.membre
->
sélection de membre
pointeur->membre
[]
indexation
pointeur[expr]
()
appel de fonction
fonction(liste expr)
()
construction
type (liste expr)
++
post-incrémentation
lvalue++
--
post-décrémentation
lvalue--
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 72/120
%
'
sizeof
taille d’un objet
sizeof expr
sizeof
taille d’un objet
sizeof expr
++
pré-incrémentation
++lvalue
--
pré-incrémentation
--lvalue
~
complément
~expr
!
négation
!expr
-
moins unaire
- expr
+
plus unaire
+expr
&
adresse
&lvalue
*
déréfence
*expr
allouer
new type
delete
désallouer
delete pointeur
delte[]
désallouer tableau
delete[] pointeur
coercition
(type) expr
*
multiplication
expr * expr
/
division
expr / expr
%
modulo
expr % expr
new
()
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
'
+
addition
expr + expr
-
soustraction
expr - expr
=
affectation
lvalue = expr
<<
décalage binaire à gauche
expr < < expr
>>
décalage binaire à droite
expr > > expr
plus petit
expr < expr
plus petit ou égal
expr <= expr
plus grand
expr > expr
>=
plus grand ou égal
expr >= expr
==
égal
expr == expr
!=
différent
expr != expr
&
ET bit-à-bit
expr & expr
^
OU (exclusif) bit-à-bit
expr ^ expr
|
OU (inclusif) bit-à-bit
expr | expr
&&
ET logique
expr && expr
||
OU logique
expr || expr
<=
>
Conception et Programmation OO
page 73/120
OO3.tex v1.1 imprimé le 23 Octobre 2006
%
$
C++ de base : opérateurs de base du C++
<
&
$
C++ de base : opérateurs de base du C++
page 74/120
%
'
$
C++ de base : opérateurs de base du C++
? :
expression conditionnelle
expr ? expr : expr
*=
multiplication et affectation
lvalue *= expr
/=
division et affectation
lvalue /= expr
%=
modulo et affectation
lvalue %= expr
+=
addition et affectation
lvalue += expr
-=
sosutraction et affectation
lvalue -= expr
< <=
décalage à gauche et affectation
lvalue < <= expr
> >=
décalage à droite et affectation
lvalue > >= expr
&=
ET et affectation
lvalue &= expr
|=
OU inclusif et affectation
lvalue |= expr
^=
OU exclusif et affectation
lvalue ^= expr
virgule (séquence)
expr, expr
,
➔ En cas de doute sur la priorité des opérateurs, les parenthèses () permettent d’imposer un
ordre clair d’évaluation (exemple : a+(b*c)) ;
➔ Tous les opérateurs d’affectation évaluent leur opérande droit comme une rvalue et affectent
cette valeur à leur opérande gauche, considéré comme une lvalue.
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 75/120
%
$
C++ de base : Les instructions
➔ Un programme C++ est constitué d’un ensemble d’instructions construites en utilisant les
nombreux opérateurs du langage disponibles ;
➔ Il existe plusieurs types d’instructions :
✓ les instructions simples ;
✓ les instructions composées ;
✓ les instructions de contrôle.
Les instructions simples
➔ Une instruction simple est une expression terminée par un point virgule ’;’ ;
int i=0;
++i;
x = y + 2;
i=0,j=0,k=0;
//
//
//
//
une déclaration est une instruction !
opérateur unaire (pré-incrémentation)
opérateur +, opérateur =
opérateur ,
➔ Une instruction n’a pas de valeur ;
➔ En C++ une déclaration est une instruction ;
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 76/120
%
'
$
C++ de base : Les instructions composées
➔ Une instruction composée est un bloc contenant un ensemble d’instructions (simples,
composées, ou de contrôle) ;
➔ Le bloc est délimité par une accolade ouvrante ’{’, et une accolade fermante ’}’ ;
➔ On peut construire des blocs de blocs .... ;
➔ La déclaration d’un identificateur au sein d’un bloc rend cet identificateur local au bloc :
- il n’est visible que dans ce bloc,
- il est détruit lorsqu’on rencontre l’accolade fermante du bloc .
...
{
double x=cos(12.7);
int i=3, j=4, k;
{
++i;
int i=6;
j=i;
}
k=i+j;
}
...
// un bloc, qui contient un bloc
// i,j et k, des entiers dans le premier bloc
// i (du premier bloc) vaut maintenant 4.
// i local au deuxieme bloc.
// <=> j=6 !
// <=> k=4+6 : k vaut maintenant 10 !
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 77/120
%
$
C++ de base : Les instructions de contrôle - if
➔ Le test conditionnel if :
✓ test simple :
if (expr_booléenne) instruction
✓ test simple avec une alternative :
if (expr_booléenne)
instruction
else
instruction
// cas vrai
// cas faux
✓ succession de tests :
if (expr_booléenne)
instruction
else if (expr_booléenne)
instruction
...
else if (expr_booléenne)
instruction
else
instruction
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 78/120
%
'
$
C++ de base : Les instructions de contrôle - if
➔ L’instruction exécutée peut être une instruction quelconque
(simple, composée ou de contrôle) :
if (x == y)
x++;
else
{
if (verbose)
cout << "x != y" << endl;
if (x>y)
{
if (berbose)
cout << "x > y" << endl;
++y;
++x;
}
else
if (verbose)
cout << "x < y" << endl;
}
// instruction simple
// bloc
// instruction simple
// bloc
// instruction simple
// instruction if
// instruction simple
➔ En cas de doute sur l’imbrication des if/else/else if, il est prudent de marquer les
blocs d’instructions avec des accolades .
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 79/120
%
$
C++ de base : Les instructions de contrôle - switch
➔ Le branchement conditionnel switch balaye les cas possibles d’une expression entière ;
➔ À l’intérieur d’un switch :
✓ case permet de sélectionner les valeurs possibles,
✓ break permet de finir le cas en cours et de sortir du switch.
switch(expression_entière) // expression_entière est évaluée
{
case valeur1:
// cas où expression_entière vaut valeur1
[instruction
// instruction simple ou composée
[break;]
// Fin du cas, sortie du switch optionnel
]
...
case valeurN:
[instruction
[break;]
]
[defaut:
// Si aucun des cas n’a été trouvé, cas par défaut.
[instruction
[break;]
]
]
}
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 80/120
%
'
$
C++ de base : Branchement conditionnel switch - case
➔ Les valeurs figurant après case doivent être des expressions constantes.
#include <iostream>
using namespace std;
int main()
{
char c=0;
// ascii null
bool fin=false;
while(fin != true)
{
cout << "Entrer un caractère ... ";
cin >> c;
switch(c)
{
case ’q’:
fin=true;
break;
case ’0’:
...
case ’8’:
cout << c << " est paire";
break;
&
Conception et Programmation OO
'
case ’1’:
case ’3’:
case ’5’:
case ’7’:
case ’9’:
cout << c << " est impaire";
break;
default:
cout << c << " : pas un chiffre!";
break;
}
cout << endl;
}
}
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 81/120
%
$
C++ de base : Boucle for
➔ La syntaxe de l’instruction for est :
for (initialisation; test; itération)
instruction
// instruction simple ou composée
➔ Les éléments d’une bouclefor sont :
✓ initialisation : instruction simple évaluée avant le premier tour de boucle
(peut contenir plusieurs expressions séparées par l’opérateur de séquence ",") ;
✓ test : expression évaluée à chaque tour de boucle ;
- si sa valeur est true, la boucle continue,
- si sa valeur est false, la boucle est arrêtée ;
✓ itération : instruction simple effectuée à la fin de chaque tour de boucle ;
✓ instruction : le corps de la boucle (instruction simple, composée ou de contrôle).
➔ L’exécution d’une boucle for correspond à la séquence suivante :
1. évaluer initialisation ;
2. évaluer test ;
si le résultat est true, continuer à l’étape 3
si le résultat est false, terminer la boucle.
3. exécuter instruction ;
4. évaluer itération et revenir à l’étape 2.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 82/120
%
'
$
C++ de base : Boucle for
➔ Remarque:
- Tous les éléments d’une boucle for sont optionnels : on peut écrire for(;;) ;
- Le premier tour de boucle commence toujours par une séquence
"initialisation, test".
const int size=100;
int tab[size];
for (int i=0; i<size; ++i)
{
tab[i]=i*i;
}
// constante pour la taille du tableau
// boucle pour initialiser tab[i]=i*i
➔ Exemple d’initialisation multiple ou absente :
int i;
const int AZsize=’z’-’a’+1;
char c1, tab_c[AZsize];
for(i=0, c1=’a’; c1 <= ’z’; ++c1, ++i)
tab_c[i]=c1;
// initialisation multiple
for(; i>0; --i)
// initialisation absente : on part de la valeur
{
// de i de fin de la boucle précédente !
const int j=AZsize-i;
cout << "tab_c[" << j << "] = " << tab_c[j] << endl;
}
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 83/120
%
$
C++ de base : Boucle for
➔ Boucle for infinie sans initialisation, test, ni itération
(équivalent d’une boucle while(true)) :
int i=0;
for(;;)
{
// traitements ...
if (i == EndValue)
break;
}
// sortie de la boucle par break
➔ Boucle forsans corps, tout le travail est fait dans le test :
char *source=chaine1; // chaine1 est un tableau de char terminé par ’\0’.
char *cible=chaine2; // chaine2 est un tableau de char terminé par ’\0’.
for(;*cible++=*source++;)
;
// corps de boucle : instruction vide
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 84/120
%
'
$
C++ de base : Boucle while, do-while
➔ L’instruction while exécute le corps de la boucle tant que la condition testée est vraie :
while (expr_booléenne)
instruction
// instruction simple ou composée
int i=0;
while(i<100)
tab[i++]=0;
➔ L’instruction do indroduit une boucle délimitée par l’instruction while :
➔ Le corps de la boucle est toujours exécutée au moins une fois ;
do
instruction
// instruction simple ou composée
while (expr_booléenne)
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 85/120
%
$
C++ de base : Branchement continue / Sortie impérative break
➔ Dans une boucle (for, while ou do...while) :
✓ l’instruction continue permet de forcer le passage à l’itération suivante ;
for(int i=0; i<MAX; ++i)
{
if (i==i0) continue;
// passer au tour suivant si i==i0
// traitement
}
✓ l’instruction break provoque la sortie immédiate de la boucle ;
for(int i=0; i<MAX; ++i)
{
if (i==i0) break;
// sortir de la boucle
// traitement
}
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 86/120
%
'
$
C++ de base : Branchement inconditionnel goto
➔ L’instruction goto étiquette permet de brancher l’exécution du programme sur la ligne
repérée "étiquette:" ;
➔ Les noms d’étiquettes sont locaux au bloc de plus haut niveau ;
➔ Un goto ne peut pas renvoyer à une étiquette située dans un autre bloc ;
➔ Un goto peut être utile pour sortir d’un seul coup de plusieurs boucles imbriquées :
...
for (int i=0; i<MAX_I; ++i)
for [int j=0; j<MAX_J; ++j)
if (matrice[i][j]==val) goto fin;
fin:
...
➔ En dehors de ce type d’utilisation, l’usage du goto n’est pas recommandé
(risque de "code spaghetti" ?).
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 87/120
%
$
C++ de base : Les fonctions - Déclaration
➔ Toute fonction doit être déclarée avant de pouvoir être utilisée ;
➔ Le compilateur C++ peut ainsi vérifier :
✓ que le nombre et le type des arguments passés à l’appel de la fonction
sont conformes à ceux de la déclaration ;
✓ que l’utilisation de valeur retournée par la fonction correspond au type de retour déclaré.
➔ La déclaration d’une fonction spécifie son prototype :
type_retour id_fonction(type [id_param1], type [id_param2], ...)
➔ Le prototype d’une fonction doit fournir :
✓ le type de la valeur retournée par la fonction ;
✓ le nom de la fonction ;
✓ la déclaration des types d’arguments passés, avec optionnellement leurs noms ;
➔ La liste des arguments passés à une fonction constitue la signature de la fonction.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 88/120
%
'
$
C++ de base : Les fonctions - Définition
➔ La définition d’une fonction donne l’implémentation de la fonction ;
➔ La définition de la fonction doit fournir :
✓ le type de la valeur retournée par la fonction,
✓ la signature (nom de la fonction, type et nom des arguments passés) ;
✓ le code de la fonction.
➔ La déclaration des arguments a une portée locale à la fonction ;
type_retour id_fonction(type id_param1, type id_param2, ...)
{
// code de la fonction
// les paramètres formels id_param1, id_param2, ... peuvent
// être utilisés dans le coprs de la focntion comme n’importe
// quel identificateur déclaré.
}
➔ La définition d’une fonction ne pas pas être placée à l’intérieur d’un bloc,
contrairement à sa déclaration ;
➔ Le compilateur vérifie que la signature présente dans la définition coïncider avec la signature
déclarée !
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 89/120
$
C++ de base : Les fonctions - Définition
int Min(int, int);
int main()
{
int i=Min(2,3);
return 0;
}
int Min(int i, int j)
%
// Déclaration de la fonction Min() pour pouvoir
// l’utiliser dans la fonction main().
// Les noms des arguments ne sont pas obligatoires.
// appel de la fonction Min().
// Définition de la fonction Min : le nommage des arguments
// est obligatoire : il fournit le nom des paramètres formels.
{
return i < j ? i : j;
}
➔ Les déclarations des fonctions sont placées dans des "fichiers interfaces" , ;
➔ Les définition des fonctions sont placées dans des "fichiers d’implémentation" ;
➔ En C++ l’extension des fichiers interfaces est classiquement : .hxx, .hh, .hpp, ...
celle des fichiers d’implémentation est classiquement : .cxx, .cc, .cpp
➔ Les fichiers interfaces sont inclus par les fichiers d’implémentation des définitions avec la
directive #include ;
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 90/120
%
'
$
C++ de base : Les fonctions - Type de retour
➔ Les types de retour possibles pour une fonction sont :
✓ void : la fonction ne retourne aucune valeur;
✓ un type de base (entier, flottant, structure, union , classe, ... ;
✓ pointeur ou référence sur n’importe quel de ces types ;
➔ Les structures et unions retournées par valeur sont copiées "bit à bit" dans une variable
temporaire ;
➔ Le type retourné peut être qualifié const ;
➔ Lorsqu’une fonction retourne une référence, l’objet référencé doit être persistant après la fin
de l’exécution de la fonction.
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 91/120
%
$
C++ de base : Les fonctions - Type de retour
Exemple d’erreur : fonction retournant une référence sur un objet temporaire :
#include <iostream>
using namespace std;
void f(int &R) {
cout << "F: R = "<< R << endl;
R=10;
cout << "F: R = "<< R << endl;
}
int &g() {
int X=30;
cout << "G: X = "<< X << endl;
return X;
}
// Argh : X est local à g() !!!
int main() {
cout << "main" << endl;
f(g());
cout << "fin main" << endl;
}
à la compilation le compilateur gcc4 émet le warning suivant (tout à fait pertinent !) :
... In function ’int& g()’:
...
warning: reference to local variable ’X’ returned
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 92/120
%
'
$
C++ de base : Les fonctions - Type de retour
à l’exécution, on constate le plantage :
main
G: X = 30
F: R = -1080875936
Erreur de segmentation
Solution : rendre la variable X statique dans la fonction g
int &g() {
static int X=30;
cout << "G: X = "<< X << endl;
return X;
}
Autre solution : allouer dynamiquement la variable X dans la fonction g
int &g() {
int *p=new int;
*p=30;
cout << "G: X = "<< *p << endl;
return *p;
}
On a alors un résultat correct :
main
G: X = 30
F: R = 30
F: R = 10
fin main
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 93/120
%
$
C++ de base : Les fonctions - Passage des arguments
➔ En C comme en C++ tous les arguments passés à une fonction sont passés par valeur :
c’est la valeur des arguments qui est passée à la fonction, pas leur adresse.
➔ Pour passer l’adresse d’un objet à une fonction il suffit de lui passer un argument de type
pointeur sur cet objet : la valeur du pointeur est l’adresse de l’objet pointé.
➔ On peut aussi passer une référence]en argument, qui permet de lire/écrire l’objet référencé
dans le corps de la fonction .
// version avec références
//
void swap(double &a, double &b)
{
double temp=a;
a=b;
b=temp;
}
// exemple d’appel :
double x, y;
...
swap(x,y);
&
Conception et Programmation OO
// version avec pointeurs
//
void swap(double *a, double *b)
{
double temp=*a;
// dé-référencement
// obligatoire pour
*a=b;
*b=temp;
}
// exemple d’appel
double x, y;
...
swap(&x,&y);
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 94/120
%
'
$
C++ de base : Les fonctions - Argument const
➔ Le modificateur const permet de déclarer qu’un argument reçu par la fonction doit être
considéré comme constant ;
➔ Très utile pour les références et les pointeurs, lorsque les variables pointées ou référencées
ne doivent pas être modifiées par la fonction.
void f(const int *, const int &,
int *, int &);
// Déclaration de f.
f(const int *pic, const int &ric, // Définition de f.
int *pi, int &ri)
{
// erreur : pic est un pointeur sur un const int.
*pic=10;
ric++;
// erreur : ric est une référence sur un const int.
// OK.
*pi=10;
ri=20;
// OK.
}
➔ L’attribut const est donné aux paramètres formels que reçoit la fonction,
ceci n’implique pas que les paramètres effectifs soient eux-mêmes des objets const :
int main()
{
int i=1, j=2, k=3, l=4;
f(&i,j,&k,l);
}
&
Conception et Programmation OO
'
// OK : i et j seront considérés comme const uniquement
// dans le corps de f.
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 95/120
%
$
C++ de base : Les fonctions - Valeur par défaut des arguments
➔ Les paramètres formels d’une fonction peuvent avoir des valeurs par défaut ;
➔ Les valeurs par défaut sont données à la déclaration de la fonction ;
➔ Les paramètres effectifs correspondants peuvent être omis à l’appel de la fonction ;
➔ Si l’on omet un paramètre à l’appel d’une fonctiont, tous les paramètres suivants doivent être
omis ;
➔ Un paramètre ayant une valeur par défaut est :
- soit le dernier paramètre passé à la fonction,
- soit suivi par des paramètres ayant tous des valeurs par défaut.
void PrintInfo(int niveau,
char *marge="\t",
const string & texte); // Erreur texte n’a pas de valeur par défaut.
le compilateur signale l’erreur :
error: default argument missing for parameter 3 of
’void PrintInfo_(int, char*, const std::string&)’
la correction pourrait être :
void PrintInfo(int niveau,
char *marge="\t",
const string & texte=string("")); // OK.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 96/120
%
'
$
C++ de base : Les fonctions - Valeur par défaut des arguments
La définition de la fonction PrintInfo ne mentionne pas les valeurs par défaut :
void PrintInfo(int niveau,
char *marge,
const string & texte)
{
cout << marge << niveau << " : " << texte << endl << flush;
}
L’appel de la fonction PrintInfo peut se faire avec un, deux ou trois arguments :
int main()
{
PrintInfo(1);
PrintInfo(2,"\t\t");
// marge prend la valeur par défaut "\t"
// texte prend la valeur par défaut string("")
// marge est donné.
// texte prend la valeur par défaut string("")
PrintInfo(3,"\t\t\t","Message transmis"); // marge et texte sont donnés.
// aucune valeur par défaut prise
...
}
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 97/120
%
$
'
C++ de base : Les fonctions - Pointeur de fonction passé comme argument
➔ Le nom d’une fonction est de type pointeur constant contenant l’adresse de la fonction ;
#include <math.h>
// l’entete math.h fournit la déclaration de :
// double cos (double x) et double sin (double x);
// M_PI : macro C donnant la valeur de pi.
#include <iostream>
using namespace std;
typedef double (*p_fonc)(double); //
//
int main() {
p_fonc p1=cos;
//
p_fonc p2=sin;
//
cout << "p1(" << M_PI << ") : " <<
cout << "p2(" << M_PI << ") : " <<
}
p_fonc : synonyme d’1 pointeur sur 1 fonction
qui prend un double et qui retourne un double.
cos <=> &cos (adresse de cos)
sin <=> &sin (adresse de sin)
p1(M_PI) << endl;
p2(M_PI) << endl;
➔ On peut passer le nom d’une fonction (pointeur de fonction) en argument à une autre fonction ;
➔ Particulièrement utilisé pour transmettre des données et une fontion pour traiter ces données :
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 98/120
%
'
C++ de base : Les fonctions - Pointeur de fonction passé comme argument
$
#include <iostream>
using namespace std;
double traite_1(double);
double traite_2(double);
// déclaration de traite_1, définie ailleurs.
// idem
void traiter(double &result, double (*f)(double));
// La fonction traiter prend en argument :
// - une référence sur un double (qui reçoit le résultat du traitement),
// - un pointeur sur une fonction qui prend un double et qui retourne un double.
int main() {
cout << "Choix traitement 1 ou 2 : ";
int i_choix; cin >> i_choix;
switch(choix) {
case 1:
traiter(choix, traite_1); break;
// traite_1 : adresse de la fonction.
case 2:
traiter(choix, traite_2); break;
}
}
void traiter(double &res, double (*f)(double)) {
double x1;
...
res=f(x1); // utilisation du pointeur de fonction
}
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 99/120
'
C++ de base : Les fonctions - Pointeur de fonction passé comme argument
%
$
➔ Dans l’exemple précédent, on peut remplacer switch par un tableau de pointeurs sur
fonctions :
double (*tab_fonc[2])(double, double); // tabl. de 2 pointeurs sur des fonctions
// prenant un double, retournant un double.
...
int main()
{
...
tab_fonc[0]=traite_1;
tab_fonc[1]=traite_2;
cout << "Choix traitement 1 ou 2 : ";
int i_choix;
cin >> choix;
traiter(choix, tab_fonc[choix-1]);
...
}
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 100/120
%
'
$
C++ de base : Les fonctions - Variable locale statique
➔ Les variables locales à une fonction sont allouées à chaque appel de la fonction
➔ la valeur d’une variable locale est perdue entre deux appels.
➔ le mot clef static permet de rentre permanente (statique) l’allocation d’une variable locale ;
➔ Une variable statique possède une adresse mémoire constante, sa valeur est conservée entre 2
appels de la fonction ;
➔ Une variable statique initialisée à sa déclaration est initialisée une seule fois, lors de la
première exécution de la fonction ;
➔ Une variable statique offre un effet mémoire à la fonction dans laquelle elle et définie
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 101/120
$
C++ de base : Les fonctions - Variable locale statique
#include <iostream>
using namespace std;
void f(int a) {
int x=0;
while(a--)
{
static int n=0;
%
// x est initialisée 1 fois à chaque appel de f.
// n sera initialisée une seule fois,
// et garde sa valeur entre 2 appels de f.
int y=0;
// y est initialisée a fois, à chaque appel de f.
cout << "n=" << n++ << ", x=" << x++ << ", y=" << y++ << endl;
}
}
int main() {
f(3);
f(3);
}
À l’exécution :
n=0,
n=1,
n=2,
n=3,
n=4,
n=5,
x=0,
x=1,
x=2,
x=0,
x=1,
x=2,
&
y=0
y=0
y=0
y=0
y=0
y=0
Conception et Programmation OO
// premier appel de f.
// 2me appel de f : n a gardé sa valeur,
// x est ré-initilalisée.
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 102/120
%
'
$
C++ de base : Pointeur, chaine de caractères et classe string
➔ Le type char * permet la manipulation "bas niveau" des chaînes de caractères ;
➔ La libC fournit des fonctions de manipulation des chaînes (fichier entête <string.h>) :
✓ char *strcat (char *dest, const char *src)
char *strncat (char *dest, const char *src, size_t n)
ajoute [les n premiers carcactères de] la chaîne src à la fin de la chaîne dest ;
✓ char *strcpy (char *dest, const char *src)
char *strncpy (char *dest, const char *src, size_t n)
copie [les n premiers carcactères de] la chaîne src dans la chaîne dest ;
✓ char *strstr (const char *s1, const char *s2) cherche la premiere occurence
de s1 dans la chaîne s2 ;
✓ int strcmp (const char *s1, const char *s2)
int strncmp (const char *s1, const char *s2, size_t n)
compare les deux chaînes s1 et s2 ;
✓ size_t strlen (const char *s) retourne la longueur de la chaîne de caractères ;
✓ char *strchr (const char *s, int c)
renvoie un pointeur sur la première occurence du caractère c dans la chaîne s ;
✓ char *strrchr (const char *s, int c)
renvoie un pointeur sur la première occurence du caractère c dans la chaîne s ;
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 103/120
%
$
C++ de base : Pointeur, chaine de caractères et classe string
➔ La libC++ fournit avec la classe string un type simple à utiliser, sûr, complet et performant
pour le traitement des chaînes de caractères ;
➔ La classe string est préférable au type char *, qui peut être la source de bien des
problèmes (!!) ;
➔ L’inclusion du fichier entête <string> fournit les déclarations de la classe <string> ;
➔ La conversion explicite d’un objet string en char * s’obtient en utilisant la fonction
membre c_str ;
➔ Avec la classe string les concaténations de chaînes deviennent sûres et simples :
Concaténation de chaînes avec char * :
main()
{
char tmp[80];
cout << "fichier? ";
cin >> tmp;
char nomfic[80]; // en espérant que cela suffit...
strcpy(nomfic, "/home/users/projet/donnees/");
strcat(nomfic, tmp);
strcat(nomfic, ".dat");
// si tout va bien, nomfic contient "/home/users/projet/donnees/.....dat"
...
}
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 104/120
%
'
$
C++ de base : Pointeur, chaine de caractères et classe string
Version avec la classe string:
main()
{
string tmp;
cout << "fichier? ";
cin >> tmp;
string nomfic = "/home/users/projet/donnees/" + tmp + ".dat";
...
}
➔ La classe string est type "complet !!" (extraits) :
// construction avec les n premiers éléments d’un tableau de caractères
// (par défaut: tous les caractères)
string(const char *s, size_t n);
// construction par répétition d’un caractère
string(size_t n, char c);
// construction avec n caractères d’une autre chaîne (par défaut: jusqu’au bout)
// à partir du caractère de rang pos (par défaut: le premier)
string(const string &str, size_t pos = 0, size_t n = npos);
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 105/120
%
$
C++ de base : Pointeur, chaine de caractères et classe string
La classe string, un exemple de type "complet !!" (extraits) :
// affectation
string &operator=(const string &str);
string &operator=(const char *s);
string &operator=(char c);
// nombre de caractères (ces deux fonctions sont les mêmes)
size_t size() const;
size_t length() const;
// nombre maximum de caractères
size_t max_size() const;
// changement du nombre de caractères :
void resize(size_t n, char c);
void resize(size_t n);
// accès au ième caractère
const char &operator[](size_t pos) const;
char &operator[](size_t pos);
const char &at(size_t n) const;
char &at(size_t n);
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 106/120
%
'
$
C++ de base : Pointeur, chaine de caractères et classe string
La classe string, un exemple de type "complet !!" (extraits) :
// concaténation avec une chaîne, un char * , un char ...
string &operator+=(const string &str);
string &operator+=(const char *s);
...
string &append(const string &str);
string &append(const char *s, size_t n);
...
/// modification des caractères d’une chaîne
string &assign(const string&);
string &assign(const char *s, size_t n);
...
// insertion parmi les caractères d’une chaîne
string &insert(size_t pos1, const string &str);
string &insert(size_t pos, const char *s, size_t n);
...
// suppression de caractères au milieu d’une chaîne
string &erase(size_t pos = 0, size_t n = npos);
...
// remplacement de caractères d’une chaîne
string &replace(size_t pos1, size_t n1, const string &str);
string &replace(size_t pos, size_t n1, const char *s);
...
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 107/120
%
$
C++ de base : Pointeur, chaine de caractères et classe string
La classe string, un exemple de type "complet !!" (extraits) :
/// obtention explicite du char * sous-jacent.
// Dans le cas de c_str, un caractère nul est présent à la fin :
const char *c_str() const; // explicit
const char *data() const;
...
// recherche de chaînes et de caractères dans une chaîne ;
// fonctions donnant la position la plus à gauche (« première occurrence ») :
size_t find (const string &str, size_t pos = 0) const;
size_t find (const char *s, size_t pos = 0) const;
...
// fonctions donnant la position la plus à droite (« dernière occurrence ») :
size_t rfind(const string &str, size_t pos = npos) const;
size_t rfind(const char *s, size_t pos, size_t n) const;
...
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 108/120
%
'
$
C++ de base : Entrée/Sorties par flot
➔ La classe iostream (fichier entête <iostream>) permet la gestion des flux d’entrée/sortie
:
✓ Un flux d’entrée est un objet de type istream :
cin est le flux associé à l’entrée standard (stdin, par défaut le clavier) ;
✓ Un flux de sortie un objet de type ostream :
cout est le flux associé à la sortie standard (stdout, par défaut l’écran) ;
cerr est le flux associé à la sortie standard des erreurs (stderr, par défaut l’écran) ;
➔ La classe iostream re-définit 2 opérateurs pour lectures/écritures ASCII formattées :
✓ l’opérateur d’injection "<<",
- injecte des données dans un flux de sortie,
- supporte les données des types de base (int, char, float,...),
- retourne l’objet cout.
✓ l’opérateur d’extraction ">>",
- extrait des données d’un flux d’entrée,
- supporte les données des types de base (int, char, float, ...),
- retourne l’objet cin.
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 109/120
%
$
C++ de base : Entrée/Sorties par flot
➔ Exemples :
✓ Écriture à l’écran : cout << expression;
comme "<<" retourne l’objet cout, on peut injecter d’autres données :
cout << expression1 << expression2 << ... ;
✓ Lecture clavier dans une variable scalaire : cin >> var;
comme ">>" retourne l’objet cin, on peut extraire d’autres données :
cin >> var1 >> var2 >> ... ;
➔ Les manipulateurs de flux permettent d’en changer la configuration ;
➔ Le fichier entête <iomanip> fournit les déclarations des manipulateurs ;
// lecture de trois le 1er le 3ème en décimal, le 2nd en hexadécimal :
int x, y, z;
cin >> x >> hex >> y >> dec >> z;
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 110/120
%
'
$
C++ de base : Entrée/Sorties par flot
➔ Manipulateurs sans arguments :
Affichage symbolique des booléens
boolalpha, noboolalpha
Affichage de la base (lorsque ce n’est pas 10)
showbase, noshowbase
Affichage du point décimal
showpoint, noshowpoint
Affichage de + devant les nombres non négatifs
showpos, noshowpos
Saut des blancs précédant des données à lire
skipws, noskipws
Mise en majuscule de certains caractères
uppercase, nouppercase
Cadrage
left, right, internal
Base, pour l’expression des nombres
dec, hex, oct
Écriture des nombres flottants
fixed, scientific
Sauter les blancs (istream uniquement)
ws
Écriture d’une fin de ligne (’\n’ + vidage buffer,ostream)
endl
Écriture d’une fin de chaîne ’\0’ (ostream)
ends
Vidange du buffer d’écriture (ostream)
flush
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 111/120
%
$
C++ de base : Entrée/Sorties par flot
➔ Manipulateurs avec paramètres :
&
La largeur de la zone
setw(int n)
Base (8, 10 ou 16)
setbase(int base)
Caractère de remplissage
setfill(char c)
Nombre de chiffres significatifs de l’affichage
setprecision(int n)
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 112/120
%
'
$
C++ de base : Entrée/Sorties par flot
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
// save the default fmtflags settings for cout
ios::fmtflags cout_flags = cout.flags();
cout << (3 + 2 == 5) << ’ ’ << boolalpha << (3 + 2 == 5) << endl;
// Affiche : 1 true
cout << hex << 256 << ’ ’ << showbase << 256 << endl;
// Affiche : 100 0x100
cout << dec << 20.0 << ’ ’ << showpoint << 20.0 << endl;
// Affiche : 20 20.0000
cout << dec << 20 << ’ ’ << showpos << 20 << endl;
// Affiche : 20 +20
cout.flags(cout_flags); // reset la config de cout
cout << hex << showbase << 256 << ’ ’ << uppercase << 256 << endl;
// Affiche : 0x100 0X100
cout.flags(cout_flags);
cout << "’" << setw(20) << 123
<< "’\n";
// Affiche : ’
123’
cout << "’" << setw(20) << left << 123 << "’\n";
// Affiche : ’123
’
cout << "’" << setw(20) << right << 123 << "’\n";
// Affiche : ’
123’
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 113/120
%
$
C++ de base : Entrée/Sorties par flot
cout.flags(cout_flags);
cout << 27 << ’ ’ << hex << 27 << ’ ’ << oct << 27 << ’ ’ << "\n";
// Affiche : 27 1b 33
cout.flags(cout_flags);
cout << 0.123 << ’ ’ << fixed << 0.123 << ’ ’ << scientific << 0.123 << endl;
// Affiche : 0.123 0.123000 1.230000e-01
cout.flags(cout_flags);
cout << setw(10) << 12345 << ’\n’ << 12345 << endl;
// Affiche :
12345
// puis
:12345
cout.flags(cout_flags);
cout << setbase(8) << 73 << ’ ’ << showbase << 73 << endl;
// Affiche : 111 0111
cout.flags(cout_flags);
cout << setw(8) << setfill(’#’) << 999.50 << ’\n’;
// Affiche : ###999.5
cout.flags(cout_flags);
cout << setprecision(2) << 0.000111111 << ’ ’ << 1.11111 << ’ ’ << 11111.1
<< ’ ’ << 111111000.0 << endl;
// Affiche : 0.00011 1.1 1.1e+04 1.1e+08
&
}
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 114/120
%
'
$
C++ de base : Entrée/Sorties par flot - Fichier
Connection d’un flux à un fichier (comme les FILE en C déclarées dans <stdio.h>) :
➔ Le fichier entête <fstream> déclare les classes ifstream et ofstream ;
➔ Fonctions membres communes à ifstream et ofstream :
✓ void open(char * nom) : ouverture du flux (dans le mode qui lui est propre) ;
✓ bool is_open() : retourne un booléen true si l’opération d’ouverture a réussi ;
✓ void close() : fermeture du flux ;
➔ Création (ouverture) d’un flux de sortie associé à un fichier :
ofstream f_out(char * nom, mode_ouverture);
➔ Principales fonctions membres de ofstream :
✓ ostream & put(char c) : écrit le caractère c ;
✓ ostream & write(void *addr, int long) : écrit long octets depuis
l’adresse addr;
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 115/120
%
$
C++ de base : Entrée/Sorties par flot - Fichier
➔ Création (ouverture) d’un flux d’entrée associé un fichier :
ifstream f_in(char * nom, mode_ouverture);
➔ Principales fonctions membres de ifstream :
✓ istream & get(char &c) : lit un caractère et le range dans c; ;
✓ int get() : lit un caractère et le renvoie comme un int ou EOF si fin de fichier; ;
✓ istream & getline(char *l, int n) : lit une ligne d’au plus n caractères ;
✓ istream & read(void *addr, int n) : lit au plus n caractères et les range à
partir de l’adresse addr.
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 116/120
%
'
$
C++ de base : Entrée/Sorties par flot
➔ Les principaux modes d’ouverture des fichiers sont des constantes de la classe ios :
✓ ios::in
ouverture en lecture (mode de la classe ifstream) ;
✓ ios::out
ouverture en écriture (mode de la classe ofstream) ;
✓ ios::app
ouverture en ajout de données (écriture en fin de fichier)
peut être utilisé avec un objet ofstream ;
✓ ios::trunc ouverture avec troncature : si le fichier existe, son contenu est perdu
obligatoire si ios::out est activé ios::app ;
✓ ios::binary utile pour les implémentations devant distinguer fichier binaire/texte.
➔ L’état d’un flux est testé grâce à des fonctions membres de la classe ios (héritées par
ifstream et ofstream) :
✓ good() : retourne un booléen true si le flux ne présente aucune erreur;
✓ eof() : retourne un booléen true si une fin de fichier a été rencontrée ;
✓ fail() : retourne un booléen true si une erreur logique s’est produite dans une
opération de lecture ou d’écriture ;
✓ bad() : retourne un booléen true si le flux est dans un état irrécupérable ;
✓ Remarque : l’opérateur not (!) est re-défini dans ios pour donner le résultat
"!good()".
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 117/120
%
$
C++ de base : Entrée/Sorties par flot
Exemple : écriture dans un fichier ASCII :
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main(void)
{
// Lire des données :
int i;
double d, e;
cout << "Entier Réel Réel : ";
cin >> i >> d >> e;
// Enregistrer ces données dans un fichier :
ofstream f("fichier.txt");
if (f.is_open())
{
f << "Les données lues sont : " << i << " " << d << " " << e << endl;
f.close();
}
return 0;
}
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 118/120
%
'
$
C++ de base : Entrée/Sorties par flot
Exemple : recopie brute d’un fichier dans un autre :
#include <iostream>
#include <iomanip>
#include <fstream>
using namespace std;
void f(int argc, char **argv) {
if (argc != 3)
cerr << "Usage: copie <fic1> <fic2>";
else
{
ifstream fi(argv[1], ios_base::in);
if ( ! fi)
// <=> if (!fi.good())
cerr << "Impossible d’ouvrir " << argv[1];
else
{
ofstream fo(argv[2]);
if ( ! fo)
cerr << "Impossible de creer " << argv[2];
char ch;
while (fo.good() && fi.get(ch))
fo.put(ch);
fo.close(); fi.close();
}
}
}
&
Conception et Programmation OO
'
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 119/120
%
$
Bibliographie
Livres C++ :
➔ "Le langage C++", Bjarne STROUSTRUP, International Thomson Publishing
➔ "L’essentiel du C++", Staley LIPPMAN, Addison-Wesley
➔ "Mieux programmer en C++, 47 problèmes pratique résolus", Hert SUTTER, Eyrolles
➔ "Effective C++, Third Edition", Scott MEYER, Addison-Wesley
➔ "More Effective C++", Scott MEYER, Addison-Wesley
➔ "C++ La synthèse", Gilles CLAVEL, Dunod
Ressources du WEB :
➔ "Le Langage C++", Henri Garreta, Polys PDF
http://www.dil.univ-mrs.fr/g̃arreta/Polys/PolyCpp.pdf
➔ "Les meilleurs Cours et Tutoriels C &x C++"
http://www.developpez.com/c/cours/
&
Conception et Programmation OO
OO3.tex v1.1 imprimé le 23 Octobre 2006
page 120/120
%