Partie 2: Types, Variables, Opérateurs — Programmation orientée objet en C++

Programmation Orientée Objet en C++
2ème Partie: Types des Données, Variables et
Opérateurs

Fabio Hernandez
Fabio.Hernandez@in2p3.fr

Vue d'Ensemble
Notions de base
Types, variables, opérateurs
Contrôle d'exécution
Fonctions
Mémoire dynamique
Qualité du logiciel
Evolution du modèle objet
Objets et classes
Fonctions membres
Classes génériques
Héritage
Polymorphisme
Héritage multiple
Entrée/sortie

POO en C++: Types, Variables, Opérateurs 18 © 1997-2003 Fabio HERNANDEZ

Table des Matières

Type des Données
Types Fondamentaux
Définition de Variables
Mots Réservés
Opérateurs (arithmétiques, relationnels, logiques, d’affectation)
Types Dérivés (pointeurs)
Constantes
Enumerations
Types Dérivés (références, tableaux)
Définition de Nouveaux Types
Conversion de Type


Type des Données

Le type d’une variable détermine
la taille de la zone mémoire qui contient la valeur de la variable
la signification de la séquence de bits en mémoire
les opérations possibles sur une variable
les instructions machine à utiliser pour certaines opérations
On peut classer les types de données en
types fondamentaux
types dérivés


Contrôle d'Avancement
Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type


Types Fondamentaux

Booléen
bool
deux valeurs constantes de type bool: true et false
Entiers de tailles différentes
char (1 octet)
short int ou short (2 octets)
int (2 ou 4 octets)
long int ou long (4 ou 8 octets)
Valeurs en virgule flottante
float (4 octets)
double (8 octets)
long double (10 ou plus octets)


Types Fondamentaux (suite)

Entiers positifs
unsigned char
unsigned short
unsigned int
unsigned long
Entiers avec signe
signed char
signed short ≅ short
signed int ≅ int
signed long ≅ long
Pour avoir la plage des valeurs pour chaque type, voir les
fichiers
limits.h pour les types entiers
float.h pour les types en virgule flottante


Types Fondamentaux (suite)

Taille de chaque type est dépendante du processeur
char, signed char et unsigned char sont trois types
différents
sizeof retourne la taille en octets d’un type ou d’une variable
cout << "The size of an int on this platform is "
<< sizeof(int) << " bytes" << endl;
Sur toutes les plate-formes il est garanti
1=sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)
sizeof(float) <= sizeof(double) <= sizeof(long double)
sizeof(Type) = sizeof(signed Type) = sizeof(unsigned Type)
où Type = char, short, int ou long


Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type



Tout objet(variable) en C++ a une classe(type)
Définition du type de la variable est obligatoire
int numHits;
float ratio;
L’identificateur de la variable(son nom) est composé de
lettres, chiffres et le caractère ‘_’ (souligné)
Les noms des variables peuvent commencer par une lettre ou
par ‘_’ (souligné), mais pas par "__" (double souligné )
"__" au début du nom est réservé aux variables/fonctions du
système
Pas de limitation imposée par le langage sur la longueur de
l’identificateur; le compilateur limite en général à 256


Définition de Variables (suite)

Valide mais à éviter
float price, discount;
Plutôt
float price;
float discount;
Majuscules et minuscules sont différenciées
float distance;
int Distance; // WARNING: "Distance" and "distance"
// are two different variables
Valeur initiale indéterminée
On peut donner une valeur initiale lors de la définition
unsigned int minDistance = 15;
double angle = 245.38;
float seed = random();


file1.cpp file2.cpp

float maxCapacity; extern float maxCapacity;
float limit = maxCapacity*0.90;

Si la variable est définie dans un autre module il faut la
déclarer avant de l’utiliser
extern float maxCapacity; // declaration
float limit = maxCapacity*0.90; // usage


