Skip to content
Snippets Groups Projects
Unverified Commit 629ecdd7 authored by orestis.malaspin's avatar orestis.malaspin
Browse files

deplacements

parent 53138fb9
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
base_1.md
+ 2
− 128
View file @ 629ecdd7
......@@ -364,135 +364,9 @@ else
x = -1; // toujours évalué
```
<!-- # Structures de contrôle: `switch`{.C} .. `case`{.C} (1/2)
# Quiz: `if ... else`{.C}
```C
switch (expression) {
case constant-expression:
instructions;
break; // optionnel
case constant-expression:
instructions;
break; // optionnel
// ...
default:
instructions;
}
```
**Que se passe-t-il si `break`{C} est absent?**
# Structures de contrôle: `switch`{.C} .. `case`{.C} (2/2)
```C
int x = 0;
switch (x) {
case 0:
case 1:
printf("0 ou 1\n");
break;
case 2:
printf("2\n");
break;
default:
printf("autre\n");
}
``` -->
**Dangereux, mais c'est un moyen d'avoir un "ou" logique dans un case.**
# Quiz: `if ... else, switch ... case`{.C}
## [Quiz: `if ... else, switch ... case`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)
# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (1/4)
## La boucle `for`{.C}
```C
for (expression1; expression2; expression3) {
instructions;
}
```
## La boucle `while`{.C}
```C
while (expression) {
instructions;
}
```
## La boucle `do ... while`{.C}
```C
do {
instructions;
} while (expression);
```
# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (2/4)
## La boucle `for`{.C}
```C
int sum = 0; // syntaxe C99
for (int i = 0; i < 10; i++) {
sum += i;
}
for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
printf("C'est plus ésotérique.\n");
}
```
# Structures de contrôle: `for`{.C}, `while`{.C}, `do ... while`{.C} (3/4)
## La boucle `while`{.C}
```C
int sum = 0, i = 0;
while (i < 10) { // pas assuré·e·s de faire un tour
sum += i;
i += 1;
}
```
## La boucle `do ... while`{.C}
```C
int sum = 0, i = 0;
do { // assuré·e·s de faire un tour
sum += i;
i += 1;
} while (i < 10);
```
# Structures de contrôle: `continue`{.C}, `break`{.C} (4/4)
- `continue`{.C} saute à la prochaine itération d'une boucle.
```C
int i = 0;
while (i < 10) {
if (i == 3) {
continue;
}
printf("%d\n", i);
i += 1;
}
```
- `break`{.C} quitte le bloc itératif courant d'une boucle.
```C
for (int i = 0; i < 10; i++) {
if (i == 3) {
break;
}
printf("%d\n", i);
}
```
## [Quiz: `if ... else`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)
# Les variables (1/2)
......
base_2.md
+ 85
− 90
View file @ 629ecdd7
% Base II
% Inspirés des slides de F. Glück
% 25 septembre 2019
% 23 septembre 2020
# Représentation des variables en mémoire (1/N)
# Structures de contrôle: `switch`{.C} .. `case`{.C} (1/2)
## La mémoire
* La mémoire est:
- ... un ensemble de bits,
- ... accessible via des adresses,
+------+----------+----------+------+----------+------+------+
| bits | 00110101 | 10010000 | .... | 00110011 | .... | .... |
+======+==========+==========+======+==========+======+======+
| addr | 2000 | 2001 | .... | 4000 | .... | .... |
+------+----------+----------+------+----------+------+------+
- ... gérée par le système d'exploitation.
- ... séparée en deux parties: **la pile** et **le tas**.
```C
switch (expression) {
case constant-expression:
instructions;
break; // optionnel
case constant-expression:
instructions;
break; // optionnel
// ...
default:
instructions;
}
```
## Une variable
**Que se passe-t-il si `break`{C} est absent?**
* Une variable, `type a = valeur`{.C}, possède:
- un type (`char`{.C}, `int`{.C}, ...),
- un contenu (une séquence de bits qui encode `valeur`{.C}),
- une adresse mémoire (accessible via `&a`{.C}),
- une portée.
# Structures de contrôle: `switch`{.C} .. `case`{.C} (2/2)
```C
int x = 0;
switch (x) {
case 0:
case 1:
printf("0 ou 1\n");
break;
case 2:
printf("2\n");
break;
default:
printf("autre\n");
}
```
# Représentation des variables en mémoire (2/N)
**Dangereux, mais c'est un moyen d'avoir un "ou" logique dans un case.**
![Les variables en mémoire.](figs/memory.svg){#fig:memory width=100%}
# Quiz: `switch ... case`{.C}
# Les pointeurs (1/N)
## [Quiz: `switch ... case`{.C}](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1033916)
- Un pointeur est une adresse mémoire.
# Structures de contrôle: `for`{.C} (1/2)
```C
type *id;
```
- Pour interpréter le contenu de ce qu'il pointe, il doit être typé.
- Un pointeur n'est rien d'autre qu'un entier (64bit sur x86-64, soit 8 octets).
- Un pointeur peut être **déréférencé**: on accède à la valeur située à l'adresse mémoire sur laquelle il pointe.
## La boucle `for`{.C}
```C
char *c; // déclaration pointeur de char
*c = 'a'; // assign. 'a' à valeur pointée par c
c = 1000; // on modifie l'adresse pointée par c
char d = *c; // on lit la valeur pointée par c. UB!
```
```C
for (expression1; expression2; expression3) {
instructions;
}
```
- `NULL`{.C} (ou `0`{.C}) est la seule adresse **toujours** invalide.
## La boucle `for`{.C}
# Les pointeurs (2/N)
```C
int sum = 0; // syntaxe C99
for (int i = 0; i < 10; i++) {
sum += i;
}
![Les pointeurs, le déréférencement, et la mémoire.](figs/memory_deref.svg){#fig:memory width=100%}
for (int i = 0; i != 1; i = rand() % 4) { // ésotérique
printf("C'est plus ésotérique.\n");
}
```
# Les pointeurs (3/N)
# Structures de contrôle: `continue`{.C}, `break`{.C} (2/2)
- Permettent d'accéder à une valeur avec une indirection.
- `continue`{.C} saute à la prochaine itération d'une boucle.
```C
int a = 2;
int *b = &a;
*b = 7; // on met 7 dans la case pointée par b
// ici a == 7 aussi
a = -2; // ici *b == -2 aussi
int i = 0;
while (i < 10) {
if (i == 3) {
continue;
}
printf("%d\n", i);
i += 1;
}
```
- Permettent d'avoir plusieurs chemins d'accès à une valeur.
- Lire **et** écrire en même temps dans un bout de mémoire devient possible: **danger**.
# Quiz: Les pointeurs
## [Quiz: Les pointeurs](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1038526)
# La fonction `sizeof()` (1/N)
- La fonction `sizeof()`{.C} permet de connaître la taille en octets:
- d'une valeur,
- d'un type,
- d'une variable.
- Soit `int a = 2`{.C}, sur l'architecture x86_64 que vaut:
- `sizeof(a)`{.C}?
- `sizeof(&a)`{.C}?
- Soit `char b = 2`{.C},
- `sizeof(b)`{.C}?
- `sizeof(&b)`{.C}?
# La fonction `sizeof()` (2/N)
- Réponses:
- `sizeof(a) == 4`{.C}, `int`{.C} entier 32 bits.
- `sizeof(&a) == 8`{.C}, une adresse est de 64 bits.
- `sizeof(b) == 1`{.C}, `char`{.C} entier 8 bits.
- `sizeof(&b) == 8`{.C}, une adresse est de 64 bits.
- `break`{.C} quitte le bloc itératif courant d'une boucle.
```C
for (int i = 0; i < 10; i++) {
if (i == 3) {
break;
}
printf("%d\n", i);
}
```
# Les fonctions (1/N)
# Les fonctions (1/7)
- Les parties indépendantes d'un programme.
- Permettent de modulariser et compartimenter le code.
......@@ -112,7 +107,7 @@
}
```
# Les fonctions (2/N)
# Les fonctions (2/7)
## Exemple
......@@ -130,7 +125,7 @@ int main() {
}
```
# Les fonctions (3/N)
# Les fonctions (3/7)
- Il existe un type `void`{.C}, "sans type", en C.
- Il peut être utilisé pour signifier qu'une fonction ne retourne rien, ou qu'elle n'a pas d'arguments.
......@@ -148,7 +143,7 @@ int main() {
}
```
# Les fonctions (4/N)
# Les fonctions (4/7)
## Prototypes de fonctions
......@@ -167,7 +162,7 @@ int main() {
}
```
# Les fonctions (5/N)
# Les fonctions (5/7)
## Arguments de fonctions
......@@ -189,7 +184,7 @@ int main() {
}
```
# Les fonctions (6/N)
# Les fonctions (6/7)
## Arguments de fonctions: pointeurs
......@@ -198,7 +193,7 @@ int main() {
- Un **pointeur** vers une variable entière a le type, `int *x`{.C}.
- La syntaxe `*x`{.C} sert à **déréférencer** le pointeur (à accéder à la mémoire pointée).
# Les fonctions (7/N)
# Les fonctions (7/7)
## Exemple
......@@ -251,7 +246,7 @@ int main() {
}
``` -->
# La fonction `main()` (1/N)
# La fonction `main()` (1/2)
## Généralités
......@@ -262,7 +257,7 @@ int main() {
- La valeur de retour peut être lue par le shell qui a exécuté le programme.
- `EXIT_SUCCESS`{.C} et `EXIT_FAILURE`{.C} (de `stdlib.h`) sont des valeurs de retour **portables** de programmes C.
# La fonction `main()` (2/N)
# La fonction `main()` (2/2s)
## Exemple
......@@ -286,7 +281,7 @@ $ if [ $? -eq 0 ]; then echo "OK" ; else echo "ERROR"; fi
ERROR # si tout s'est mal passé
```
# Les tableaux (1/N)
# Les tableaux (1/6)
## Généralités
......@@ -301,7 +296,7 @@ ERROR # si tout s'est mal passé
- Le premier élément du tableau à l’index `0`{.C}!
- Lorsqu’un tableau est déclaré, la taille de celui-ci doit toujours être spécifiée, sauf s’il est initialisé lors de sa déclaration.
# Les tableaux (2/N)
# Les tableaux (2/6)
## Exemple
......@@ -360,7 +355,7 @@ int main(void) {
return 0;
}
``` -->
# Les tableaux (3/N)
# Les tableaux (3/6)
## Itérer sur les éléments d'un tableau
......@@ -382,7 +377,7 @@ do {
```
# Les tableaux (4/N)
# Les tableaux (4/6)
## Les tableaux comme argument
......@@ -405,7 +400,7 @@ do {
}
```
# Les tableaux (5/N)
# Les tableaux (5/6)
## Quels sont les bugs dans ce code?
......@@ -426,7 +421,7 @@ int main(void) {
}
```
# Les tableaux (6/N)
# Les tableaux (6/6)
## Quels sont les bugs dans ce code?
......
base_3.md
+ 94
− 0
View file @ 629ecdd7
......@@ -2,6 +2,100 @@
% Inspirés des slides de F. Glück
% 2 octobre 2019
# Représentation des variables en mémoire (1/N)
## La mémoire
* La mémoire est:
- ... un ensemble de bits,
- ... accessible via des adresses,
+------+----------+----------+------+----------+------+------+
| bits | 00110101 | 10010000 | .... | 00110011 | .... | .... |
+======+==========+==========+======+==========+======+======+
| addr | 2000 | 2001 | .... | 4000 | .... | .... |
+------+----------+----------+------+----------+------+------+
- ... gérée par le système d'exploitation.
- ... séparée en deux parties: **la pile** et **le tas**.
## Une variable
* Une variable, `type a = valeur`{.C}, possède:
- un type (`char`{.C}, `int`{.C}, ...),
- un contenu (une séquence de bits qui encode `valeur`{.C}),
- une adresse mémoire (accessible via `&a`{.C}),
- une portée.
# Représentation des variables en mémoire (2/N)
![Les variables en mémoire.](figs/memory.svg){#fig:memory width=100%}
# Les pointeurs (1/N)
- Un pointeur est une adresse mémoire.
```C
type *id;
```
- Pour interpréter le contenu de ce qu'il pointe, il doit être typé.
- Un pointeur n'est rien d'autre qu'un entier (64bit sur x86-64, soit 8 octets).
- Un pointeur peut être **déréférencé**: on accède à la valeur située à l'adresse mémoire sur laquelle il pointe.
```C
char *c; // déclaration pointeur de char
*c = 'a'; // assign. 'a' à valeur pointée par c
c = 1000; // on modifie l'adresse pointée par c
char d = *c; // on lit la valeur pointée par c. UB!
```
- `NULL`{.C} (ou `0`{.C}) est la seule adresse **toujours** invalide.
# Les pointeurs (2/N)
![Les pointeurs, le déréférencement, et la mémoire.](figs/memory_deref.svg){#fig:memory width=100%}
# Les pointeurs (3/N)
- Permettent d'accéder à une valeur avec une indirection.
```C
int a = 2;
int *b = &a;
*b = 7; // on met 7 dans la case pointée par b
// ici a == 7 aussi
a = -2; // ici *b == -2 aussi
```
- Permettent d'avoir plusieurs chemins d'accès à une valeur.
- Lire **et** écrire en même temps dans un bout de mémoire devient possible: **danger**.
# Quiz: Les pointeurs
## [Quiz: Les pointeurs](https://cyberlearn.hes-so.ch/mod/evoting/view.php?id=1038526)
# La fonction `sizeof()` (1/N)
- La fonction `sizeof()`{.C} permet de connaître la taille en octets:
- d'une valeur,
- d'un type,
- d'une variable.
- Soit `int a = 2`{.C}, sur l'architecture x86_64 que vaut:
- `sizeof(a)`{.C}?
- `sizeof(&a)`{.C}?
- Soit `char b = 2`{.C},
- `sizeof(b)`{.C}?
- `sizeof(&b)`{.C}?
# La fonction `sizeof()` (2/N)
- Réponses:
- `sizeof(a) == 4`{.C}, `int`{.C} entier 32 bits.
- `sizeof(&a) == 8`{.C}, une adresse est de 64 bits.
- `sizeof(b) == 1`{.C}, `char`{.C} entier 8 bits.
- `sizeof(&b) == 8`{.C}, une adresse est de 64 bits.
# Types complexes: `struct`{.C} (1/N)
## Généralités
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment