Skip to content
Extraits de code Groupes Projets
Non vérifiée Valider 4df545fc rédigé par Olivier Bonaventure's avatar Olivier Bonaventure Validation de GitHub
Parcourir les fichiers

Merge pull request #7 from qdeconinck/exo_s2

Relecture de la section Exercices
parents 49a76e6a eb259f1f
Aucune branche associée trouvée
Aucune étiquette associée trouvée
Aucune requête de fusion associée trouvée
......@@ -77,8 +77,6 @@ que vous aviez réalisé en Java.
.. code-block:: c
#include <stdio.h>
int f()
{
int a = 1252;
......
......@@ -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
......
......@@ -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
......
......@@ -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++;
}
......
......@@ -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)`_
......
......@@ -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::
......
......@@ -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
---
......
0% Chargement en cours ou .
You are about to add 0 people to the discussion. Proceed with caution.
Terminez d'abord l'édition de ce message.
Veuillez vous inscrire ou vous pour commenter