La définition de la variable implique une allocation de mémoire
La déclaration de la variable informe au compilateur que la
variable existe et est définie ailleurs. Donc, pas d’allocation
de mémoire nécessaire
La définition (déclaration) de la variable doit paraître avant
sa première utilisation, mais pas forcément avant la première
instruction exécutable
int offset = 200;
....
offset = offset + 15;
....
int step = offset;
Généralement on fait la définition (déclaration) de la variable
juste avant sa première utilisation

Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type


Mots Réservés
asm enum private true
auto explicit protected try
break export public typedef
case extern typeid
register
catch float typename
reinterpret_cast
char for union
return
class friend
short Unsigned
Const goto
signed using
const_cast if
sizeof virtual
continue inline
default static void
int
delete long static_cast volatile
do mutable struct wchar_t
double namespace switch while
dynamic_cast new template
else operator this
throw


Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type


Opérateurs Arithmétiques

Addition x+y
Soustraction x-y
Multiplication x*y
Division x/y
Modulo x%y
Plus Unaire +x
Minus Unaire -x
Post-incrément x++
Pre-incrément ++x
Post-décrément x--
Pre-décrément --x


Opérateurs Arithmétiques (suite)

x++ est équivalent à x = x + 1
x++ signifie: prendre la valeur de x et après l’incrementer
++x signifie: incrementer x et après prendre sa valeur
Exemple
int x=0;
cout << "1. x: " << x << endl;
cout << "2. x: " << x++ << endl;
cout << "3. x: " << x << endl;
cout << "4. x: " << ++x << endl;
cout << "5. x: " << x << endl;
Produit
1. x: 0
2. x: 0
3. x: 1
4. x: 2
5. x: 2
Analogue pour x-- et --x


Opérateurs Relationnels

Le résultat est une valeur de vrai ou faux
faux est représenté par 0 (zéro)
vrai est représenté par une valeur différente de zéro
Opérateur d’égalité
if (x == y) {
// do something when x equals y
}
Attention: erreur TRES courante
if (x = y)
// ERROR: This is assignement instead of a comparison
Opérateur d’inégalité
if (x != y) {
// do something when x is different from y
}


Opérateurs Relationnels (suite)

Inférieur et inférieur égal
if (x < y) {
// do something when x is less than y
}
if (x <= y) {
// do something when x is less than or equal to y
}
Supérieur et supérieur égal
if (x > y) {
// do something when x is greater than y
}
if (x >= y) {
// do something when x is greater than or equal to y
}


Opérateurs Logiques

Négation
if ( !x ) {
// do something if x is equal to 0 (zero)
}
!x produit la valeur 1 si x est égal a zéro et 0 si x est différent de 0
ET logique
if ( x && y ) {
// do something if x and y are both different
// from zero
}
Le résultat de x && y est égal à 1 si x et y ont toutes les deux une
valeur différente de 0
L’expression est évaluée de gauche à droite et uniquement le nombre
de composants nécessaires pour déterminer sa valeur de vérité sont
évalués


Opérateurs Logiques (suite)

OU (inclusif) logique
if ( x || y ) {
// do something if at least one of x or y is
// different from zero
}
Le résultat de x || y est égal à 1 si x ou y ou les deux ont une valeur
différente de 0
L’expression est évaluée de gauche à droite et uniquement le nombre
de composants nécessaires pour déterminer sa valeur de vérité sont
évalués


Opérateurs Logiques Bit à Bit

Interprètent ses opérandes comme une collection ordonnée de
bits
Chaque bit peut contenir une valeur de 0 (zéro) ou 1
Utiles pour effectuer des manipulations au niveau des bits
Les opérandes doivent être de type (signed ou unsigned)
char, short, int ou long
Négation bit à bit
unsigned char bitSet = 33; 0 0 1 0 0 0 0 1

bitSet = ~bitSet; 1 1 0 1 1 1 1 0


Opérateurs Logiques Bit à Bit (suite)

Déplacement vers la gauche
0 0 0 0 0 0 0 1
unsigned char bitSet = 1;

bitSet = bitSet << 2; 0 0 0 0 0 1 0 0

Déplacement vers la droite
bitSet = bitSet >> 1; 0 0 0 0 0 0 1 0

