Cours 5 - Les tableaux statiques

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

---
# Programmation procédurale - CM5
## Inès de Courchelle
## Les tableaux statiques

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

---
layout: false
# Rappel
## Compilation séparée
#### Fonctions.h fonctions.c

.pull-left[

```c
#ifndef __FONCTIONS_H
#define __FONCTIONS_H
/* signatures/prototypes des fonctions */
int add (int a, int b);
int sous (int a, int b);
#endif
```
]
.pull-right[

```c
#include "fonctions.h"
int add (int a, int b){
    return a+b;
}
int sous (int a, int b){
   return a-b;
}
```
]

<br>

#### main.c
```c
#include <stdio.h>
#include "fonctions.h"

int main(int argc, int* argv) {
    int resultat1;
    int resultat2;
    resultat1=sous(4,4);
    resultat2=add(4,4);
    return 0;
}
```

---
# Rappel
## makefile
Nous considérons l'arborescence de fichiers suivante :
<img src="../cm4/img/makefileex.svg"  width=250/>

## Le script
```shell
exe: fonctions.o main.o
	gcc fonctions.o main.o -o exe

fonctions.o: fonctions.c fonctions.h
	gcc -c -Wall fonctions.c  -o fonctions.o

main.o: main.c fonctions.h
	gcc -c -Wall main.c -o main.o
```
---
# Aujourd'hui
## Objectifs
- Faire attention a la gestion de la taille du tableau la taille du tableau est fixe.
- Connaître la façon dont sont stockées des valeurs du tableau. Elles sont stockées les unes à la suite des autres dans la mémoire. Attention à ne pas accéder à une case mémoire hors du tableau !
- Utiliser un tableau en paramètre de fonctions/procédures
- Détecter la fin d'une chaîne de caractères

---
# Today
## Plan
1. Définition d'un tableau 1D
2. Mise en garde dans les tableau 1D
3. Les tableaux 1D dans les fonctions/procédures
4. La gestion des chaînes de caractères en C
5. Les tableaux 2D

