Le document traite du langage de programmation C, ses bases, et son histoire, notamment son développement par Dennis Ritchie. Il aborde des concepts d'allocation de mémoire, l'utilisation de pointeurs, de macros et de bibliothèques standard, ainsi que les normes POSIX. De plus, le texte fournit des exemples de code et souligne l'importance d'une gestion correcte de la mémoire pour éviter les fuites.

1. Systèmes
d'exploitation
Le Langage C
Allocation de mémoire

2. Pirates of Silicon Valley
2

3. Hidden Figures
3

4. Dennis Ritchie
• Américain
• Harvard University
• Auteur de langage C
• Co-auteur UNIX
4

5. Contenu
• Le langage C
• Le standard POSIX
• Allocation de mémoire
5

6. Bibliographie pour aujourd'hui
• Dan Gookin, C for Dummies (2nd Edition)
– Chapitre 6, 24, 27 et 29
• Peter D. Hipson, Advanced C
– Chapitre 2, 3, 7, 14 et 15
• Steve Summit, C Programming Notes
– Chapitre 6, 8, 9, 10 et 11
6

7. LANGAGE C
7

8. Langage C
• Ecrit par Denis Ritchie, 1972
• Bell Labs
• A été écrit pour UNIX
• Portable
– Fonction sur presque toutes SE
• Macro Assembleur
• Fichiers .h et .c
• Diffèrent de C++
8

9. Standards C
• Original – K&R C
• Plus utilisé ANSI C (C89 ou C90)
• Plus stricte C99
– Plus de types des données
• Plus nouveau C11 et C18
• Embedded C
9

10. Bibliothèque C
• Libc
– fonctions qui sont disponible dans toutes les SE
• Pour un nouveau SE, c’est la premier
bibliothèque implémenté
• Exemple
– printf / scanf
– malloc / free
– fopen / fread
10

11. Compilateurs pour le langage C
• GNU Compiler Collection (gcc)
• Low Level Virtual Machine (llvm - clang)
• Microsoft Visual C++ (msvc)
• Intel C
11

12. La structure d’un program en C
// defines
#define VALUE 10000
...
// variables declaration
int main ()
{
// variables declaration
// statements (code)
return 0;
}
int f ()
{
// variables declaration
// statements (code)
}
12

13. POSIX
13

14. POSIX
• Standard
• Portable Operating System Interface
• POSIX – 1
– comprend ANSI C
• POSIX – 1b – Temps Réel
• POSIX – 1c - Fils d’exécutions
• POSIX -2 – Shell et outilles
14

15. SE conformes avec POSIX
15

16. MACRO
16

17. Macro Definition
#define SIZE 1000;
long vector[SIZE];
17

18. Macro après la Compilation
long vector[1000;];
18
Erreur

19. Macro Definition
#define SIZE 1000
long vector[SIZE];
19

20. Macro après la Compilation
long vector[1000];
20

21. Utilisation des Macros
• Utilisé pour définition de constants
• Paramétriez le programme
• Modifier les valeurs en un seul endroit
21

22. ALLOCATION DE MEMOIRE
22

23. Disposition de la mémoire
23

24. Pointeurs
24

25. La memoire en C
• Pointeurs
– nom, adresse, adresse référencée
• Valeur
– adresse de mémoire (numéro)
– NULL (numéro 0)
• Fonctions
– sizeof
– malloc
– calloc
– realloc
– free
25

26. Valeur NULL
• Valeur 0
#define NULL ((void*)0)
• Protection
– La adresse 0 n’est pas utilise
26

27. sizeof
operateur sizeof (data)
data – variable ou type de données
Renvoie le nombre d'octets occupés par data
27

28. sizeof
• sizeof (short) ?
– 2
• sizeof (char) ?
– 1
• sizeof (long) ?
– 4
• sizeof (int) ?
– 4 ou 8
• sizeof (long long) ?
– 8
• int f; sizeof (f) ?
– 4 ou 8
28

29. malloc
void *malloc (size_t size);
size - nombre de octets demandée
renvoie:
• Succès: pointeur vers la mémoriel allouée
• Erreur: NULL
La mémoire alloue n’a pas toujours la valeur 0
int *s = (int*)malloc (sizeof (int))
pourquoi pas sizeof (4)?
29

30. calloc
void *calloc (size_t count, size_t size);
count – nombre d'objets à allouer
size – taille en octets d'objets à allouer
renvoie:
• Succès: pointeur vers la mémoriel allouée
• Erreur: NULL
La mémoire alloue este avec la valeur 0
// one item
int *s = (int*)calloc (1, sizeof (int));
// array of items
int *v = (int*)calloc (100, sizeof (int));
30

