diff --git a/Exercices/Programmes/prog-1.rst b/Exercices/Programmes/prog-1.rst
index e52ebf0e4aa4cf64880640664a544980dd268faf..74b69963c2a05eff9053d160ff257df6f5e1de1f 100644
--- a/Exercices/Programmes/prog-1.rst
+++ b/Exercices/Programmes/prog-1.rst
@@ -77,8 +77,6 @@ que vous aviez réalisé en Java.
.. code-block:: c
- #include <stdio.h>
-
int f()
{
int a = 1252;
diff --git a/Exercices/Programmes/prog-4.rst b/Exercices/Programmes/prog-4.rst
index 973d5526ccb2ac1ccd79321f92ffa54079b55056..0193b5d0a3470c4e132d2cf7379fc24abe3dedff 100644
--- a/Exercices/Programmes/prog-4.rst
+++ b/Exercices/Programmes/prog-4.rst
@@ -18,11 +18,11 @@ Lorsque l'on écrit des programmes en C ou dans un autre langage, il est importa
le bon fonctionnement de toutes les fonctions du programme pour éviter des erreurs et autres
bugs difficiles à corriger. L'idéal est de commencer par écrire les tests qui valident le bon
fonctionnement de chaque fonction *avant* d'écrire cette fonction. Plusieurs librairies peuvent vous
-aider à écrire de tels tests. CUnit (:ref:`outils:ref_cunit`) est l'un d'entre elles.
+aider à écrire de tels tests. CUnit (:ref:`outils:ref_cunit`) est l'une d'entre elles.
Prenez le temps de lire le chapitre
qui lui est consacré dans le syllabus.
-Pour démontrer votre bon utilisation de `make(1)`_ et CUnit, reprenez le programme que vous
+Pour démontrer votre bonne utilisation de `make(1)`_ et CUnit, reprenez le programme que vous
avez écrit pour l'exercice `test <https://inginious.info.ucl.ac.be/course/LEPL1503/commandetest>`_
,
divisez-le en plusieurs fichiers, ajoutez-y des tests unitaires pour chaque fonction et
diff --git a/Exercices/Programmes/prog-5.rst b/Exercices/Programmes/prog-5.rst
index 9714f859c434868739687e08db7d2a72500bceef..328149e2a70eff9e52a3905da0eb0ad16982259d 100644
--- a/Exercices/Programmes/prog-5.rst
+++ b/Exercices/Programmes/prog-5.rst
@@ -7,17 +7,14 @@ Exercices INGINIOUS
Les exercices INGINIOUS de cette semaine ont comme objectif de vous familiariser avec la manipulation des fichiers contenant des données binaires.
-#. Le `premier exercice <https://inginious.info.ucl.ac.be/course/LEPL1503/s5_file_exists>`_ est
-une mise en jambe. En utilisant `open(2)`_ (et `close(2)`_), pouvez-vous vérifier si un
-fichier dont le nom est passé en argument existe ? Voir https://inginious.info.ucl.ac.be/course/LEPL1503/s5_file_exists
+#. Le `premier exercice <https://inginious.info.ucl.ac.be/course/LEPL1503/s5_file_exists>`_ est une mise en jambe. En utilisant `open(2)`_ (et `close(2)`_), pouvez-vous vérifier si un fichier dont le nom est passé en argument existe ? Voir https://inginious.info.ucl.ac.be/course/LEPL1503/s5_file_exists
#. Parfois, il est utile de pouvoir stocker une structure directement dans un fichier. Utilisez `mmap(2)`_ pour cela dans l'exercice https://inginious.info.ucl.ac.be/course/LEPL1503/s5_file_save_struct
#. Un fichier binaire peut être utilisé pour stocker tous les éléments d'un tableau d'entiers. Ecrivez la `fonction sum_file <https://inginious.info.ucl.ac.be/course/LEPL1503/s5_read_file_array_integer>`_ qui prend comme argument un nom de fichier contenant un tel tableau et calcule la somme de tous les entiers stockés dans le fichier. Pensez aux cas d'erreurs possibles si le fichier n'a pas la bonne taille. Voir https://inginious.info.ucl.ac.be/course/LEPL1503/s5_read_file_array_integer
-#. Vous continuez à explorer les fichiers binaires qui permettent de stocker tous les éléments d'un tableau d'entiers. Cette fois-ci vous devez écrire une `première fonction <https://inginious.info.ucl.ac.be/course/LEPL1503/s5_big_array_get_set>`_ pour récupérer la valeur d'un
-élément du tableau stocké dans le fichier et une `seconde fonction <https://inginious.info.ucl.ac.be/course/LEPL1503/s5_big_array_get_set>`_ pour modifier la valeur d'un élément de ce tableau. Voir https://inginious.info.ucl.ac.be/course/LEPL1503/s5_big_array_get_set
+#. Vous continuez à explorer les fichiers binaires qui permettent de stocker tous les éléments d'un tableau d'entiers. Cette fois-ci vous devez écrire une `première fonction <https://inginious.info.ucl.ac.be/course/LEPL1503/s5_big_array_get_set>`_ pour récupérer la valeur d'un élément du tableau stocké dans le fichier et une `seconde fonction <https://inginious.info.ucl.ac.be/course/LEPL1503/s5_big_array_get_set>`_ pour modifier la valeur d'un élément de ce tableau. Voir https://inginious.info.ucl.ac.be/course/LEPL1503/s5_big_array_get_set
#. En ligne de commande, `cp(1)`_ vous permet de copier complètement un fichier quel que soit son contenu. Pouvez-vous implémenter l'équivalent de cette commande dans la `fonction copy <https://inginious.info.ucl.ac.be/course/LEPL1503/s5_file_copy>`_ que vous allez écrire en C. Voir https://inginious.info.ucl.ac.be/course/LEPL1503/s5_file_copy
diff --git a/Exercices/mcq-ex/qcm-2.rst b/Exercices/mcq-ex/qcm-2.rst
index 2d646af251fc3c9bb2d60e97e44dcd2f5aeba5d5..406873bd030e5ba108fc13ec1109dfaaa7268fad 100644
--- a/Exercices/mcq-ex/qcm-2.rst
+++ b/Exercices/mcq-ex/qcm-2.rst
@@ -26,6 +26,8 @@ En C tout comme dans des langages comme Java, il est possible de convertir des n
// unsigned short 2 octet(s)
// int 4 octet(s)
// unsigned int 4 octet(s)
+ // long 4 octet(s)
+ // unsigned long 4 octet(s)
int i;
@@ -486,7 +488,7 @@ Question 8. Chaînes de caractères
int count1(char *s, char c) {
int i=0;
int count=0;
- while(*s!=`\0`) {
+ while(*s!='\0') {
if(*(s+i)==c) {
count++;
}
diff --git a/Exercices/mcq-ex/qcm-3.rst b/Exercices/mcq-ex/qcm-3.rst
index 111276317eef56e4c1c6c266c17d51a956b828b0..5d7ae8070159b89bc7567b70d2f9b869f8921860 100644
--- a/Exercices/mcq-ex/qcm-3.rst
+++ b/Exercices/mcq-ex/qcm-3.rst
@@ -231,14 +231,14 @@ Considérons le fragment de programme ci-dessous.
Question 4. Initialisation des variables
----------------------------------------
-En C, une règle de bonne pratique est d'initialiser toutes les variables avant leur utilisation. Utiliser une variable qui n'a pas été correctement initialisée pour être une source de problèmes. Un étudiant a écrit les déclarations ci-dessous :
+En C, une règle de bonne pratique est d'initialiser toutes les variables avant leur utilisation. Utiliser une variable qui n'a pas été correctement initialisée peut être une source de problèmes. Un étudiant a écrit les déclarations ci-dessous :
.. code-block:: c
int k=0;
int i;
short j;
- float f;
+ float f=0.0;
double d;
char c[10];
char* string;
@@ -255,57 +255,59 @@ En C, une règle de bonne pratique est d'initialiser toutes les variables avant
.. positive::
- - la variable ``i`` est initialisée à la valeur ``0``
- - le pointeur ``string`` est initialisé à la valeur ``NULL``
- - ``c[2]`` contient le caractère ``'\0'``
- - Après exécution de ``malloc``, le contenu de l'adresse ``ptr+1`` est indéterminé
+ - la variable ``k`` est initialisée à la valeur ``0``
+ - la variable ``f`` est initialisé à la valeur ``0``
+ - la variable ``ptr`` est stockée sur la pile
+ - Après exécution de ``malloc``, le contenu de l'adresse ``ptr+1`` est indéterminé
.. comment:: Pour des raisons d'efficacité, `malloc(3)`_ n'initialise pas à zéro les zones mémoires allouées, contrairement à `calloc(3)`_
.. positive::
- - la variable ``j`` est initialisée à la valeur ``0``
- - le pointeur ``v`` est initialisé à la valeur ``NULL``
- - ``c[4]`` contient le caractère ``'\0'``
- - Après exécution de ``malloc``, le contenu de l'adresse ``ptr+4`` est indéterminé
+ - la variable ``d`` contient une valeur indéterminée
+ - le pointeur ``v`` contient une valeur indéterminée
+ - ``c[9]`` va faire un accès mémoire sur la pile
+ - Après une exécution réussie de ``malloc``, le contenu de ``ptr`` est une adresse sur le tas
- .. comment:: Pour des raisons d'efficacité, `malloc(3)`_ n'initialise pas à zéro les zones mémoires allouées, contrairement à `calloc(3)`_
+ .. comment:: Le contenu de ``c`` est stocké sur la pile
.. negative::
- - la variable ``f`` est initialisée à la valeur ``0.0``
- - le pointeur ``string`` n'a aucune valeur et n'est pas utilisable
+ - la variable ``f`` est initialisée à la valeur ``0.0``
+ - le pointeur ``string`` n'est pas utilisable
- ``c[2]`` contient le caractère espace
- Après exécution de ``malloc``, l'adresse ``ptr+1`` contient le caractère ``'\0'``
- .. comment:: `malloc(3)`_ n'initialise pas la zone mémoire allouée. ``string`` contient ``NULL`` et ``c[2]`` le caractère ``'\0'``
+ .. comment:: `malloc(3)`_ n'initialise pas la zone mémoire allouée. Le contenu de ``c`` est indéfini
.. negative::
- la variable ``f`` est initialisée à la valeur ``0.0``
- le pointeur ``v`` n'a aucune valeur et n'est pas utilisable
- - ``c[2]`` contient le caractère espace
+ - ``c[2]`` contient le caractère ``'\0'``
- Après exécution de ``malloc``, l'adresse ``ptr`` contient le caractère ``'\0'``
+ .. comment:: `malloc(3)`_ n'initialise pas la zone mémoire allouée. Le contenu de ``c`` est indéfini
+
.. negative::
- la variable ``f`` est initialisée à la valeur ``0.0``
- - le pointeur ``string`` est initialisé à ``NULL``
- - ``c[10]`` contient le caractère espace
- - Après exécution de ``malloc``, l'adresse ``ptr+3`` contient le caractère ``'\0'``
+ - la variable ``j`` contient une valeur indéterminée
+ - le pointeur ``string`` contient une valuer indéterminée
+ - Après une exécution réussie de ``malloc``, le contenu de ``ptr`` est une adresse sur la pile
- .. comment:: ``c[10]`` est hors du tableau ``c``. `malloc(3)`_ n'initialise pas la zone mémoire allouée.
+ .. comment:: `malloc(3)`_ n'initialise pas de zone mémoire sur la pile.
.. negative::
- la variable ``f`` est initialisée à la valeur ``0.0``
- - le pointeur ``v`` est initialisé à ``NULL``
- - ``c[6]`` contient le caractère ``'\0'``
+ - la variable ``i`` contient une valeur indéterminée
+ - la variable ``d`` contient une valeur indéterminée
- Après exécution de ``malloc``, l'adresse ``ptr+5`` contient le caractère ``'\0'``
.. comment:: `malloc(3)`_ n'initialise pas la zone mémoire allouée. De plus, ``ptr+5`` se trouve en dehors de la zone mémoire allouée par `malloc(3)`_
diff --git a/Exercices/mcq-ex/qcm-6.rst b/Exercices/mcq-ex/qcm-6.rst
index 9fd2f623b30d7d639afce3a651def5b259ee3090..747550f42ee5bd52402e046dc2183e6fafcce66e 100644
--- a/Exercices/mcq-ex/qcm-6.rst
+++ b/Exercices/mcq-ex/qcm-6.rst
@@ -530,7 +530,7 @@ Dans certains programmes, il est nécessaire de définir plusieurs mutex qui son
.. negative::
- .. code-block:: none
+ .. code-block:: c
// thread A
@@ -542,7 +542,7 @@ Dans certains programmes, il est nécessaire de définir plusieurs mutex qui son
update(&b,&c,&y,&z);
update(&c,&a,&z,&x);
- .. comment:: Lorsqu'un thread utilise plusieurs ressources protégées par un mutex, il est important que les accès à ces mutex se fasse chaque fois dans le même ordre. Dans cet exemple, il faut toujours accéder à ``x`` puis à ``y`` puis à ``z`` (ou un autre ordre). Accéder à ``z`` puis à ``x`` dans le thread B et à ``x`` puis à ``z`` dans le thread A est une source de deadlocks potentiels.
+ .. comment:: Lorsqu'un thread utilise plusieurs ressources protégées par un mutex, il est important que les accès à ces mutex se fasse chaque fois dans le même ordre. Dans cet exemple, il faut toujours accéder à ``x`` puis à ``y`` puis à ``z`` (ou un autre ordre). Accéder à ``z`` puis à ``x`` dans le thread B et à ``x`` puis à ``z`` dans le thread A est une source de deadlocks potentiels.
.. negative::
diff --git a/Outils/gcc.rst b/Outils/gcc.rst
index 511a8084aa2dcbcecb28acce9895fc0161615f16..891aca7024327a27b76f900a1732ab306a43b161 100644
--- a/Outils/gcc.rst
+++ b/Outils/gcc.rst
@@ -2,7 +2,7 @@
.. Copyright |copy| 2012 by `Olivier Bonaventure <http://inl.info.ucl.ac.be/obo>`_ et Nicolas Houtain
.. Ce fichier est distribué sous une licence `creative commons <http://creativecommons.org/licenses/by-sa/3.0/>`_
-
+.. _gcc:
GCC
---