---
# Today
## Plan
1. .under[Définition d'un tableau 1D]
2. Mise en garde dans les tableau 1D
3. Les tableaux 1D dans les fonctions/procédures
4. La gestion des chaînes de caractères en C
5. Les tableaux 2D

---
# Tableau 1D
## Définition
C'est une structure de données qui permet de stocker plusieurs valeurs du même type (nombres, caractères, chaînes, etc.) dans une seule variable, accessibles grâce à un indice ou index.

## Objectif
Il sert à regrouper des données liées, comme les notes d’un élève, les jours d’une semaine, ...

---
# Tableau 1D
## Définition
#### Taille
La taille d’un tableau correspond au nombre total d’éléments qu’il contient.
#### Index
L'index (ou indice) est le numéro de position d’un élément dans le tableau. Il commence à 0.
#### Nom
Le tableau est une variable, donc il a un nom

---
# Tableau 1D
## Représentation
<img src="img/templateTableau.svg" width=700>

---
# Tableau 1D
## Représentation
<img src="img/explicationTableau.svg" width=700>

---
# Tableau 1D
## En C
#### Déclaration
```c
int monTab[100];
```
.underR[Attention] 100 est la taille MAXIMALE de case que peut contenir le tableau

#### Affectation
.pull-left[
```c
monTab[0]=42;
monTab[1]=24;
monTab[2]=8;
monTab[3]=25;
monTab[4]=12;
monTab[5]=37;
monTab[6]=53;
monTab[7]=19;
```
]
.pull-right[
<img src="img/templateTableau.svg" width=400>
]

---
# Tableau 1D
## Affectation saisie
.pull-left[
#### En algo
```c
POUR i allant de 0 à taille FAIRE
    ECRIRE("entrez une valeur ")
    LIRE(monTab[i])
FIN POUR
```
]

.pull-right[
#### En C
```c
for (int i=0;i<taille;i++){
    printf("entrez une valeur : \n");
    scanf("%d",&monTab[i]);
}
```
]

---
# Tableau 1D
## Affectation aléatoire

#### En Algo
```c
POUR i allant de 0 à longueur(monTab) FAIRE
    monTab[i] ← ALEATOIRE(0,100)
FIN POUR
```

#### En C
```c
for (int i=0;i<taille;i++){
    monTab[i] = rand() % 100;
}
```

---
# Rappel Aleatoire
## En C
#### Etape 1
Il faut initialiser la "GRAINE" et le faire UNE SEULE ET UNIQUE FOIS dans le programme principal.
L'instruction est la suivante : *srand(time(NULL));* Si on ne met pas cette instruction, une fois, alors le nombre aléatoire généré sera toujours le même.
```c
int main(){
    srand(time(NULL));
    return 0;
}
```
#### Etape 2
À chaque fois que l'on veut générer un nombre aléatoire
```c
int a = rand() % 5; /*génération d'un entier aléatoire entre 0 et 5 */
double b = (rand()/(double)  RAND_MAX * 2.0 - 1.0); /* génération d'un réél aléatoire entre -1.0 et 1.0*/
float c = ((float) rand() / RAND_MAX) * 5.0; /* génération d'un réél aléatoire entre 0.0 et 5.0*/
```
**RAND MAX** représente la valeur maximale que la fonction rand() peut retourner

---
# Rappel Aleatoire
## En C
<center>
<video src="videos/aleatoire.mp4" height="300" width="300"  controls poster="vignette.jpg"> </video>
</center>

---
# Tableau 1D
## Affichage
<img src="img/templateTableau.svg" width=800>
#### Comment faire pour afficher 37 ?

**En algo**
```c
ECRIRE("la valeur à la case 2 est "+ monTab[2])
```

**En C**
```c
printf("la valeur à la case 2 est %d ", monTab[2]);
```

---
# Tableau 1D
## Le parcours
#### En algo
```c
POUR i allant de 0 à longueur(monTab) FAIRE
    ECRIRE("| " + monTab[i])
FIN POUR
```

#### En C
```c
for (int i=0; i< taille;i++){
    printf("| %d ",monTab[i]);
}
```

---
# Tableau 1D
## En C

---
# Today
## Plan
1. Définition d'un tableau 1D
2. .under[Mise en garde dans les tableau 1D]
3. Les tableaux 1D dans les fonctions/procédures
4. La gestion des chaînes de caractères en C
5. Les tableaux 2D

---
# Tableau 1D
## Mise en garde
- Si on déclare un tableau de taille N, alors on ne peut utiliser les indices : [0;N-1]
- Si on utilise un indice incorrect alors on essaye d’accéder à une partie de la mémoire qui n'est pas comprise dans le tableau.

## Exemple
On considère le tableau suivant :

---
# Tableau 1D
## Mise en garde
<img src="img/exempleTableau2camarchepo.png" width=500>

La case tab[5] n'existe pas !

---
# Tableau 1D
## Mise en garde

---
# Tableau 1D
## Mise en garde
#### Dans la mémoire
<img src="img/memoryStore.png" width=400>

---
# Today
## Plan
1. Définition d'un tableau 1D
2. Mise en garde dans les tableau 1D
3. .under[Les tableaux 1D dans les fonctions/procédures]
4. La gestion des chaînes de caractères en C
5. Les tableaux 2D

---
# Tableau 1D
## Dans les fonctions/Procèdures
On considère le tableau suivant :
<img src="img/exempleTableau.png" width=300>

On considère la procédure suivante :
```c
void echange(int i, int j, int monTab[100]){
    int temp;
    temp=monTab[i];
    monTab[i]=monTab[j];
    monTab[j]=temp;
}
```
---
# Tableau 1D
## Dans les fonctions/Procèdures
```c
#include <stdio.h>
#include <stdlib.h>
int main(){
	int monTab[5]={22,12,6,4,42};
    echange(0,1,monTab);
    return 0;
}
```

#### À la fin du programme à quoi ressemblera le tableau ?
**Réponse a** Le tableau a été changé dans la procédure échange mais à cause de la visibilité des variables, il ne change pas dans le programme principal !

**Réponse b** Le tableau a été changé dans la procédure échange et aussi dans le programme principal !

---
# Tableau 1D
## Dans les fonctions/Procèdures
#### La réponse b !
Le tableau a été changé dans la procédure échange et aussi dans le programme principal !

#### VAR
<center>
<video src="videos/fonctionsProcedure.mp4" height="300" width="300"  controls poster="vignette.jpg"> </video>
</center>

---
# Today
## Plan
1. Définition d'un tableau 1D
2. Mise en garde dans les tableau 1D
3. Les tableaux 1D dans les fonctions/procédures
4. .under[La gestion des chaînes de caractères en C]
5. Les tableaux 2D

---
# Les chaînes de caractères
## Définition
- C'est un tableau de caractères se terminant par un marqueur de fin de chaı̂ne : ’\0’
- Une case = un caractère

## Exemple
<img src="img/tableauCarExemple.png" width=500>

---
# Les chaînes de caractères
## Déclaration
```c
char nom[20];
```
## Affectation
```c
char nom[20]="alexia";
```

## Affichage
```c
printf("%s \n",nom);
```

---
# Les chaînes de caractères
## Exemple
```c
#include <stdio.h>
#include <stdlib.h>

int main(){
  char nom[100]="alexia";
  int taille = sizeof(nom) / sizeof(nom);
  int i;
  for (int i=0; i< taille;i ++){
    printf("%c ",nom[i]);
  }
  return 0;
}

```

.underR[ça ne marche pas]

---
# Les chaînes de caractères
## Exemple
.pull-left[
```c
#include <stdio.h>
#include <stdlib.h>

int main(){
  char nom[100]="alexia";
  int i;
  i=0;
  while(nom[i]!='\0'){
    printf("%c ",nom[i]);
    i++;
  }
  return 0;
}
```
]
.pull-right[
<img src="img/tabCaracteres.png" width=400>
]

---
# Les chaînes de caractères
## ça marche !

---
# Les chaînes de caractères
## La biblio string.h

| Fonction            | Rôle                                           |
| ------------------- | ---------------------------------------------- |
| `strlen(s)`         | Calcule la longueur de la chaîne (sans `'\0'`) |
| `strcpy(dest, src)` | Copie une chaîne dans une autre                |
| `strcat(dest, src)` | Concatène deux chaînes                         |
| `strcmp(s1, s2)`    | Compare deux chaînes                           |
| `strchr(s, c)`      | Cherche un caractère dans une chaîne           |
| `strstr(s, t)`      | Cherche une sous-chaîne                        |

---
# Today
## Plan
1. Définition d'un tableau 1D
2. Mise en garde dans les tableau 1D
3. Les tableaux 1D dans les fonctions/procédures
4. La gestion des chaînes de caractères en C
5. .under[Les tableaux 2D]

---
# Tableau 2D
## Définitions
#### Taille
- Nombre de ligne
- Nombre de colonne

#### Index
- L'index (ou indice) est le numéro de position d’un élément dans le tableau. Il commence à 0.
- On utilise 2 index pour parcourir un tableau 2D. Un pour les lignes et un pour les colonnes.

#### Nom
Le tableau est une variable, donc il a un nom.

---
# Tableau 2D
## Représentations
<img src="img/matriceD2.png" width=500>

---
# Tableau 2D
## En C
#### Déclaration
```c
int monTab2D[100][50];
```
#### Affectation
```c
monTab2D[0][1]= 4;
```
#### Parcours
```c
for (int i=0; i<nbLignes; i++){
    for (int j=0; j<nbLignes;j++){
        printf("| %d ",monTab[i][j]);
    }
}
```
---
# Astuce
## Déclaration de la taille
<center>
<video src="videos/fonctionsDefine.mp4" height="300" width="300"  controls poster="vignette.jpg"> </video>
</center>

---
# Bilan
## Objectifs
- Faire attention a la gestion de la taille du tableau la taille du tableau est fixe.
- Connaître la façon dont sont stockées des valeurs du tableau. Elles sont stockées les unes à la suite des autres dans la mémoire. Attention à ne pas accéder à une case mémoire hors du tableau !
- Utiliser un tableau en paramètre de fonctions/procédures
- Détecter la fin d'une chaîne de caractères