Cours 1 - Les Pointeurs

name: inverse
layout: true
class: center, middle, inverse

---
# Inès de Courchelle
## Les pointeurs
## 2023-2024

![image](../img/CY-tech.png)

---
layout: false

# Avant de Commencer

## Objectif
Avant de coder, il faut réaliser une première phase d'analyse (TOUJOURS)

## Comment ?

Avec un papier et stylo

## Pourquoi ?
Pour bien réfléchir aux éléments que l'on manipule

---
# Aujourd'hui
## Objectifs
- Manipuler les pointeurs
- Allouer de l'espace mémoire
- Utiliser des adresses de variables

## Plan
1. Les variables et leur adresse
2. Les pointeurs

---
# Qu'est ce qu'une variable ?
## Définition
- Il peut changer de valeur dans le temps
- Il a besoin d'un type + nom
- Il ne prend pas d'accent, ni de ponctuation
```c
int a;
a=4;
```

## Stockage d'une variable
- Une variable est stockée dans le PC à une adresse mémoire
- Son adresse nous est données via le **&**
```c
printf("la valeur de mon petit a est : %d \n",a);
printf("l'adresse de mon petit a est : %p \n",&a);
```
---
# Le pointeur
## Pourquoi ?
- Manipuler des variables en dehors et à l'intérieur d'une methode/fonction
- Ne pas mettre la variable en retour d'une fonction mais la modifier quand même !

## Quand ?
- Utilisation de Tableau
- Manipulation de chaîne de caractères

## Comment ?
.pull-left[
 Utiliser les **\***
]
.pull-right[
<img src="https://media.giphy.com/media/1Md9azxcgIyQ/giphy.gif" width=200/>
]

---
# Représentation d'un pointeur en C
## Généralisation
<img src="img/pointeur1.png" width=300/>

.underV[p_a est un pointeur qui pointe vers l'adresse de a]

## Attention
- un pointeur a un type
- il ne peut pointer que vers l'adresse d'une variable qui a le même type que lui !

.underV[p_a est un pointeur d'entier qui pointe vers l'adresse de a qui doit être un entier]

---
# Utilisation d'un pointeur

.pull-left[
##### Déclaration
```c
int* p_a;
float* p_b;
int i_a;
float f_b;
```

##### Affectation
```c
i_a=42;
f_b=66.6;
```
##### Faire pointer
```c
p_a=&i_a;
p_b=&f_b;
```
##### Affichage
```c
printf("%d \n",*p_a);
printf("%f \n",*p_f);
```
]

.pull-right[
| variable | adresse | valeur |
|----------|---------|--------|
| p_a      | 0x7ppa  | 0x7aai |
| p_b      | 0x7ppb  | 0x7ffb |
| i_a      | 0x7aai  | 42     |
| f_b      | 0x7ffb  | 66.6   |
| *p_a     | 0x7aai  | 42     |
| *p_b     | 0x7ffb  | 66.6   |

]
---
# PANICCCCC

.pull-left[
<img src="https://media.giphy.com/media/1FMaabePDEfgk/giphy.gif" width=300/>
]
.pull-right[
<img src="https://media.giphy.com/media/8Ep2aFnTfs6TC/giphy.gif" width=300/>
]
---
# Posey !
<img src=" https://media.giphy.com/media/xT5LMFzytmJ07GmqkM/giphy.gif" width=300/>

#### On va y aller petit à petit !

---
# Déclaration d'un pointeur
## Illustration
```c
int* p_a;
float* p_b;
```
<img src="img/declarationP.png" width=200/>

## Un pointeur possède
- un nom
- une adresse
- un type
- une flêche qui pointe vers une adresse d'une variable du même type !

---
# Affectation d'une variable
## Illustration
```c
i_a=42;
f_b=66.6;
```

## Une variable possède
- un nom
- une adresse
- un type

---
# Faire pointer
## Illustration
.pull-left[
```c
p_a=&i_a;
p_b=&f_b;
```
]
.pull-right[
<img src="img/exemple_pointeur.png" width=300/>
]

*L'adresse d'une variable nous est donnée via **&***
- i_a donne 42
- &i_b donne 0x7aai

.pull-left[
.underG[La valeur de l'adresse est gérée par le système]
]
.pull-right[
<img src="https://media.giphy.com/media/28HuTvEHje7v1ngGAm/giphy.gif" width=125/>

]

---
# Une variable VS une adresse

.pull-left[
## Les valeurs !
```c
printf("%d \n",*p_a);
printf("%f \n",*p_f);
printf("%d \n",i_a);
printf("%f \n",f_b);
```
## Les Adresses !
```c
printf("%p \n",&i_a);
printf("%p \n",&f_b);
printf("%p \n",&p_b);
printf("%p \n",&p_a);
```
]
.pull-right[

| variable | adresse         | valeur       |
|----------|-----------------|--------------|
| p_a      | .underR[0x7ppa] | 0x7aai       |
| p_b      | .underR[0x7ppb] | 0x7ffb       |
| i_a      | .underR[0x7aai] | .under[42]   |
| f_b      | .underR[0x7ffb] | .under[66.6] |
| *p_a     | 0x7aai          | .under[42]   |
| *p_b     | 0x7ffb          | .under[66.6] |

]

---
# À vous de jouer 1/3
## Exercice 1
.underR[Attention je ne donne pas la correction au format info, à vous de prendre des notes]
Nous considérons les informations suivantes :

| variable | adresse | valeur |
|----------|---------|--------|
| p_nb     | 0x1pa   | 0x1aa  |
| i_nb     | 0x1aa   | 12     |

Compléter le tableau suivant :

| Écriture      | type(adresse ou entier) | valeur |
|---------------|-------------------------|--------|
| &i_nb         |                         |        |
| i_nb          |                         |        |
| &p_nb         |                         |        |
| *p_nb         |                         |        |
| &(*p_nb)      |                         |        |
| *(&p_nb)      |                         |        |
| \*(\*(&p_nb)) |                         |        |

---
# À vous de jouer 2/3
## Exercice 2
.underR[Attention je ne donne pas la correction au format info, à vous de prendre des notes]

Écrire le programme permettant de réaliser le schéma suivant :
<img src="img/exo1.png" width=250/>

---
# À vous de jouer 3/3
## Exercice 3
.underR[Attention je ne donne pas la correction au format info, à vous de prendre des notes]

Modifier le code précédent pour obtenir le schéma suivant :
<img src="img/exo2.png" width=250/>

---
# Des pointeurs de pointeurs
## Illustration
```c
 /* Déclaration */
 int** pp_a;
 int* p_a;
 int a;
 /* Affectation */
 a=11;
 pp_a=&p_a;
 p_a=&a;
 /* Affichage */
 printf("la valeur de a est %d \n",**pp_a);
```
<img src="img/doupleP.png" width=400/>

---
# VAR
## Problème !
#### Objectif
Faire une procédure pour échanger deux variables

#### Pourquoi ?
- ça va nous servir pour trier des listes et des tableaux
- ça illustre le principe des pointeurs

---
# Échange
## Version 1
#### En Algo
```c
PROGRAMME V1
VARIABLES
 a,b : entier
DEBUT
 a <- 24
 b <- 42
 ECRIRE("avant la procédure echanger a = "+ a +" et b= "+b)
 echanger(a,b)
 ECRIRE("avant la procédure echanger a = "+ a +" et b= "+b)
FIN

PROCEDURE echanger(x,y : entier)
DEBUT
 x <- y
 y <- x
FIN
```

---
# Échange
## Version 1
#### En C
```c
#include <stdio.h>
#include <stdlib.h>

int main(){
  int a,b;
  a=24;
  b=42;
  printf("avant la procedure : a = %d et b=  %d \n",a,b);
  echanger(a,b);
  printf("après la procedure : a = %d et b=  %d \n",a,b);

return 0;
}

void echanger(int x, int y){
  x=y;
  y=x;
}
```

---
# Échange
## Version 1
.pull-left[
#### En C
```c
#include <stdio.h>
#include <stdlib.h>

int main(){
  int a,b;
  a=24;
  b=42;
  printf("avant la procedure : a = %d et b=  %d \n",a,b);
  echanger(a,b);
  printf("après la procedure : a = %d et b=  %d \n",a,b);

return 0;
}

void echanger(int x, int y){
  x=y;
  y=x;
}
```
]

.pull-right[
#### En Algo
```c
PROGRAMME V1
VARIABLES
 a,b : entier
DEBUT
 a <- 24
 b <- 42
 ECRIRE("avant la procédure echanger a = "+ a +" et b= "+b)
 echanger(a,b)
 ECRIRE("avant la procédure echanger a = "+ a +" et b= "+b)
FIN

PROCEDURE echanger(x,y : entier)
DEBUT
 x <- y
 y <- x
FIN
```
]
---
# Échange
## Version 1
<video src="videos/echange1.mp4" width="700" controls poster="vignette.jpg"> </video>

---
# Échange
## Version 2
#### En C
```c
#include <stdio.h>
#include <stdlib.h>

void echanger(int x, int y);

int main(){
  int a,b;
  a=24;
  b=42;
  printf("avant la procedure : a = %d et b=  %d \n",a,b);
  echanger(a,b);
  printf("après la procedure : a = %d et b=  %d \n",a,b);

return 0;
}

void echanger(int x, int y){
 x=y;
 y=x;
}
```
---
# Échange
## Version 2
<img src="img/echangeSignature1.png" width=600>

---
# Échange
## Version 2
<img src="img/echangeSignature2.png" width=600>

---
# Échange
## Version 2
<video src="videos/echange2.mp4" width="700" controls poster="vignette.jpg"> </video>

---
# Échange
## Version 3
<video src="videos/echange3.mp4" width="700" controls poster="vignette.jpg"> </video>

---
# Échange
## Explication
<img src="img/echange/perm1.png" width=350/>

---
# Échange
## Explication
<img src="img/echange/perm2.png" width=350/>

---
# Échange
## Explication
<img src="img/echange/perm3.png" width=350/>

---
# Échange
## Explication
<img src="img/echange/perm4.png" width=350/>

---
# Échange
## Explication
<img src="img/echange/perm5.png" width=350/>

---
# Échange
## Explication
<img src="img/echange/perm6.png" width=350/>

---
# Échange
## Explication
<img src="img/echange/perm7.png" width=350/>

---
# Échange
## Version 4
<video src="videos/echange4.mp4" width="700" controls poster="vignette.jpg"> </video>

---
# Échange
## Explication
<img src="img/echange2/perm1.png" width=350/>

---
# Échange
## Explication
<img src="img/echange2/perm2.png" width=350/>

---
# Échange
## Explication
<img src="img/echange2/perm3.png" width=350/>

---
# Échange
## Explication
<img src="img/echange2/perm4.png" width=350/>

---
# Échange
## Explication
<img src="img/echange2/perm5.png" width=350/>

---
# Échange
## Explication
<img src="img/echange2/perm6.png" width=350/>

---
# Échange
## Explication
<img src="img/echange2/perm7.png" width=350/>

---
# Échange
## Version 5
<video src="videos/echange6.mp4" width="700" controls poster="vignette.jpg"> </video>

---
# Échange
## Version 6
#### En C
```c
#include <stdio.h>
#include <stdlib.h>
/* auteur : Inès de Courchelle */
/* date : 28-11-23*/
/* résumé : procedure permettant d'echanger 2 entiers*/
/* entree : 2 entiers */
/* sortie : aucunes */
void echanger(int* x, int* y);
int main(){
 int a,b;
 a=24;
 b=42;
 printf("avant la procedure : a = %d et b= %d \n",a,b);
 echanger(&a,&b);
 printf("après la procedure : a = %d et b= %d \n",a,b);
 return 0;
}
void echanger(int* x, int* y){
 int tmp;
 tmp=*x;
 *x=*y;
 *y=tmp;
}
```
---
# Échange
## Version 6
#### En algo
```c
PROGRAMME V6
VARIABLES
 a,b : entier
DEBUT
 a <- 24
 b <- 42
 ECRIRE("avant la procédure echanger a = "+ a +" et b= "+b)
 echanger(a,b)
 ECRIRE("avant la procédure echanger a = "+ a +" et b= "+b)
FIN

PROCEDURE echanger(x,y : entier)
DEBUT
 temp <- x
 x <- y
 y <- x
FIN
```
---
# Échange
## Version 6
.pull-left[
#### En algo
```c
PROGRAMME V6
VARIABLES
 a,b : entier
DEBUT
 a <- 24
 b <- 42
 ECRIRE("avant la procédure echanger a = "+ a +" et b= "+b)
 echanger(a,b)
 ECRIRE("avant la procédure echanger a = "+ a +" et b= "+b)
FIN

PROCEDURE echanger(x,y : entier)
DEBUT
 temp <- x
 x <- y
 y <- x
FIN
```
]
.pull-right[
#### En C
```c
#include <stdio.h>
#include <stdlib.h>
/* auteur : Inès de Courchelle */
/* date : 28-11-23*/
/* résumé : procedure permettant d'echanger 2 entiers*/
/* entree : 2 entiers */
/* sortie : aucunes */
void echanger(int* x, int* y);
int main(){
 int a,b;
 a=24;
 b=42;
 printf("avant la procedure : a = %d et b= %d \n",a,b);
 echanger(&a,&b);
 printf("après la procedure : a = %d et b= %d \n",a,b);
 return 0;
}
void echanger(int* x, int* y){
 int tmp;
 tmp=*x;
 *x=*y;
 *y=tmp;
}
```
]
---
# Échange
## Version 6
<video src="videos/echange6.mp4" width="700" controls poster="vignette.jpg"> </video>

---
# HELP !
## Naviguation terminal
```shell
cd .. # Pour revenir au répertoire précédent dans l'arborescence
cd nomduRepertoire # pour aller dans un répertoire présent où je me trouve
cd /home/monLogin/Documents # pour aller dans un répertoire
                            # en indiquant le chemin complet
ls # pour afficher le contenu du repertoire où je me trouve
```
## Compilation
```shell
gcc -Wall monProgramme.c -o exe
```
## Exécution
```shell
./exe
```