ET bit à bit
0 1 1 0 0 1 0 1

unsigned char mask = 175; 1 0 1 0 1 1 1 1

unsigned char result = bitSet & mask; 0 0 1 0 0 1 0 1


Opérateurs Logiques Bit à Bit (suite)

Soit
0 1 1 0 0 1 0 1

unsigned char mask = 175; 1 0 1 0 1 1 1 1

OU inclusif bit à bit
unsigned char result = bitSet | mask; 1 1 1 0 1 1 1 1

OU exclusif bit à bit
unsigned char result = bitSet ^ mask; 1 1 0 0 1 0 1 0


Ordre d’Evaluation des Opérateurs

Quel est le résultat de l’expression suivante?
4 + 3 * 4 / 2 + 2
16 si l’expresssion est évaluée de gauche à droite
Le résultat correct est 12
3*4 12
12/2 6
4+6 10
10+2 12
Multiplication et division sont prioritaires par rapport à
l’addition et soustraction, donc évaluées avant
Conclusion: utilisez les parenthèses lorsque une expression
comprend plusieurs types d’opérateurs
((price-discount)*numItems)/numMonths


Opérateurs d’Affectation

Pour changer la valeur d’une variable
short hour;
...
hour = 18;
Le résultat de l’opération d’affectation est la valeur de
l’expression à droite de ‘=‘
Le type du résultat est le type de l’opérande de gauche
On peut faire une série d’affectations en une seule
expression
int i;
int j;
i = j = 1024;
Evaluation de la droite vers la gauche


Opérateurs d’Affectation (suite)

L’opération
step = step + 20;
peut s’écrire aussi en utilisant l’opérateur d’addition et
affectation +=
step += 20;
Similairement pour les autres opérations arithmétiques
step -= 20; // subtract assignement
step *= 20; // multiply assignement
step /= 20; // divide assignement
step %= 20; // modulus assignement


Opérateurs d’Affectation (suite)

Et pour les opérations logiques bit à bit
result <<= 5; // bitwise shift left
result >>= 5; // bitwise shift right
result &= mask; // bitwise AND
result |= mask; // bitwise inclusive OR
result ^= mask; // bitwise exclusive OR (XOR)


Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type


Types Dérivés

Dérivés des types fondamentaux et des types définis par le
programmeur
La dérivation se fait à l’aide d’opérateurs de déclaration
Quatre types de dérivation
pointeur
référence
tableau
fonction


Types Dérivés : Pointeurs

Un pointeur contient l’adresse d’un objet en mémoire
L’objet pointé peut être référencé via le pointeur
Utilisation typique: manipulation des objet alloués
dynamiquement (pendant l’exécution du programme), création
et manipulation de structures chaînées, etc.
Exemple
int* pointerToAnInt;
double* pointerToADouble;
Peut s’écrire aussi
int *pointerToAnInt;


Types Dérivés : Pointeurs (suite)

Attention
int* p, q; // WARNING: p is a pointer, q is an int
définit p comme un pointeur à un entier, et q comme un
entier!!!
Faites plutôt
int* p;
int* q;
La taille mémoire d’un pointeur est la quantité d’octets
nécessaire pour stocker une adresse mémoire dépendante
du matériel. En conséquence, un pointeur à un int aura la
même taille qu’un pointeur à un double
L'expression sizeof(int*) retourne cette taille



Pour affecter une valeur à un pointeur
Extraction de
double ratio = 45.2; l'adresse mémoire
double* ratioPtr = &ratio; de ratio
L’opérateur & extrait l’adresse mémoire de la variable qui le
suit (ratio)
Résultat
ratio
ratioPtr

sizeof(double*) 45.2 sizeof(double)


Pour modifier le contenu de la zone mémoire pointée par un
pointeur
*ratioPtr = 250.3; // equivalent to ratio = 250.3;
Résultat ratio
ratioPtr

sizeof(double*) 250.3 sizeof(double)

On peut aussi écrire
double offset;
.....
*ratioPtr += 126.5 + offset;
.....
double finalResult = *ratioPtr + 0.20;

