Test sommatif #1 Flashcards
2.5%
Classe
structure regroupant les données (attributs ou membres) et les opérations
(méthodes) pour un concept donné. Exemple: un étudiant.
Attribut
aussi appelée membre ou propriété d’une classe, l’attribut contient un élément
d’information d’une classe (dans une variable)
Méthode
opération d’une classe, contenant du code. On évite les termes fonctions et
procédures.
Objet
« instance » d’une classe, représentant un élément tangible. Par exemple, Fido est
un objet ou une instance de la classe Chien.
public
accessibles à l’extérieur et à l’intérieur de la classe. Souvent les méthodes getXYZ
(getters) sont publiques mais ce n’est pas obligatoire.
protected
accessibles dans les classes dérivées (héritées) et à l’intérieur de la classe. Rarement
utilisé en général mais bien pratique pour les setXYZ (setters) afin de préserver les
validations qu’on souhaiterait réaliser.
private
accessibles uniquement à l’intérieur de la classe.
.h (header)
Le fichier d ’en-tête contient à la déclaration de la classe. On y place le nom de la classe, les
modificateurs de visibilité, les déclarations des attributs et des méthodes. En général, on n’y place
pas de définitions (pas de corps de méthodes).
.cpp
Le fichier .cpp contient la définition de la classe. On y place les définitions des attributs statiques
ainsi que la définition (le corps) des méthodes.
2 grands types d’algorithme de recherche
Recherche linéaire (glouton)
Recherche dichotomique (diviser pour régner)
critère de performance très important
Remarquez le nombre de comparaisons effectuées (apparaît en
haut à gauche)
Algorithmes de tri lent
Tri par sélection
Tri par insertion
Tri à bulles
Etc
Algorithmes de tri rapide
Tri fusion
Tri rapide
Etc
sortes des complexités algorithmiques De temps
Nombre d’opérations élémentaires effectuées par un
algorithme
sortes des complexités algorithmiques D’espace
Nombre d’espace physique (essentiellement de la mémoire)
occupé par l’algorithme
Données (Data segment)
pour les variables globales et statiques
Code (code segment)
pour le code compilé
Tas (Heap):
pour l’allocation dynamique
Pile (Stack)
pour les variables locales
void UneFonction (int nombre3);
int nombre1;
void main()
{
Ennemi * e1;
e1 = new Ennemi;
UneFonction(7);
}
void UneFonction(int nombre3)
{
int nombre2;
}
class Ennemi
{
static int cptInstance;
// . . .
};
Données
cptInstance
nombre1
Tas
e1
(contenu)
Pile
nombre2 (fonction)
nombre3 (fonction)
e1 (pointeur)
La taille d’un int
4 octets
comment est c’est représenté un int dans la mémoire
52 0 0 0
0x00effc08 0x00effc09 0x00effc0A 0x00effc0B
int a
52
&a
0x00effc08 Emplacement
mémoire de a. On
dit aussi un pointeur
vers a.
((unsigned char)&a)
52 Valeur de l’octet se
trouvant l’adresse
mémoire de a.
(((unsigned char)&a)+1)
0 Valeur du premier
octet qui suit
l’adresse mémoire
de a
&
une façon
d’obtenir l’adresse de l’original
int valeurDeA = *ptrA;
Si l’on veut accéder ce qui se trouve à une adresse on utilise l’opérateur *
Passage par référence
Lorsque l’on passe un paramètre par référence, on utilise l’adresse de l’original
pointeur
Un pointeur est une adresse. Cette adresse est stockée sur 32 bits
Arithmétique de pointeurs
Si l’on exécute les instructions suivantes :
int a = 52;
int* ptrA = &52;
int* pValeur = ptrA + 1;
la valeur de pValeur sera celle de ptrA augmentée de 4 octets car ptrA est un pointeur de int
et un int occupe 4 octets en mémoire.
int* pData;
e pointe vers RIEN DE CONCRET. On ne veut pas faire cela
allouer une zone de mémoire dynamique on utilise un pointeur
int* pData = new int;
delete pData;
Contrairement à Java et C#, NOUS sommes responsables de libérer la mémoire allouée avec new
lorsqu’elle n’est plus nécessaire. Le pointeur peut alors être réutilisé pour un autre emplacement mémoire mais le contenu
désormais pointé est indéterminé.
fuite de
mémoire.
void doIt()
{
int * pData = new int;
pData = 80;
}
void main()
{
doIt();
}
A la fin de l’exécution de la fonction doIt, la portée de la variable local pData sera terminée. La
variable sera libérée MAIS PAS L’ESPACE MÉMOIRE POINTÉ par pData.
Allocation d’un tableau
int* pData = new int[10];
std::cout «_space;pData[4];
est l’équivalent de
std ::cout «_space;*(pData+4);
Pour libérer un tableau
delete[] pData;
*p = 52;
On utilise l’opérateur « * » pour affecter une valeur du type qui a été
déclaré
Allocation dynamique :
Variables locales :
Statiques et globales :
Code compilé :
heap
stack
data
code
remplir tab dynamique
int * tab = new int[10];
// remplissage avec le [ ]
for(int i = 0; i < 10; i++)
{
tab[i] = i + 10;
}
ou pointe adresse dun tab
premer element du tabb
1) Stocker des références vers des entiers :
int * tab[10];
int a = 12;
tab[0] = &a;
Rien de dynamique dans cette approche, rien à faire non plus
lorsqu’on n’a plus besoin de ce tableau (tout est sur la stack).
2) Stocker des pointeurs vers des entiers alloués
dynamiquement:
int * tab[10];
tab[0] = new int;
*tab[0] = 12 //même principe avec l’étoile
Cette fois-ci il y a un new: toutes les adresses stockées dans le
tableau vont pointer vers un bloc dynamique, il faut en faire la
suppression !
Tableaux de pointeurs delete[] tab; ?
for(int j = 0; j < 10; j++)
{
delete tab[ j ]; //suppression de tous les blocs dynamiques
}
En allocation dynamique, on utilise simplement l’opérateur
d’accès « -> »
ptrEnnemi->attaquer();
La dernière instruction est l’équivalent de
*(ptrEnnemi).attaquer();
Destructeur
void attaquerEnnemi()
{
Ennemi * ptrEnnemi = new Ennemi();
ptrEnnemi->attaquer();
delete ptrEnnemi; //Le destructeur de la classe
Ennemi est appelé ici;
int a = 38
[…]
}
Ennemi * tabEnnemis = new Ennemi[10];
« allocation dynamique de 10 blocs consécutifs pour des
Ennemis en mémoire, la variable tabEnnemis reçoit l’adresse
du premier bloc »
Il faut suivre les règles vues pour le stockage et la suppression !
1) Une classe garde la référence d’une autre classe dans une
de ses variables
Habituellement on ne touche pas à cette référence, on
laisse la stack faire son travail ! Composition faible
2) Une classe alloue dynamiquement une autre classe et
stocke l’adresse reçue dans une variable
Habituellement, la classe qui alloue la mémoire
s’occupe de la libérer Composition forte
Association
La classe « A » utilise un objet de la classe « B ». Aucun attribut de la classe
ne fait référence à un objet de la classe « B »
Agrégation
(ou composition faible)
La classe « A » possède un pointeur sur un objet de la classe « B » parmi ses
attributs mais n’est pas responsable de la destruction de celui-ci. En quelque
sorte, si la classe « A » disparait, la classe « B » ne disparaît pas.
Généralement, l’objet de la classe « B » est instancié à l’extérieur de la classe
« A » et est passé en paramètre à l’une des méthodes de la classe « A »
Composition
(ou composition forte)
La classe « A » possède un pointeur sur un objet de la classe « B » (ou l’objet
directement) parmi ses attributs et est responsable de la destruction de celui-ci.
En quelque sorte, si la classe « A » disparait, la classe « B » doit disparaître.
Généralement, l’objet de la classe « B » est instancié à l’intérieur de la classe
« A », souvent lors de la construction.
p = &total; que contient &p
adresse de p (juste p c’est l’adresse contenu dans p)
