# Jour 2
## Pointeurs & Références
### Adresses en C++
Pour comprendre les pointeurs, il faut d’abord comprendre comment les données sont stockées sur l’ordinateur.
Chaque variable crée par votre variable se voit assignée une “place” sur l’ordinateur. La valeur que la variable contient est stockée à cet endroit. Pour connaitre l’emplacement de cette endroit, C++ dispose de l’opérateur `&`(opérateur de référencement), qui vous donne l’adresse occupée par une variable.
Si `var`est une variable, alors `&var`renvoie l’adresse de cette variable:
```cpp
#include <iostream>
int main() {
int var1 = 3;
int var2 = 24;
int var3 = 17;
std::cout << &var1 << std::endl; // 0x7fff5fbff8ac
std::cout << &var2 << std::endl; // 0x7fff5fbff8a8
std::cout << &var3 << std::endl; // 0x7fff5fbff8a4
}
```
## hello einar
**Attention !** Vous n’aurez probablement pas les mêmes adresses en testant ce bout de code chez vous.
Le `0x`au début représente l’adresse sous sa forme hexadécimale.
### Pointeurs
C++ nous donne la possibilité de manipuler directement la donnée dans la mémoire. On peut assigner et dé-assigner de l’espace dans la mémoire comme on le souhaite, en utilisant les pointeurs. La définition à retenir est la suivante:
`Un pointeur est une variable qui contient l'adresse d'une autre variable.`
Un pointeur est déclaré de la sorte:
```cpp
int *p;
```
Ici, `p` est un pointeur sur `int`, càd qu’il pointe vers un entier dans l’adresse stockée.
### Référencement `&` et deréférencement `*`
L’opérateur `&`renvoie l’adresse d’une variable.
Pour obtenir la valeur stockée à un emplacement donné, on utilise l’opérateur `*`
*Par exemple:* Si un entier est stocké à l’adresse mémoire `0x123` et qu’il contient la valeur 5.
L’opérateur `&` nous donne la valeur 0x123, tandis que l’opérateur `*` nous renvoie 5.
*Attention:* Le signe `*`utilisé lors de la déclaration d’un pointeur n’est pas l’opérateur de deréférencement, mais tout simplement une notation similaire.
### Exemple concret
```cpp
#include <iostream>
int main() {
int *pc, c;
c = 5;
std::cout << "Adresse de c (&c): " << &c << std::endl;
std::cout << "Valeur de c (c): " << c << std::endl << std::endl;
pc = &c; // Le pointeur pc contient l'adresse mémoire de c
std::cout << "Adresse contenue par le pointeur pc (pc): "<< pc << std::endl;
std::cout << "Contenu de l'adresse contenue par pc (*pc): " << *pc << std::endl << std::endl;
c = 11; // Le contenu de l'adresse mémoire &c change de 5 à 11.
std::cout << "Adresse que contient le pointeur pc (pc): " << pc << std::endl;
std::cout << "Contenu de l'adresse contenur par pc (*pc): " << *pc << std::endl << std::endl;
*pc = 2;
std::cout << "Adresse de c (&c): " << &c << std::endl;
std::cout << "Valeur de c (c): " << c << std::endl << std::endl;
return 0;
}
```
Voici le contenu de la sortie standard:
```
Adresse de (&c): 0x7fff5fbff80c
Valeur de c (c): 5
Adresse contenue par le pointeur pc (pc): 0x7fff5fbff80c
Contenu de l'adresse contenue par pc (*pc): 5
Adresse contenue par le pointeur pc (pc): 0x7fff5fbff80c
Contenu de l'adresse contenue par pc (*pc): 11
Adresse de c (&c): 0x7fff5fbff80c
Valeur de c (c): 2
```
## Allocation dynamique de mémoire
Dans les programmes vus précédemment, toute la mémoire nécéssaire étaient déterminée avant l’execution du programme en définissant les variables requises. Mais il y’a des moments où nous ne pouvons définir les ressources mémoires nécessaires à un programme que lors de l’exécution de ce dernier. Imaginons par exemple que la mémoire nécessaire dépendent d’une entrée utilisateur. Afin de résoudre ce problème, C++ nous donne les opérateurs `new`& `delete`.
### Opérateur `new`
La mémoire dynamique est allouée en utilisant l’opérateur `new`, suivi d’un type de donnée, et si on a besoin d’une séquence de données, le nombre d’items entre `[]`. Il renvoie un pointeur vers le début du nouveau bloc de mémoire nouvellement créé. En voici la syntaxe:
```cpp
int *var = new int;
int *arr = new int[42];
```
Ici, `arr`est un pointeur dont son premier élément peut être accédé soit par l’expression `*foo`mais également par l’expression `foo[0]`.
La différence la plus importante entre un tableau normal et un tableau déclaré avec `new` est que la taille d’un tableau normal doit être une expression constante, et sa taille doit de fait être déterminée à la compilation, avant son exécution, tandis que l’allocation dynamique avec `new`permet d’assigner de la mémoire pendant l’exécution de ce dernier, en utilisant n’importe quelle variable comme taille.
### Opérateur `delete`
La plupart du temps, la mémoire allouée dynamiquement n’est nécessaire que durant une période de temps donnée; dès qu’elle n’est plus requise, elle peut être libérée afin de redevenir disponible pour d’autres réutilisations. Ceci est effectué par l’opérateur `delete`, dont voici la syntaxe:
```cpp
delete var; // pour libérer l'espace alloué avec `new`
delete[] arr; // pour libérer l'espace alloué avec `new[]`
```
## Héritage
L’héritage désigne le fait de baser une classe sur une autre classe, afin que la classe appelée “fille” implémente automatiquement toutes les propriétés (variables) et comportements (méthodes) de la classe appelée “mère”. C’est un mécanisme permettant la ré-utilisation du code de manière aisée, et l’extension aisée d’une classe tout en maintenant ses caractéristiques désirées.
Par exemple, imaginons une série de classes permettant de décrire deux types de polygones: *rectangles* et *triangles*. Ces deux polygones ont certaines propriétés communes, comme les valeurs nécessaires au calcul de leurs aires: ils peuvent être décrits par leur hauteur et leur largeur (ou base).
```cpp
class Polygon {
};
class Triangle
: public Polygon {
};
```
La portée *public* peut être remplacée par n’importe quel autre portée (*protected* ou *private*). Cette dernière limite les niveaux les plus accessibles pour les membres hérités de la classe mère: Les membres avec un niveau d’accessibilité plus élevé sont hérités avec ce niveau là par défaut, tandis que les membres avec un niveau d’accessibilité égal ou plus restrictif gardent leur niveau d’accessibilité dans la classe fille.
```cpp
#include <iostream>
class Polygon {
protected:
int m_width, m_height;
public:
void set_values (int a, int b) {
m_width = a;
m_height = b;
}
};
class Rectangle
: public Polygon {
public:
int area() const {
return m_width * m_height;
}
};
class Triangle
: public Polygon {
public:
int area() const {
return (m_width * m_height) / 2;
}
};
int main () {
Rectangle rect;
Triangle trgl;
rect.set_values (4,5);
trgl.set_values (4,5);
cout << rect.area() << '\n';
cout << trgl.area() << '\n';
return 0;
}
```
## Polymorphisme
Polymorphe = “Qui peut prendre plusieurs formes”.
Le polymorphisme définit la capacité de pouvoir fournir une interface unique à des entités pouvant avoir différents types.
Une des fonctionnalités centrales de l’héritage en C++ est qu’un pointeur vers une classe fille est compatible avec un pointeur de la classe mère. Le polymorphisme nous permet de prendre avantage de cette feature simple mais extrêmement puissante. Si nous reprenons notre example des polygones ci-dessus, nous pouvons écrire la fonction `main`suivante:
```cpp
#include <iostream>
int main () {
Rectangle rect;
Triangle trgl;
Polygon * ppoly1 = ▭
Polygon * ppoly2 = &trgl;
ppoly1->set_values (4, 5);
ppoly2->set_values (4, 5);
std::cout << rect.area() << '\n'; // 20
std::cout << trgl.area() << '\n'; // 10
return 0;
}
```
Le main déclare deux pointeurs sur `Polygon`. Ils contiennent les adresses de `rect` et de `trgl`, qui sont des objets de type `Rectangle` et `Triangle`. Ces assignations sont valides, car ces deux types dérivent de `Polygon`.
On peut également deréférencer `ppoly1`et `ppoly2` et accéder aux membres de l’objet pointé, mais comme le type manipulé est `Polygon`, nous pouvons seulement accéder aux membres hérités de ce dernier.
## Enumérations
Une énumération est un type définissable par l’utilisateur qui est composé de constantes entières.
```cpp
#include <iostream>
enum Color {
RED,
BLUE,
GREEN,
YELLOW,
PURPLE
};
int main() {
Color c;
c = Color::YELLOW;
std::cout << "Color: " << c << std::endl; // 3
}
```
Par défaut, `RED` est à 0, `BLUE`est à 1, et ainsi de suite. Vous pouvez changer la valeur par défaut d’un des éléments si nécéssaire:
```cpp
enum Color {
RED,
BLUE = 4,
GREEN, // 5
YELLOW = 10,
PURPLE // 11
};
int main() {
Color c;
c = Color::YELLOW;
std::cout << "Color: " << c << std::endl; // 10
}
```
## Tableaux
En C++, la syntaxe pour utiliser et manipuler un tableau est plutôt simple:
```cpp
int arr [5] = { 16, 2, 77, 40, 12071 }; // arr = [16, 2. ,77, 40, 12071]
int arr [5] = { 10, 20, 30 }; // arr = [10, 20, 30, 0, 0]
int arr [5] = { }; // arr = [0, 0, 0, 0, 0]
int arr [] = { 16, 2, 77, 40, 12071 }; // crée automatiquement un tableau de la bonne taille (5)
arr[2] = 75; // stocke 75 dans le 3eme élément du tableau
```
## Allocation dynamique de mémoire
Dans les programmes vus précédemment, toute la mémoire nécéssaire étaient déterminée avant l’execution du programme en définissant les variables requises. Mais il y’a des moments où nous ne pouvons définir les ressources mémoires nécessaires à un programme que lors de l’exécution de ce dernier. Imaginons par exemple que la mémoire nécessaire dépendent d’une entrée utilisateur. Afin de résoudre ce problème, C++ nous donne les opérateurs `new`& `delete`
### Opérateur `new`
La mémoire dynamique est allouée en utilisant l’opérateur `new`, suivi d’un type de donnée, et si on a besoin d’une séquence de données, le nombre d’items entre `[]`. Il renvoie un pointeur vers le début du nouveau bloc de mémoire nouvellement créé. En voici la syntaxe:
```cpp
int *var = new int;
int *arr = new int[42];
```
Ici, `arr`est un pointeur dont son premier élément peut être accédé soit par l’expression `*foo`mais également par l’expression `foo[0]`.
La différence la plus importante entre un tableau normal et un tableau déclaré avec `new` est que la taille d’un tableau normal doit être une expression constante, et sa taille doit de fait être déterminée à la compilation, avant son exécution, tandis que l’allocation dynamique avec `new`permet d’assigner de la mémoire pendant l’exécution de ce dernier, en utilisant n’importe quelle variable comme taille.
### Opérateur `delete`
La plupart du temps, la mémoire allouée dynamiquement n’est nécessaire que durant une période de temps donnée; dès qu’elle n’est plus requise, elle peut être libérée afin de redevenir disponible pour d’autres réutilisations. Ceci est effectué par l’opérateur `delete`, dont voici la syntaxe:
```cpp
delete var; // pour libérer l'espace alloué avec `new`
delete[] arr; // pour libérer l'espace alloué avec `new[]`
```
## Surcharges de fonctions
Il est interdit en C de définir plusieurs fonctions qui portent le même nom. En C++, cette interdiction est levée, moyennant quelques précautions. Le compilateur peut différencier deux fonctions en regardant le type et le nombre des paramètres qu'elle reçoit. La liste de ces types s'appelle la *signature* de la fonction. En revanche, le type du `return` de la fonction ne permet pas de l'identifier, car le résultat peut ne pas être utilisé ou peut être converti en une valeur d'un autre type avant d'être utilisé après l'appel de cette fonction.
Il est donc possible de faire des fonctions de même nom (des *surcharges*) si et seulement si toutes les fonctions portant ce nom peuvent être distinguées par leurs signatures. La surcharge qui sera appelée sera celle dont la signature est la plus proche des valeurs passées en paramètre lors de l'appel.
```cpp
int operate(int a, int b) {
return (a * b);
}
double operate(double a, double b) {
return (a / b);
}
float operate(float a) {
return (a * a);
}
int main() {
int x = 5, y = 2;
double n = 5.0, m = 2.0;
std::cout << operate(x, y) << '\n'; // 10
std::cout << operate(n, m) << '\n'; // 2.5
std::cout << operate(n) << '\n'; // 25.0
return 0;
}
```
## Surcharge d’opérateur
En C, il est possible de changer la manière dont les opérateurs fonctionnent (pour les types définis par l’utilisateur).
Imaginons par exemple que nous ayons deux objets d’une classe qui contiennent une chaine de caractères. Nous pourrions redéfinir le sens de l’opérateur `+` et l’utiliser pour concaténer ces chaines de caractères.
Vous pouvez écrire du code C++ sans jamais connaître l’existence de la surcharge d’opérateurs. cependant , cette feature du langage est très utilisée par les développeurs afin de rendre la programmation bien plus intuitive. Par exemple:
```cpp
// on pourrait remplacer cette ligne de code
calculation = add(multiply(a, b),divide(a, b));
// par la suivante
calculation = (a * b) + (a / b);
```
Afin de voir une application concrète de la surcharge d’opérateur, ainsi que sa syntaxe, prenons l’exemple d’un vecteur mathématique 2D:
```cpp
class Vector2D {
public:
int m_x, m_y;
public:
Vector2D(int x, int y);
Vector2D operator+(Vector2D const &o) const;
inline bool operator==(Vector2D const &o) const {
return m_x == o.m_x && m_y == o.m_y;
}
};
Vector2D::Vector2D(int x, int y)
: m_x(x), m_y(y)
{}
Vector2D Vector2D::operator+(Vector2D const &o) const {
return Vector2D(m_x + o.m_x, m_y + o.m_y);
}
```
Il existe de multiples syntaxes permettant de surcharger des opérateurs, n’hésitez pas à vous renseigner sur ces dernières, car elles peuvent se révéler toutes utiles selon le cas d’usage.
Google Drive
Gist
Clipboard
Sign in with Wallet
