Skip to content
Snippets Groups Projects
Verified Commit ece6d944 authored by orestis.malaspin's avatar orestis.malaspin
Browse files

Merge branch 'master' of ssh://ssh.hesge.ch:10572/programmation_sequentielle/cours

parents 92ed4d4e 294c558a
Branches
No related tags found
No related merge requests found
Pipeline #38676 passed
Stage: test
Hide whitespace changes
Inline Side-by-side
exemples/alot_of_scanfs.c deleted 100644 → 0
+ 0
− 103
View file @ 92ed4d4e
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Ce programme prend en argument deux
// entiers se trouvant chacun
// sur une nouvelle ligne et affiche
// la somme des deux entiers en argument
// sur une nouvelle ligne.
// Ex:
// 12
// 19
//
// 31
void sum_two() {
int a, b;
scanf("%d %d", &a, &b);
printf("\n%d\n", a + b);
}
// Ce programme prend en argument 12 nombres à
// virgule flottante se trouvant chacun
// sur une nouvelle ligne. Multiplie chaque
// nombre par deux et affiche leur somme
// sur une nouvelle ligne suivi de CHF.
// Ex:
// 12.2
// 45.5
// 1.5
// 65.1
// 89.4
// 567.6
// 112.8
// 67.0
// 35.1
// 112.2
// 3.3
// 9.8
//
// 2243.000000 CHF
void sum_array() {
float sum = 0.0;
for (int i = 0; i < 12; ++i) {
float a = 0.0;
scanf("%f", &a);
a *= 2.0;
sum += a;
}
printf("\n%f CHF\n", sum);
}
// Ce programme prend en argument 2 chaînes de
// caractères sur des lignes séparées (longueur
// max de 80), les sépare au milieu et retourne
// les 4 chaînes chacune sur une nouvelle ligne
// (si la longueur N est paire on sépare en 2
// chaînes de longueur N/2, sinon la première
// aura une longueur de N/2 et la seconde N/2+1).
// Ex:
// abcdefgh
// asdfghjkl
//
// abcd
// efgh
// asdf
// ghjkl
void split_mid() {
char str_one[2][41], str_two[2][41];
for (int j = 0; j < 2; ++j) {
char str[81];
scanf("%s", str);
int n = strlen(str);
int n1 = n / 2;
int n2 = n - n1;
for (int i = 0; i < n1; ++i) {
str_one[j][i] = str[i];
}
str_one[j][n1] = '\0';
for (int i = 0; i < n2; ++i) {
str_two[j][i] = str[n1 + i];
}
str_two[j][n2] = '\0';
}
printf("\n");
for (int j = 0; j < 2; ++j) {
printf("%s\n", str_one[j]);
printf("%s\n", str_two[j]);
}
}
int main() {
/* sum_two(); */
sum_array();
/* split_mid(); */
}
exemples/sum_n.c deleted 100644 → 0
+ 0
− 22
View file @ 92ed4d4e
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("Enter n: "); // affichage chaine de caractères
int n = 0; // déclaration et initialisation de n
scanf("%d", &n); // entrée au clavier
int sum = 0; // déclaration et initialisation de sum
for (int i = 0; i <= n; ++i) { // boucle for
sum += i;
}
printf("The sum of the %d first integers is: %d\n", n, sum); // affichage de n et sum
printf("The analytical formula is %d * (%d + 1) / 2 = %d.\n", n, n, n*(n+1)/2); // on peut mettre n'importe quelle expression
if (sum != n * (n+1) / 2) { // branchement conditionnel
printf("Error: The answer we computed is wrong.\n");
return EXIT_FAILURE; // code d'erreur
}
return EXIT_SUCCESS; // code de réussite
}
\ No newline at end of file
slides/les_exos_avec_le_dojo.md
+ 3
− 1
View file @ ece6d944
---
title: "Dojo"
date: "2024-02-21"
date: "2025-02-21"
---
# Le Dojo
......@@ -77,6 +77,8 @@ $ dojo auth test
...
```
* Cette commande clone également le repo de l'exercice créé dans le répertoire courant
* Laissez l'opération se terminer
* Ne quittez **JAMAIS** le repo git sur `gitedu`
# Faire un exercice (2/3)
......
slides/opaque.md 0 → 100644
+ 153
− 0
View file @ ece6d944
---
title: "Types opaques"
date: "2025-02-28"
---
# Types composés
* Jusqu'ici les `struct` sont dans les `.h` et sont *transparents*
```C
// table.h
typedef struct _table {
int *data;
int length;
} table;
// main.c
table tab; // membres de tab accessibles directement
tab.length = 10;
tab.data = malloc(tab.length * sizeof(int));
tab.data[9] = 10;
```
# Types opaques
* Afin de cacher les détails de l'implémentation.
* Afin d'éviter les modifications directs des données.
* Afin de protéger le monde de la dévastation!
* Définition de types **opaques**:
* Variables dans les structures ne sont pas accessibles.
* Variables dans les structures ne sont pas modifiables.
* Les variables ne sont même pas connues.
* Nécessité de passer par des fonctions pour initialiser/modifier les instances
de types opaques.
* Très souvent utilisés pour les structures de données abstraites (table de
hachage, pile, file, ...).
# Utilisation d'un type opaque: problème?
* Dans `opaque.h`
```C
struct table;
```
* Dans `opaque.c`
```C
struct table {
int a;
}
```
* Dans `main.c`
```C
int main() {
struct table t;
}
// error: storage size of ‘t’ isn’t known
```
* La taille de `table` n'est pas connue à la compilation!
* Comment faire?
# Utilisation d'un type opaque: pointeur!
\footnotesize
* Dans `opaque.h`
```C
struct table;
struct table *create();
void init(struct table **t);
```
* Dans `opaque.c`
```C
struct table {
int a;
}
struct table *create() {
struct table *t = malloc(sizeof(*t));
return t;
}
void init(struct table **t) {
*t = malloc(sizeof(**t));
}
```
* Dans `main.c`
```C
int main() {
struct table *t = create();
init(&t);
t->a = 2; // Interdit, set(2)
printf("%d\n", t->a); // Interdit, get()
}
```
# Un peu plus joli: typedef! (1/2)
* Dans `opaque.h`
```C
struct _table;
typedef struct _table * table;
void init(table *t);
void set_a(table t, int a);
int get_a(table t);
```
* Dans `opaque.c`
```C
struct _table {
int a;
}
void init(table *t) {
*t = malloc(sizeof(**t));
(*t)->a = 0;
}
void set_a(table t, int a) {
t->a = a;
}
int get_a(table t) {
return t->a;
}
```
# Un peu plus joli: typedef! (2/2)
* Dans `main.c`
```C
int main() {
table t;
init(&t);
set_a(t, 10);
printf("%d\n", get_a(t));
}
```
* On a fait les fonctions `get_a()` et `set_a()` comme exemples, mais...
. . .
* c'est pas forcément nécessaire d'implémenter (`get/set`).
. . .
* Par exemple, pour la hashmap on `get/set` les variables des structs!
## Yaka
* Utiliser les types opaques pour la hashmap!
slides/pointeurs_avances.md 0 → 100644
+ 92
− 0
View file @ ece6d944
---
title: "Pointeurs avancés"
date: "2025-03-21"
---
# Pointeurs et `const`
\footnotesize
- Le mot-clé `const` permet de déclarer des valeurs **constantes** qui ne changeront plus en cours d'exécution du programme.
```C
const int a = 1;
a = 2; // interdit, erreur de compilation!
```
## Deux niveaux de constance
- Mais qu'est-ce que cela veut dire pour les pointeurs?
* Constance de la valeur de l'adresse? de la valeur pointée? des deux?
```C
int n = 12;
const int *p = &n; // la valeur *p est const, p non
int const *p = &n; // la valeur *p est const, p non
int *const p = &n; // la valeur p est const, *p non
const int *const p = &n; // la valeur p et *p sont const
```
# Pointeurs et `const`
## Exemples
```C
int n = 12; int m = 13;
const int *p = &n; // la valeur *p est const, p non
*p = m; // erreur de compilation.
p = &m; // OK
int const *p = &n; // la valeur *p est const, p non
*p = m; // erreur de compilation.
p = &m; // OK
int *const p = &n; // la valeur p est const, *p non
*p = m; // OK
p = &m; // erreur de compilation.
const int *const p = &n; // la valeur p et *p sont const
*p = m; // erreur de compilation.
p = &m; // erreur de compilation.
```
# Rappel: pointeurs et fonction
## Faites un dessin de ce qui se passe en mémoire
```C
void foo(int *a) {
*a = 3;
}
void bar(int a) {
a = 12;
}
int main() {
int a = 1;
foo(&a); // Que vaut a?
bar(a); // Que vaut a?
}
```
# Pointeurs et `const`
## Fonctions
```C
void foo(int *a);
void foo(const int *a); // on pourra pas changer *a
void foo(int *const a); // inutile on peut pas changer a
void foo(const int *const a); // identique à ci-dessus
```
## Mais.....
```C
const int a = 0;
int *b = (int *)&a;
*b = 7;
printf("a = %d\n", a); // affiche quoi?
```
# Utilité
* Permet d'empêcher une mauvaise utilisation des arguments,
* Permet de documenter le code: on sait que la variable ne sera pas modifiée.
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment