Cours 1 - Les Pointeurs

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

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

![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
- Rappel du s1
- Manipuler les pointeurs
- Allouer de l'espace mémoire
- Utiliser des adresses de variables

## Plan
1. Rappel du S1
2. Les variables et leur adresse
3. Les pointeurs

---
# Rappel Du s1
## Qu'est ce qu'on a fait ?

1. Nous avons écrit des algos
2. Nous avons vu les fonctions/procédures
3. Nous avons codé en C

---
# Rappel Du s1
## Qu'est ce qu'on a fait ?

1. .under[Nous avons écrit des algos]
2. Nous avons vu les fonctions/procédures
3. Nous avons codé en C

---
# Écrire un algo
## C'est quoi ?
- Une recette de cuisine
- Une suite d'instructions pour aller quelque part
- Des consignes de sécurité

## Comment ?
<img src="https://c.tenor.com/dsoNmYoIDUkAAAAC/gif-cerebro.gif" width=200>

---
# Écrire un algo
## Instructions
- Un programme impératif est une suite finie d'instructions comprise en le début et la fin
- L'instruction de base est l'écriture (sortie, affichage ...) d'informations dans le terminal
- Exemple de programme complet : HELLO WORLD

```
PROGRAMME Bonjour
DEBUT
    ECRIRE("bonjour tout le monde")
FIN
```

---
# Écrire un algo
## Variable
- C'est un élément du programme qui sert à stocker une valeur
- Est définie par un nom et un type
- Syntaxe :
```
nomVariable : type
```

## Type
- Un type définit un ensemble de valeurs sur lesquelles on peut appliquer des opérateurs
- Exemple : entier, réel, booléen, chaîne, caractère ...

---
# Écrire un algo
## Déclaration
```
VARIABLES :
 i,j : entiers
 x,y : réels
 estTrouvé : booleen
 reponse : chaine de caractères
```

## Affectation
- Une affectation est le fait de mettre une valeur dans une variable en cohérence avec son type
- La première affectation de valeur à une variable est appelée initialisation
- On la représente par une flèche

#### Exemple
```
i ← 4
reponse ← "Bonjour"
```
.underR[Attention] : Avant d'affecter une valeur il ne faut pas oublier de déclarer la variable

---
# Écrire un algo
## Les conditions
.pull-left[
#### SI ...ALORS
```
SI [CONDITION] ALORS
...
FIN SI
```

#### Si ... SINON SI...
```
SI [CONDITION] ALORS
...
SINON SI [CONDITION] ALORS
...
SINON
...
FIN SI
```
]
.pull-right[
#### SI ... SINON
```
SI [CONDITION] ALORS
...
SINON
...
FIN SI
```
#### SELON
```
SELON [VARIABLE]
    CAS [VALEUR]:
    CAS [VALEUR]:
    CAS [VALEUR]:
    DEFAUT:
FIN SELON
```
]
---
# Écrire un algo
## Une boucle
#### Pour
.pull-left[
Quand on sait combien de fois on veut réaliser une opération
]

.pull-right[
```
POUR i ALLANT de 0 à 10 FAIRE
...
FIN POUR
```
]

---
# Écrire un algo
## Une boucle
#### Tant que Faire ...
.pull-left[
Quand on doit répéter une opération en fonction tant qu'une condition est vérifiée
]

.pull-right[
```
TANT QUE [CONDITION EST VRAI] FAIRE
...
FIN TANT QUE
```

]

#### Faire ... Tant que
.pull-left[

Quand on doit répéter une opération en fonction tant qu'une condition est vérifiée
]

.pull-right[
```
FAIRE
...
TANT QUE [CONDITION EST VRAI]
```
]
---
# Écrire un algo
## La blagounette
<img src="img/lol.jpg" width=400>

---
# Rappel Du s1
## Qu'est ce qu'on a fait ?

1. Nous avons écrit des algos
2. .under[Nous avons vu les fonctions/procédures]
3. Nous avons codé en C

---
# Une fonction
## Définition
Une fonction est une série d'instructions regroupés sous un nom, qui permet d'effectuer des actions. Elle peut prendre entre 0 et N paramètres. Elle renvoie forcement une variable.

## En algo
```
FONCTION nomFonction(param1 : type, param2 : type) : type
VARIABLES
    ...
DEBUT
    ...
    retourner maVar;
FIN
```

.underR[Attention] : une fonction ne peut avoir qu'un seul "retourner" (à part en récursif où il peut il y en avoir plus de 2 !

---
# Une fonction
## Représentation

## Exemple
.pull-left[
<img src="img/templateAddition.png" width=400>
]
.pull-right[
<img src="img/addition.png" width=400>
]

---
# Une fonction
## L'algorithme de la fonction addition
<img src="img/algoAddition.png" width=400>

**Attention** Si le type de retour est un entier la variable retournée doit être un entier

---
# Une procédure
## Définition
Une procédure est une série d'instructions regroupés sous un nom, qui permet d'effectuer des actions. Elle peut prendre entre 0 et N paramètres.

## En algo
```
PROCEDURE nomProcedure(param1 : type, param2 : type)
VARIABLES
    ...
DEBUT
    ...
FIN
```

---
# Une procédure
## Représentation

## Exemple
.pull-left[
<img src="img/templateBonjour.png" width=300>
]
.pull-right[
<img src="img/bonjour.png" width=300>
]

---
# Une procédure
## L'algorithme de la procèdure bonjour
<img src="img/algoBonjour.png" width=600>

**Attention** Pas de valeur de retour !
---
# Procédure - Fonction
## OBLIGATOIRE
Pour chaque foncti Nous avons écris on et procédure, nous définirons :

- **Un résumé** : décrit en une phrase ce que fait la fonction
- **les préconditions** : décrit la nature de l'ensemble des contraintes sur tous les paramètres d'entrée, afin que la fonction puisse s'exécuter correctement
- **la post-condition** : décrit le résultat produit par la fonction/procédures et ses contraintes éventuelles

#### Où ?
En haut du programme

---
# Procédure - Fonction
## OBLIGATOIRE
#### addition

#### bonjour

---
# Rappel Du s1
## Qu'est ce qu'on a fait ?

1. Nous avons écrit des algos
2. Nous avons vu les fonctions/procédures
3. .under[Nous avons codé en C]

---
# 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

.pull-left[
#### En algo
```c
PROGRAMME test
VARIABLE
 a : entier
DEBUT
 a <- 4
FIN
```
]
.pull-right[
#### En C
```c
int main(){
 int a;
 a=4;
 return 0;
}
```
]
---
# Qu'est ce qu'une variable ?
## Stockage d'une variable
- Une variable est stockée dans le PC à une adresse mémoire
- Son adresse nous est données via le **&**

## En C
- On peut afficher une adresse
- Le format : %p

```c
int main(){
    printf("la valeur de mon petit a est : %d \n",a);
    printf("l'adresse de mon petit a est : %p \n",&a);
    return 0;
}
```
---
# Aujourd'hui
## Les pointeurs
Nous allons voir la notion de pointeur !

---
# 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>

---
# BILAN
## Des pointeurs

---
# 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
```