Un pointeur peut recevoir l'adresse d’un autre pointeur du
même type
int count = 1024;
int* countPtr = &count;
int* anotherCountPtr = countPtr;
Résultat
countPtr
count
sizeof(int*)
1024 sizeof(int)
anotherCountPtr

sizeof(int*)


Convention: si un pointeur est égal à 0 (zéro), il ne pointe nulle part
Obtenir la valeur d’un pointeur qui pointe nulle part est une erreur
(segmentation fault in UNIX)
int* aPointer=0;
*aPointer = 125; // ERROR: segmentation fault
Il faut toujours lui affecter une valeur initiale ou tester sa valeur avant
d’extraire la valeur pointée par lui
int* aPointer;
if (aPointer == 0) {
// It points nothing
}
else {
// it points somewhere
}



Exemple
#include <iostream> // C++ I/O declarations
int main()
{
int hitCounter = 200;
int* hitCounterPtr;
if (hitCounterPtr == 0) {
cout << "hitCounterPtr is initially 0" << endl;
hitCounterPtr = &hitCounter;
*hitCounterPtr += 100;
}
cout << "hitCounter = " << hitCounter
<< "*hitCounterPtr = " << *hitCounterPtr
<< endl;
return 0;
}



Les chaînes de caractères en C++ sont manipulées via des
pointeurs
Exemple
char* bookTitle = "Le Petit Prince";

bookTitle:

L e P e t i t P r i n c e 0

La fin de la chaîne est marquée par le caractère ‘0’(zéro)


Arithmétique des pointeurs
char* bookTitle = "Le Petit Prince";
char* secondWord = bookTitle + 3;
cout << *bookTitle << endl; // prints: L
cout << bookTitle << endl; // prints: Le Petit Prince
cout << *secondWord << end; // prints: P
cout << secondWord << end; // prints: Petit Prince

bookTitle:

L e P e t i t P r i n c e 0

secondWord:


Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type


Constantes

Le mot réservé const ajouté à la définition d’un objet
empêche la modification de sa valeur
L’objet doit être initialisé lors de la définition
La violation de cette règle est détectée lors de la compilation
Exemple
const int maxEntries = 150;
maxEntries = 200; // ERROR: maxEntries is a constant
Pointeurs vers constantes
const char* stringPtr = "this is a string";
*stringPtr = ‘T’; // ERROR: stringPtr is a constant


Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type


Enumérations

Alternative pour les constantes de type entier
Exemple
enum { Red, Green, Blue, Black, White };
Equivaut à
const int Red = 0;
const int Green = 1;
...
const int White = 4;
Une énumération peut-être nommée
enum Color { Red, Green, Blue, Black, White };

Color background = Black;
Color foreground;
....
if (background == Black)
foreground = White;


Enumérations (suite)

Utile lorsque le type bool n’est pas encore supporté par votre
compilateur
enum bool { false=0, true=1 };

bool isNull = false;
char* aPointer;
if (aPointer == 0)
isNull = true;


Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type


Types Dérivés : Références

Une référence vers un objet est un alias vers l’objet
Un tant qu’alias, il doit être initialisé avec l’objet référencé
int target = 15;
int& refToTarget = target;
Toute opération effectuée via la référence affecte l’objet
référencé
refToTarget = 500; // target has now the value 500
int half = refToTarget/2; // half is 250
Très utile pour le passage des paramètres aux fonctions (plus
tard)


Types Dérivés : Tableaux

Un tableau est une collection d’objets du même type
Chacun de ces objet est accédé par sa position
Définition d’un tableau de 10 entiers
int table[10];
Les éléments du tableau sont indexés à partir de la position 0
table 0 1 2 3 4 5 6 7 8 9

sizeof(int)

Pour accéder à la valeur dans la position 4 du tableau
table[4] = 800;
table[4] *= 2;
int count = table[4];


Types Dérivés : Tableaux (suite)

La dimension du tableau doit être connue en temps de
compilation
const int numPorts = 200;
double portTable[numPorts]; // OK
int bufferSize;
char buffer[bufferSize]; // ERROR: the value of
// bufferSize is unknown
Le tableau peut être initialisé lors de la définition
int groupTable[3] = {134, 85, 29};
int userTable[] = {10, 74, 43, 45, 89}; // 5 positions
Pour initialiser un tableau, il faut donner une valeur à chaque
élément (exemple plus tard)



Le langage ne garantit pas le contrôle de la validité d’une
position du tableau
int array[5];
array[10] = 555; // Runtime ERROR: array has only
// 5 elements
Tableaux de plusieurs dimensions
const int numRows = 4;
const int numColumns = 3;
int matrix[numRows][numColumns];

0 1 2
0
1
matrix:
2
3



Pour accéder à un élément il faut spécifier ses coordonnées
matrix[2][1] = 18;
0 1 2
0
1
matrix:
2 18

3


Tableaux et Pointeurs

L’identifieur d’un tableau est lui même un pointeur à la
première position
float angleTable[4] = {23.0, 45.8, 123.9, 54.7};
Pour modifier la valeur du premier élément, on peut écrire
angleTable[0] = 222.9;
et aussi Modification du
premier élément
*angleTable = 222.9;
du tableau
et du quatrième angleTable
angleTable[3] = 90.0;
*(angleTable+3) = 90.0;
Il est préférable d’utiliser la notation avec index pour les
tableaux


Tableaux et Pointeurs (suite)

Attention, à la différence des autres pointeurs, sa valeur ne
peut pas être modifiée
float angleTable[4];
float* aPointer;
angleTable = aPointer; // ERROR: angleTable is an
// array


Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type



On peut définir un synonyme pour un type prédéfini (par le
langage ou par le programmeur) à l’aide du mot clé typedef
typedef float Angle;
Le nouveau type Angle peut être utilisé pour définir variables
Angle rotation = 234.78;
Toutes les opérations valides avec le type original le sont
aussi avec le synonyme
Angle rotation = "white"; // ERROR: Angle is float
// not char*


Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type


Conversion de Type

Consiste à modifier la façon d’interpreter la séquence de bits
contenue dans une variable
Conversion implicite
faite automatiquement par le compilateur (non sans warnings) lorsque
plusieurs types de données sont impliqués dans une opération
lors de l’affectation d’une valeur à un objet, le type de la valeur est
modifié au type de l’objet
int count = 5.890; // conversion to int 5
chaque paramètre passé à une fonction est modifié au type de
l’argument espéré par la fonction
extern int add(int first, int second);
count = add(6.41, 10); // conversion to int 6


Conversion de Type (suite)
dans les expressions arithmétiques, le type de taille supérieure
détermine le type de conversion
int count = 3;
count + 5.8978; // conversion to double 3.0 + 5.8978
exemple de plusieurs conversions
int count = 10;
count = count * 2.3; // Conversion to 10.0*2.3
// Conversion de 23.0 a int 23
résultat identique pour
count *= 2.3; // count is now 23 not 20
tout pointeur à une valeur non constante de n’importe quel type, peut
être affecté à un pointeur de type void*
char* name = 0;
void* aPointer = name; // implicit conversion


Conversion de Type (suite)
l’inverse n’est pas vrai
name = aPointer; // ERROR: different pointer types
Conversion explicite ou casting
demandée par le programmeur
exemple
int result = 34;
result = result + static_cast<int>(10.890);
peut être aussi écrit
result = result + int(10.890); // old style notation
permet d’utiliser des pointeur génériques (au risque du programmeur)
char* name;
void* genericPointer;
name = (char*)genericPointer; // explicit conversion


Type des données
Types Fondamentaux
Mots Réservés
Constantes
Enumerations
Conversion de Type


Partie 2: Types, Variables, Opérateurs — Programmation orientée objet en C++

Contenu connexe

Tendances (20)

En vedette (12)

Similaire à Partie 2: Types, Variables, Opérateurs — Programmation orientée objet en C++ (20)

Partie 2: Types, Variables, Opérateurs — Programmation orientée objet en C++