31. realloc
void *realloc (void *ptr, size_t size);
ptr - pointeur précédemment alloue
size - nombre nouveau de octets demandée
renvoie:
• Succès: pointeur vers la nouveau mémoriel allouée
• Erreur: NULL
La mémoire nouveau alloue n’a pas toujours la valeur 0
// resize the s array
s = (int*)realloc (s, 100*sizeof(int));
31

32. free
void free (void *ptr);
ptr - pointeur à libérer
free (s); // s does not become
NULL
s = NULL; // important
ptr ne change pas sa valeur en NULL
32

33. Fuite de mémoire
Il n'y a aucun moyen de libérer un pointeur
int *p = (int*)malloc (sizeof(int));
…
p = NULL; // p is leaked
33
Valgrind
valgrind.org

34. malloc – vérifiez le retour
int *s = (int*) malloc (sizeof (int))
if (s != NULL)
{
…
}
else
{
perror ("malloc");
abort ();
}
34

35. Déréférencer un pointeur
int a = 510;
int *p = NULL;
p = &a; // &a - address of variable a
printf ("%dn", a); // prints 510
printf ("%dn", p); // prints the address
of a
printf ("%dn", *p); // prints 510 (the
value at the address of a)
35

36. Déréférencer un pointeur
int *a = NULL;
a = (int*)malloc (sizeof(int));
if (a != NULL)
{
*a = 510;
printf ("%dn", a); // prints ...?
printf ("%dn", *a); // prints ...?
free (a);
a = NULL;
}
else
{
perror ("malloc");
abort ();
}
36

37. Déréférencer un pointeur
int *a = NULL;
a = (int*)malloc (sizeof(int));
if (a != NULL)
{
*a = 510;
printf ("%dn", a); // prints the address of a
printf ("%dn", *a); // prints 510
free (a);
a = NULL;
}
else
{
perror ("malloc");
abort ();
}
37

38. STRINGS
38

39. String - C Style
s t r i n g 0 …
115 116 114 105 110 103 0 …
char s[N] N
39

40. Déclaration pour string
char s[100];
// use s
char *s = NULL;
s = (char*)malloc ( ... ? );
// use s
free (s);
s = NULL;
40

41. Déclaration pour string
char s[100];
// use s
char *s = NULL;
s = (char*)malloc (100*sizeof(char));
// use s
free (s);
s = NULL;
41

42. Déclaration pour string
char s[100];
// use s
char *s = NULL;
s = (char*)calloc (100, sizeof(char));
// use s
free (s);
s = NULL;
42

43. Allouer un string
text <- "SE subject"
char *text = NULL;
text = (char*) malloc (…)
strncpy (text, "SE subject", ...);
43

44. Allouer un string
text <- "SE subject"
char *text = NULL;
text = (char*) malloc (11*sizeof(char));
if (text != NULL) // important!!!
{
strcpy (s, "SE is important");
printf ("%sn", text);
}
else
{
perror ("malloc");
abort ();
}
44

45. Allouer un string
char *text = NULL;
text = (char*) malloc (11*sizeof(char));
if (text != NULL) // important!!!
{
strcpy (s, "SE is important");
printf ("%sn", text);
/// ...
free (text);
text = NULL;
}
else
{
perror ("malloc");
abort ();
}
45

46. Fonctions pour string (pas sécurisé)
// string duplicate
char *strdup(const char *s1);
// string compare
int strcmp(const char *s1, const char *s2);
// string copy
char *strcpy(char *dest, const char *src);
// string concatenate
char *strcat(char *dest, const char *src);
// string length
size_t strlen(const char *s1);
46

47. Fonctions pour string (sécurisée)
// string duplicate (max n bytes)
char *strndup(const char *s1, size_t n);
// string compare (max n bytes)
int strncmp(const char *s1, const char *s2, size_t n);
// string copy (max n bytes)
char *strncpy(char *dest, const char *src, size_t n);
// string concatenate (max n bytes)
char *strncat(char *dest, const char *src, size_t n);
// string length (max n bytes)
size_t strnlen(const char *s1, size_t n);
47

48. Copier un string
char s[100];
strncpy (s, "", 99); // s = "”;
char s1[100];
char s2[100];
strncpy (s1, s2, 99); // s1 = s2;
48

49. Concaténer des strings
char s[200];
char s2[100];
strncat (s, s2, 99); // s = s + s2;
char s[200];
char s1[100];
char s2[100];
strncpy (s, s1, 99); // s = s1;
strncat (s, s2, 99); // s = s + s2;
49

