#C 12

### Exercice 2

La pile: mémoire rapide sur le principe du premier arrivé dernier sorti. Dedans est stoqué les variables transmises à travers les fonctions. Il y en a donc une par thread.

Le tas contient toutes les variables qui sont définies dynamiquement avec malloc. L'accès est plus lent puisque toutes les adresse doivent être «retenus».

### Exercice 3
Le programme va poser problème. En effet, lors de l'entrée dans le main, le programme demande 10000*10000 entiers dans la pile: cette dernière explose. On pourrait allouer cet espace, mais dans le tas avec 
```
int main(){
    int n=10000;
    int** carte = malloc(n*sizeof(int*));
    int* carteData = calloc(n*n, sizeof(int*));
    
    //on initialise la carte
    for(int i=0;i<n;i++)  {
        carte[n] = carteData + i*n;
    }
    //on fait des choses
    return 0;
}
```

### Exercice 4
Ce programme va plus poser problème parce que les valeurs des paramètres seront stoqués dans la pile. Les 100_000_000 valeurs de paramètres. Dans la pile. Elle a une taille limitée donnée par le système d'exploitation.

### Exercice 5

La taille utilisée sur la pile varie à chaque appel à des fonctions, afin de stoquer la valeur des paramètres (passage en valeur). La taille du tas peut elle aussi varier, notemment à travers les appels à `malloc`.


### Exercice 6
`malloc` demande au système d'explotation de lui réserver un espace memoire de taille arbitraire (des octets contigüs). Si accépté, la fonction renvoie un pointeur vers une adresse mémoire correspondant au premier octet de l'allocation. Cette adresse peut ensuite être cast en un pointeur afin de pouvoir faire de l'arithmétique cohérente avec la taille des entiers utilisés.

### Exercice 7
La fonction free indique au système d'exploitation que l'emplacement qui avait précedement été réservé avec `malloc` peut être libéré. Le programme n'a donc plus accès aux données et l'OS peut réallouer la portion. C'est très important afin d'éviter une fuite de mémoire, c'est à dire que la totalité de la mémoire ait été réservée et non libérée même si plus utilisée par un programme mal fait.

### Exercice 9

Rien n'assure que notre grille soit contiguë en mémoire. Les pointeurs vers les pointeurs des lignes sont eux contigüs, ainsi que les données dans chaque ligne, mais rien de plus ne peut être assuré. En effet, d'autres appels à *alloc ont pû être effectués pendant la génération de la matrice, ou pendant son redimensionnement.

J'aurais pû effectivement faire un seul calloc au début, avec quelque chose ressemblant à :

```
int * data = calloc(h*w, sizeof(int))

for(int i=0;i<h;i++)
  arr[i] = data + w*i;
```