---
title: "Rappel sur les pointeurs"
date: "2023-02-21"
---

# Rappel sur les pointeurs (1/2)

Pour reprendre dans la joie après les ~~vacances~~ **semaines sans cours**.

. . .

## Qu'est-ce qu'un pointeur?

. . .

* Un objet qui stocke une adresse mémoire et le type des données pointées.

. . .

## Comment déclare-t-on les pointeurs en C?

. . .

```C
// type *variable;
double *d;
struct element *e;
```

* `double *` est le **type** de `d` et `struct element *` est le **type** de `e`.

## Comment accède-t-on à la valeur se trouvant à une adresse mémoire?

. . .

```C
int c = 2;
// On assigne l'adresse de c au pointeur p_c
int *p_c = &c;
// On déréférence un pointeur
*p_c = 4;
```

# Rappel sur les pointeurs (2/2)

## Quelle est la seule adresse "interdite"?

. . .

```C
// l'adresse 0 ou NULL
double *e = NULL;
*e = 10; // Runtime error...
double *e;
*e = 10; // Maybe error (e has a random value)...
```

## Qu'est-ce qu'un pointeur n'est pas?

* Un pointeur **n'est pas** entier (mais bien plus)...
* même si en C on peut convertir un pointeur en entier.
* D'ailleurs, on ne **peut pas** déréférencer un entier

```C
uint64_t c = 2;
*c = 3; // ERREUR!
```

# Comment utilise-t-on les pointeurs? (1/2)

## Dans les arguments des fonctions

```C
void modif_argument(int *val) {
    *val = 5;
}
int main() {
    int var = 4;
    modif_argument(&var); // on passe l'adresse de var
}
```

. . .

## Pour allouer de la mémoire sur le tas

```C
int main() {
    int *var = malloc(sizeof(*var));
    struct element *revar = malloc(sizeof(struct element));
    double *tab = malloc(10 * sizeof(*tab));
    free(var);
    free(revar);
    free(tab); // oui il faut pas oublier de désallouer
}
```

# Comment utilise-t-on les pointeurs? (2/2)

## Allouer de la mémoire sur le tas dans fonction

```C
void modif_argument(int **val) {
    *val = malloc(sizeof(int));
}
int main() {
    int *var = NULL;
    modif_argument(&var); // on passe l'adresse de var et donc on alloue
}
```

. . .

## Que se passerait-il si....

```C
void modif_argument(int *val) {
    val = malloc(sizeof(int));
}
int main() {
    int *var = NULL;
    modif_argument(var);
}
```

. . .

* Un code buggé (99.9% du temps) **et** une fuite mémoire...
* Mais avec un peu de chance le code va marcher (comportement indéfini).