50. Comparer les strings
char s1[100];
char s2[100];
// if (s1 == s2)
if (strncmp (s1, s2, 99) == 0)
// if (s1 < s2)
if (strncmp (s1, s2, 99) < 0)
// if (s1 > s2)
if (strncmp (s1, s2, 99) > 0)
50

51. STRUCTURES
51

52. Definition
#define MAX_NAME
// Type
struct File
{
char name[MAX_NAME+1];
long size;
};
// Variable
struct File file1;
52

53. Accéder aux membres
struct File file1;
strncpy (file1.name, "sde.txt", MAX_NAME);
file1.size = 50;
53

54. Pointeur sur une structure
struct File *file1 = NULL;
file1 = (struct File*)malloc ( ... ?);
54

55. Pointeur sur une structure
struct File *file1 = NULL;
file1 = (struct File*)malloc (sizeof(struct File));
55

56. Accès membre structure
struct File *file1 = NULL;
file1 = (struct File*)malloc (sizeof(struct File));
// pointer to a struct of type File
file1
// value from the memory location pointed by the pointer
*file1
// error, a pointer is an address, has no member
file1.name
// the value pointed is a struct that as a member
name
(*file1).name
56

57. Accès membre structure
// the value pointed is a struct
that as a member name
(*file1).name
file1->name
57

58. Pointeur sur une structure
struct File *file1 = NULL;
file1 = (struct File*)malloc (sizeof(struct File));
if (file1 != NULL)
{
strncpy ((*file1).name, "sde.txt", MAX_NAME);
(*file1).size = 50;
/// ...
free (file1);
file1 = NULL;
}
else
{
perror ("malloc");
abort ();
}
58

59. Pointeur sur une structure
struct File *file1 = NULL;
file1 = (struct File*)malloc (sizeof(struct File));
if (file1 != NULL)
{
strncpy (file1->name, "sde.txt", MAX_NAME);
file1->size = 50;
/// ...
free (file1);
file1 = NULL;
}
else
{
perror ("malloc");
abort ();
}
59

60. TAMPON DE DONNÉES
60

61. Fonctions pour la memoire
// compare memory
int memcmp(const void *m1, const void *m2, size_t n);
// copy memory
void *memcpy(void *dest, void *src, size_t n);
// set value
void *memset(void *b, int c, size_t n);
61

62. Tampon des donees
#define BUFFER_SIZE 1024
char buffer[BUFFER_SIZE];
// ...
// or
void *buffer = (void*)malloc (BUFFER_SIZE);
// ...
free (buffer);
62

63. Tampon des donees avec 0
char buffer[BUFFER_SIZE];
memset (buffer, 0, BUFFER_SIZE);
// ...
// or
void *buffer = (void*)calloc (1, BUFFER_SIZE);
// ...
free (buffer);
63

64. Exemple
int main ()
{
void *temp_buffer = (void*)malloc (1024);
void *buffer = (void*)malloc (1024);
int f = open ("data.bin", O_RDONLY);
read (f, temp_buffer, 1024);
memcpy (buffer, temp_buffer, 1024);
close (f);
return 0;
}
64

65. Curseur tampon
// at location 0
memcpy (buffer, data, n);
memcpy (&buffer[0], data, n);
// at location p
memcpy (&buffer[p], data, n);
65

66. Exemple avec curseur
#define PARTS 10
#define BUFFER_SIZE 1024
int main ()
{
void *temp_buffer = (void*)malloc (BUFFER_SIZE);
void *buffer = (void*)malloc (BUFFER_SIZE * PARTS);
int f = open ("data.bin", O_RDONLY);
int part, position = 0, bytes;
for (part = 0; part < PARTS; part++)
{
bytes = read (f, temp_buffer, BUFFER_SIZE);
if (bytes > 0)
{
memcpy (&buffer[position], temp_buffer, bytes);
position = position + bytes;
}
}
close (f);
return 0;
}
66

67. Tampon des donees avec 0
• la mémoire allouée n'est pas définie sur 0
• les données dans la mémoire nouvellement
allouée sont aléatoires
• Fonctions
– calloc - clear allocate
– strncpy - copy empty string
– memset - memory set
67

68. Mot clés
• Langage C
• ANSI C
• C90
• Libc
• gcc
• llvm
• Visual C++
• POSIX
• Macro
• Pointeur
• NULL
• allocation
• désallocation
• c-string
• structure
• tampon de données
• access dans le tampon
• valeur de retour
68

69. Bibliographie pour aujourd'hui
• Dan Gookin, C for Dummies (2nd Edition)
– Chapitre 6, 24, 27 et 29
• Peter D. Hipson, Advanced C
– Chapitre 2, 3, 7, 14 et 15
• Steve Summit, C Programming Notes
– Chapitre 6, 8, 9, 10 et 11
69

70. Questions
70