ENIB PRJ-C Training_2 - Entraînement à la seconde épreuve

{} Première variante

{} Structure Time

Votre réalisation sera composée des fichiers suivants :

un programme principal prog_training_02.c,
un module de programmation time_utils.h/time_utils.c.

Le programme exécutable résultant sera obtenu en utilisant ce fichier GNUmakefile✎

Contenu du fichier GNUmakefile

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# this GNU-makefile relies on the GCC toolchain
# nb: on Windows, the Mingw-w64 package provides the mingw32-make.exe command
#     ( see https://web.enib.fr/~harrouet/dev_tools/#windows.mingw )

#~~~~ control global settings ~~~~
# make opt=2 --> enable optimisation, then disable debug, but keep symbols
# make opt=1 --> enable optimisation, then disable debug
# make opt=0 --> disable optimisation, then enable debug
opt=0
# make clang=1 --> use clang/clang++, not gcc/g++
# make clang=0 --> use gcc/g++, not clang/clang++
clang=0
# make wasm=1 --> target webassembly rather than the native platform
# make wasm=0 --> target the native platform rather than webassembly
wasm=0

#~~~~ build library or programs ~~~~
# if LIB_TARGET is provided, this library will be built (with its
# platform-specific name), otherwise ${EXE_PREFIX}* programs will be built
LIB_TARGET=
EXE_PREFIX=prog

#~~~~ detect operating system ~~~~
ifneq (${OS},Windows_NT)
  ifneq (,${findstring Ubuntu,${shell lsb_release -i 2>/dev/null}})
    OS:=Ubuntu
  else ifneq (,${findstring Raspbian,${shell lsb_release -i 2>/dev/null}})
    # Standard distribution for Raspberry-Pi
    OS:=Raspbian
  else
    OS:=${strip ${shell uname -s}}
  endif
  ifneq (,${findstring Microsoft,${shell cat /proc/version 2>/dev/null}})
    # Windows-Subsystem-for-Linux
    OS:=${OS}_WSL
  endif
endif

#~~~~ adjust project-specific settings ~~~~
CPPFLAGS=
# CPPFLAGS+=-I header/path
LDFLAGS=-lm
# LDFLAGS+=-L library/path -Wl,-rpath,library/path -l library_name
CFLAGS=
CXXFLAGS=
BINFLAGS=
ifneq (,${findstring Windows_NT,${OS}})
  # nothing special for now
else
  ifneq (,${strip ${LIB_TARGET}})
    BINFLAGS+=-fPIC
  endif
  ifneq (,${findstring Darwin,${OS}})
    # nothing special for now
  else
    ifneq (,${findstring Ubuntu,${OS}})
      # sanitizer sometimes requires gold-linker on Ubuntu
      LDFLAGS+=-fuse-ld=gold
    else ifneq (,${findstring Raspbian,${OS}})
      # some warnings may appear when mixing g++-6 and g++-7 on Raspbian
      CXXFLAGS+=-Wno-psabi
    else
      # nothing special for now
    endif
  endif
endif

#~~~~ adjust platform-specific features (Posix/Windows/Emscripten...) ~~~~
ifneq (,${findstring Windows_NT,${OS}})
  LIB_PREFIX=
  LIB_SUFFIX=.dll
  EXE_SUFFIX=.exe
  SKIP_LINE=echo.
  REMOVE=del /q
else
  LIB_PREFIX=lib
  ifneq (,${findstring Darwin,${OS}})
    LIB_SUFFIX=.dylib
  else
    LIB_SUFFIX=.so
  endif
  EXE_SUFFIX=
  SKIP_LINE=echo
  REMOVE=rm -rf
endif
ifeq (${strip ${wasm}},1)
  LIB_PREFIX:=lib
  LIB_SUFFIX:=.bc
  EXE_SUFFIX:=.html
endif

#~~~~ deduce file names ~~~~
ifneq (,${strip ${LIB_TARGET}})
  LIB_TARGET:=${LIB_PREFIX}${strip ${LIB_TARGET}}${LIB_SUFFIX}
  MAIN_C_FILES=
  MAIN_CXX_FILES=
else
  LIB_TARGET:=
  MAIN_C_FILES=${wildcard ${strip ${EXE_PREFIX}}*.c}
  MAIN_CXX_FILES=${wildcard ${strip ${EXE_PREFIX}}*.cpp}
endif
COMMON_C_FILES=${filter-out ${MAIN_C_FILES},${wildcard *.c}}
COMMON_CXX_FILES=${filter-out ${MAIN_CXX_FILES},${wildcard *.cpp}}
#
MAIN_OBJECT_FILES=${sort ${patsubst %.c,%.o,${MAIN_C_FILES}} \
                         ${patsubst %.cpp,%.o,${MAIN_CXX_FILES}}}
COMMON_OBJECT_FILES=${sort ${patsubst %.c,%.o,${COMMON_C_FILES}} \
                           ${patsubst %.cpp,%.o,${COMMON_CXX_FILES}}}
OBJECT_FILES=${MAIN_OBJECT_FILES} ${COMMON_OBJECT_FILES}
DEPEND_FILES=${patsubst %.o,%.d,${OBJECT_FILES}}
EXE_FILES=${sort ${patsubst %.c,%${EXE_SUFFIX},${MAIN_C_FILES}} \
                 ${patsubst %.cpp,%${EXE_SUFFIX},${MAIN_CXX_FILES}}}
#
GENERATED_FILES=${DEPEND_FILES} ${OBJECT_FILES} ${LIB_TARGET} ${EXE_FILES}
ifneq (,${findstring Darwin,${OS}})
  GENERATED_FILES+=${wildcard *.dSYM}
endif
ifeq (${strip ${wasm}},1)
  GENERATED_FILES+=${patsubst %.html,%.js,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.html.mem,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.wasm,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.wast,${EXE_FILES}}
endif
GENERATED_FILES+=${wildcard output_* *~}

#~~~~ compiler/linker settings ~~~~
CPPFLAGS+=-MMD -pedantic -Wall -Wextra -Wconversion -Wno-sign-conversion
CPPFLAGS+=-Wno-unused -Wno-unused-parameter
CPPFLAGS+=-Werror -Wfatal-errors
CFLAGS+=-std=c99 -Wc++-compat -Wwrite-strings -Wold-style-definition -Wvla
CXXFLAGS+=-std=c++17 -Wno-missing-braces
LDFLAGS+=
BINFLAGS+=
ifeq (${strip ${wasm}},1)
  CC=emcc
  CXX=em++
  CPPFLAGS+=-Wno-dollar-in-identifier-extension
  LDFLAGS+=-s ALLOW_MEMORY_GROWTH=1
else ifeq (${strip ${clang}},1)
  CC=clang
  CXX=clang++
else
  CC=gcc
  CXX=g++
endif
#
ifneq (,${strip ${MAIN_CXX_FILES} ${COMMON_CXX_FILES}})
  # force c++ link if there is at least one c++ source file
  LD:=${CXX}
else
  LD:=${CC}
endif

#~~~~ debug/optimisation settings ~~~~
ifneq (${strip ${opt}},0)
  CPPFLAGS+=-DNDEBUG
  BINFLAGS+=-O3 -ffast-math
  # BINFLAGS+=-fopt-info-vec-optimized
  ifneq (${strip ${wasm}},1)
    BINFLAGS+=-march=native
  endif
  ifeq (${strip ${opt}},2)
    # optimise but keep symbols for profiling
    BINFLAGS+=-g -fno-omit-frame-pointer
  else
    BINFLAGS+=-fomit-frame-pointer
  endif
else
  CPPFLAGS+=-UNDEBUG
  BINFLAGS+=-g -O0
  ifeq (${strip ${wasm}},1)
    # sanitizer is not available yet with Emscripten
  else ifneq (,${findstring Windows_NT,${OS}})
    # sanitizer is not available yet on Windows
  else
    BINFLAGS+=-fsanitize=address,undefined
    ifneq (,${findstring Raspbian,${OS}})
      # dynamic sanitizer libraries may not be found on Raspbian
      BINFLAGS+=-static-libasan -static-libubsan
    endif
  endif
endif

#~~~~ main target ~~~~
all : ${EXE_FILES} ${LIB_TARGET}

rebuild : clean all

.SUFFIXES:
.SECONDARY:
.PHONY: all clean rebuild

#~~~~ linker command to produce the library (if any) ~~~~
${LIB_TARGET} : ${COMMON_OBJECT_FILES}
	@echo ==== linking [opt=${opt}] $@ ====
	${LD} -shared -o $@ $^ ${BINFLAGS} ${LDFLAGS}
	@${SKIP_LINE}

#~~~~ linker command to produce the executable files (if any) ~~~~
%${EXE_SUFFIX} : %.o ${COMMON_OBJECT_FILES}
	@echo ==== linking [opt=${opt}] $@ ====
	${LD} -o $@ $^ ${BINFLAGS} ${LDFLAGS}
	@${SKIP_LINE}

#~~~~ compiler command for every source file ~~~~
%.o : %.c
	@echo ==== compiling [opt=${opt}] $< ====
	${CC} -o $@ $< -c ${BINFLAGS} ${CPPFLAGS} ${CFLAGS}
	@${SKIP_LINE}

%.o : %.cpp
	@echo ==== compiling [opt=${opt}] $< ====
	${CXX} -o $@ $< -c ${BINFLAGS} ${CPPFLAGS} ${CXXFLAGS}
	@${SKIP_LINE}

-include ${DEPEND_FILES}

#~~~~ remove generated files ~~~~
clean :
	@echo ==== cleaning ====
	${REMOVE} ${GENERATED_FILES}
	@${SKIP_LINE}

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Notre module de programmation doit déclarer une structure Time constituée des membres suivants :

un entier nommé minute,
un réel nommé second.

Ce même module doit déclarer et définir une fonction Time_total_seconds() :

elle attend un paramètre de type Time,
elle renvoie un résultat de type réel.

Son rôle est d'indiquer par son résultat la durée totale en secondes du temps décrit par le paramètre.
Il suffit d'additionner le nombre de minutes multiplié par soixante avec le nombre de secondes.

Pour tester le bon fonctionnement de cette réalisation, il faut définir dans le programme principal une fonction test_Time(), sans paramètre ni résultat, qui sera appelée depuis la fonction principale.
Elle commence par afficher lisiblement son nom.
Elle doit créer une variable de type Time en initialisant ses membres avec des valeurs de votre choix.
Elle doit ensuite afficher lisiblement les valeurs des membres de cette structure ainsi que le résultat de la fonction Time_total_seconds() qui lui est appliquée.
Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

{} Modification d'une structure Time

Notre module de programmation doit déclarer et définir une fonction Time_add_seconds() :

elle attend un paramètre de type pointeur désignant une structure Time,
elle attend un paramètre de type réel représentant une durée en secondes,
elle ne renvoie aucun résultat.

Son rôle est de modifier la structure Time désignée par le pointeur afin de lui ajouter les secondes (éventuellement négatives) indiquées en paramètre.
Il faudra veiller toutefois à ce que le membre second de la structure soit toujours dans l'intervalle [0.0; 60.0) :

tant que le membre second est supérieur ou égal à 60.0, il faut lui retirer 60.0 et incrémenter le membre minute,
tant que le membre second est inférieur à 0.0, il faut lui ajouter 60.0 et décrémenter le membre minute.

Pour tester le bon fonctionnement de cette réalisation, il faut compléter dans le programme principal la fonction test_Time() de la façon suivante :

utiliser la fonction Time_add_seconds() sur la variable de type Time existante, en choisissant un paramètre réel qui provoquera une augmentation de la valeur du membre minute,
- afficher lisiblement les valeurs des membres de la structure ainsi modifiée,
utiliser la fonction Time_add_seconds() sur la variable de type Time existante, en choisissant un paramètre réel qui provoquera une diminution de la valeur du membre minute,
- afficher lisiblement les valeurs des membres de la structure ainsi modifiée.

Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

{} Structure TimeCollection

Notre module de programmation doit être complété pour déclarer une structure TimeCollection constituée des membres suivants :

un entier nommé count,
un pointeur servant à désigner des structures Time nommé times.

Son rôle est de mémoriser un nombre variable (count) de structures Time (désignées par times).

Ce même module doit déclarer et définir une fonction TimeCollection_load() :

elle attend un paramètre de type const char * indiquant le nom d'un fichier,
elle renvoie un résultat de type TimeCollection.

Son rôle est de lire le contenu du fichier dont le nom est indiqué par son paramètre afin de renseigner à partir de ce contenu une structure TimeCollection qui sera le résultat.
Un tel fichier est supposé être organisé comme celui-ci : time_collection.txt✎.
La première information est un entier qui indique le nombre de structures Time que ce fichier décrit :

ce nombre correspondra au membre count,
il devra être pris en considération pour calculer le dimensionnement du bloc de mémoire alloué dynamiquement et désigné par le membre times.

Ensuite, pour chacune des structures Time promises, nous nous attendons à trouver dans le fichier :

un entier (membre minute),
le caractère :,
un réel (membre second).

Si la lecture d'un tel fichier rencontre une anomalie, il faut se contenter de renvoyer une structure TimeCollection dont les deux membres sont nuls.

Puisque la fonction précédente implique l'usage de mémoire allouée dynamiquement, notre module de programmation doit également déclarer et définir une fonction TimeCollection_destroy() :

elle attend un paramètre de type pointeur désignant une structure TimeCollection,
elle ne renvoie aucun résultat.

Son rôle est de libérer la mémoire allouée dynamiquement désignée par le membre times de la structure puis réinitialiser les deux membres à des valeurs nulles.

Pour tester le bon fonctionnement de cette réalisation, il faut définir dans le programme principal la fonction test_TimeCollection() de la façon suivante :

utiliser la fonction TimeCollection_load() pour obtenir une structure TimeCollection à partir du fichier time_collection.txt fourni plus haut,
pour chacune des structures Time contenues, afficher lisiblement les valeurs des membres de cette structure ainsi que le résultat de la fonction Time_total_seconds() qui lui est appliquée,
s'assurer du fait qu'il n'y ait pas de fuite mémoire avant de quitter cette fonction.

Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

{} Recherche dans une structure TimeCollection

{} Seconde variante

{} Structure Rectangle

Votre réalisation sera composée des fichiers suivants :

un programme principal prog_training_02.c,
un module de programmation rectangle_utils.h/rectangle_utils.c.

Le programme exécutable résultant sera obtenu en utilisant ce fichier GNUmakefile✎

Contenu du fichier GNUmakefile

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# this GNU-makefile relies on the GCC toolchain
# nb: on Windows, the Mingw-w64 package provides the mingw32-make.exe command
#     ( see https://web.enib.fr/~harrouet/dev_tools/#windows.mingw )

#~~~~ control global settings ~~~~
# make opt=2 --> enable optimisation, then disable debug, but keep symbols
# make opt=1 --> enable optimisation, then disable debug
# make opt=0 --> disable optimisation, then enable debug
opt=0
# make clang=1 --> use clang/clang++, not gcc/g++
# make clang=0 --> use gcc/g++, not clang/clang++
clang=0
# make wasm=1 --> target webassembly rather than the native platform
# make wasm=0 --> target the native platform rather than webassembly
wasm=0

#~~~~ build library or programs ~~~~
# if LIB_TARGET is provided, this library will be built (with its
# platform-specific name), otherwise ${EXE_PREFIX}* programs will be built
LIB_TARGET=
EXE_PREFIX=prog

#~~~~ detect operating system ~~~~
ifneq (${OS},Windows_NT)
  ifneq (,${findstring Ubuntu,${shell lsb_release -i 2>/dev/null}})
    OS:=Ubuntu
  else ifneq (,${findstring Raspbian,${shell lsb_release -i 2>/dev/null}})
    # Standard distribution for Raspberry-Pi
    OS:=Raspbian
  else
    OS:=${strip ${shell uname -s}}
  endif
  ifneq (,${findstring Microsoft,${shell cat /proc/version 2>/dev/null}})
    # Windows-Subsystem-for-Linux
    OS:=${OS}_WSL
  endif
endif

#~~~~ adjust project-specific settings ~~~~
CPPFLAGS=
# CPPFLAGS+=-I header/path
LDFLAGS=-lm
# LDFLAGS+=-L library/path -Wl,-rpath,library/path -l library_name
CFLAGS=
CXXFLAGS=
BINFLAGS=
ifneq (,${findstring Windows_NT,${OS}})
  # nothing special for now
else
  ifneq (,${strip ${LIB_TARGET}})
    BINFLAGS+=-fPIC
  endif
  ifneq (,${findstring Darwin,${OS}})
    # nothing special for now
  else
    ifneq (,${findstring Ubuntu,${OS}})
      # sanitizer sometimes requires gold-linker on Ubuntu
      LDFLAGS+=-fuse-ld=gold
    else ifneq (,${findstring Raspbian,${OS}})
      # some warnings may appear when mixing g++-6 and g++-7 on Raspbian
      CXXFLAGS+=-Wno-psabi
    else
      # nothing special for now
    endif
  endif
endif

#~~~~ adjust platform-specific features (Posix/Windows/Emscripten...) ~~~~
ifneq (,${findstring Windows_NT,${OS}})
  LIB_PREFIX=
  LIB_SUFFIX=.dll
  EXE_SUFFIX=.exe
  SKIP_LINE=echo.
  REMOVE=del /q
else
  LIB_PREFIX=lib
  ifneq (,${findstring Darwin,${OS}})
    LIB_SUFFIX=.dylib
  else
    LIB_SUFFIX=.so
  endif
  EXE_SUFFIX=
  SKIP_LINE=echo
  REMOVE=rm -rf
endif
ifeq (${strip ${wasm}},1)
  LIB_PREFIX:=lib
  LIB_SUFFIX:=.bc
  EXE_SUFFIX:=.html
endif

#~~~~ deduce file names ~~~~
ifneq (,${strip ${LIB_TARGET}})
  LIB_TARGET:=${LIB_PREFIX}${strip ${LIB_TARGET}}${LIB_SUFFIX}
  MAIN_C_FILES=
  MAIN_CXX_FILES=
else
  LIB_TARGET:=
  MAIN_C_FILES=${wildcard ${strip ${EXE_PREFIX}}*.c}
  MAIN_CXX_FILES=${wildcard ${strip ${EXE_PREFIX}}*.cpp}
endif
COMMON_C_FILES=${filter-out ${MAIN_C_FILES},${wildcard *.c}}
COMMON_CXX_FILES=${filter-out ${MAIN_CXX_FILES},${wildcard *.cpp}}
#
MAIN_OBJECT_FILES=${sort ${patsubst %.c,%.o,${MAIN_C_FILES}} \
                         ${patsubst %.cpp,%.o,${MAIN_CXX_FILES}}}
COMMON_OBJECT_FILES=${sort ${patsubst %.c,%.o,${COMMON_C_FILES}} \
                           ${patsubst %.cpp,%.o,${COMMON_CXX_FILES}}}
OBJECT_FILES=${MAIN_OBJECT_FILES} ${COMMON_OBJECT_FILES}
DEPEND_FILES=${patsubst %.o,%.d,${OBJECT_FILES}}
EXE_FILES=${sort ${patsubst %.c,%${EXE_SUFFIX},${MAIN_C_FILES}} \
                 ${patsubst %.cpp,%${EXE_SUFFIX},${MAIN_CXX_FILES}}}
#
GENERATED_FILES=${DEPEND_FILES} ${OBJECT_FILES} ${LIB_TARGET} ${EXE_FILES}
ifneq (,${findstring Darwin,${OS}})
  GENERATED_FILES+=${wildcard *.dSYM}
endif
ifeq (${strip ${wasm}},1)
  GENERATED_FILES+=${patsubst %.html,%.js,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.html.mem,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.wasm,${EXE_FILES}}
  GENERATED_FILES+=${patsubst %.html,%.wast,${EXE_FILES}}
endif
GENERATED_FILES+=${wildcard output_* *~}

#~~~~ compiler/linker settings ~~~~
CPPFLAGS+=-MMD -pedantic -Wall -Wextra -Wconversion -Wno-sign-conversion
CPPFLAGS+=-Wno-unused -Wno-unused-parameter
CPPFLAGS+=-Werror -Wfatal-errors
CFLAGS+=-std=c99 -Wc++-compat -Wwrite-strings -Wold-style-definition -Wvla
CXXFLAGS+=-std=c++17 -Wno-missing-braces
LDFLAGS+=
BINFLAGS+=
ifeq (${strip ${wasm}},1)
  CC=emcc
  CXX=em++
  CPPFLAGS+=-Wno-dollar-in-identifier-extension
  LDFLAGS+=-s ALLOW_MEMORY_GROWTH=1
else ifeq (${strip ${clang}},1)
  CC=clang
  CXX=clang++
else
  CC=gcc
  CXX=g++
endif
#
ifneq (,${strip ${MAIN_CXX_FILES} ${COMMON_CXX_FILES}})
  # force c++ link if there is at least one c++ source file
  LD:=${CXX}
else
  LD:=${CC}
endif

#~~~~ debug/optimisation settings ~~~~
ifneq (${strip ${opt}},0)
  CPPFLAGS+=-DNDEBUG
  BINFLAGS+=-O3 -ffast-math
  # BINFLAGS+=-fopt-info-vec-optimized
  ifneq (${strip ${wasm}},1)
    BINFLAGS+=-march=native
  endif
  ifeq (${strip ${opt}},2)
    # optimise but keep symbols for profiling
    BINFLAGS+=-g -fno-omit-frame-pointer
  else
    BINFLAGS+=-fomit-frame-pointer
  endif
else
  CPPFLAGS+=-UNDEBUG
  BINFLAGS+=-g -O0
  ifeq (${strip ${wasm}},1)
    # sanitizer is not available yet with Emscripten
  else ifneq (,${findstring Windows_NT,${OS}})
    # sanitizer is not available yet on Windows
  else
    BINFLAGS+=-fsanitize=address,undefined
    ifneq (,${findstring Raspbian,${OS}})
      # dynamic sanitizer libraries may not be found on Raspbian
      BINFLAGS+=-static-libasan -static-libubsan
    endif
  endif
endif

#~~~~ main target ~~~~
all : ${EXE_FILES} ${LIB_TARGET}

rebuild : clean all

.SUFFIXES:
.SECONDARY:
.PHONY: all clean rebuild

#~~~~ linker command to produce the library (if any) ~~~~
${LIB_TARGET} : ${COMMON_OBJECT_FILES}
	@echo ==== linking [opt=${opt}] $@ ====
	${LD} -shared -o $@ $^ ${BINFLAGS} ${LDFLAGS}
	@${SKIP_LINE}

#~~~~ linker command to produce the executable files (if any) ~~~~
%${EXE_SUFFIX} : %.o ${COMMON_OBJECT_FILES}
	@echo ==== linking [opt=${opt}] $@ ====
	${LD} -o $@ $^ ${BINFLAGS} ${LDFLAGS}
	@${SKIP_LINE}

#~~~~ compiler command for every source file ~~~~
%.o : %.c
	@echo ==== compiling [opt=${opt}] $< ====
	${CC} -o $@ $< -c ${BINFLAGS} ${CPPFLAGS} ${CFLAGS}
	@${SKIP_LINE}

%.o : %.cpp
	@echo ==== compiling [opt=${opt}] $< ====
	${CXX} -o $@ $< -c ${BINFLAGS} ${CPPFLAGS} ${CXXFLAGS}
	@${SKIP_LINE}

-include ${DEPEND_FILES}

#~~~~ remove generated files ~~~~
clean :
	@echo ==== cleaning ====
	${REMOVE} ${GENERATED_FILES}
	@${SKIP_LINE}

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Notre module de programmation doit déclarer une structure Rectangle constituée des membres suivants :

deux réels nommés x, y,
deux autres réels nommés width et height.

Ce même module doit déclarer et définir une fonction Rectangle_area() :

elle attend un paramètre de type Rectangle,
elle renvoie un résultat de type réel.

Son rôle est d'indiquer par son résultat la surface du rectangle décrit par le paramètre.
Il suffit de multiplier sa largeur par sa hauteur.

Pour tester le bon fonctionnement de cette réalisation, il faut définir dans le programme principal une fonction test_Rectangle(), sans paramètre ni résultat, qui sera appelée depuis la fonction principale.
Elle commence par afficher lisiblement son nom.
Elle doit créer une variable de type Rectangle en initialisant ses membres avec des valeurs de votre choix.
Elle doit ensuite afficher lisiblement les valeurs des membres de cette structure ainsi que le résultat de la fonction Rectangle_area() qui lui est appliquée.
Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

{} Modification d'une structure Rectangle

Notre module de programmation doit déclarer et définir une fonction Rectangle_extend() :

elle attend un paramètre de type pointeur désignant une structure Rectangle,
elle attend deux paramètres de type réel représentant la position d'un point,
elle ne renvoie aucun résultat.

Son rôle est de modifier la structure Rectangle désignée par le pointeur afin qu'elle englobe le point indiqué par les paramètres.

si l'abscisse du point est inférieure au membre x du rectangle (à sa gauche),
- la largeur du rectangle est augmentée de la différence entre le membre x et l'abscisse,
- le membre x du rectangle devient cette abscisse,
si au contraire l'abscisse du point est supérieure à la somme des membres x et width du rectangle (à sa droite),
- la largeur du rectangle devient la différence entre l'abscisse et le membre x,
un raisonnement similaire concerne l'ordonnée du point et les membres y et height du rectangle.

Pour tester le bon fonctionnement de cette réalisation, il faut compléter dans le programme principal la fonction test_Rectangle() de la façon suivante :

utiliser la fonction Rectangle_extend() sur la variable de type Rectangle existante, en choisissant des paramètres réels qui provoqueront un agrandissement du rectangle du côté des coordonnées basses,
- afficher lisiblement les valeurs des membres de la structure ainsi modifiée,
utiliser la fonction Rectangle_extend() sur la variable de type Rectangle existante, en choisissant des paramètres réels qui provoqueront un agrandissement du rectangle du côté des coordonnées hautes,
- afficher lisiblement les valeurs des membres de la structure ainsi modifiée.

Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

{} Structure RectangleGroup

Notre module de programmation doit être complété pour déclarer une structure RectangleGroup constituée des membres suivants :

un entier nommé count,
un pointeur servant à désigner des structures Rectangle nommé rectangles.

Son rôle est de mémoriser un nombre variable (count) de structures Rectangle (désignées par rectangles).

Ce même module doit déclarer et définir une fonction RectangleGroup_load() :

elle attend un paramètre de type const char * indiquant le nom d'un fichier,
elle renvoie un résultat de type RectangleGroup.

Son rôle est de lire le contenu du fichier dont le nom est indiqué par son paramètre afin de renseigner à partir de ce contenu une structure RectangleGroup qui sera le résultat.
Un tel fichier est supposé être organisé comme celui-ci : rectangle_group.txt✎.
La première information est un entier qui indique le nombre de structures Rectangle que ce fichier décrit :

ce nombre correspondra au membre count,
il devra être pris en considération pour calculer le dimensionnement du bloc de mémoire alloué dynamiquement et désigné par le membre rectangles.

Ensuite, pour chacune des structures Rectangle promises, nous nous attendons à trouver dans le fichier :

le caractère (,
un réel (membre x),
le caractère ;,
un réel (membre y),
le caractère ),
un réel (membre width),
le caractère ×,
un réel (membre height).

Si la lecture d'un tel fichier rencontre une anomalie, il faut se contenter de renvoyer une structure RectangleGroup dont les deux membres sont nuls.

Puisque la fonction précédente implique l'usage de mémoire allouée dynamiquement, notre module de programmation doit également déclarer et définir une fonction RectangleGroup_destroy() :

elle attend un paramètre de type pointeur désignant une structure RectangleGroup,
elle ne renvoie aucun résultat.

Son rôle est de libérer la mémoire allouée dynamiquement désignée par le membre rectangles de la structure puis réinitialiser les deux membres à des valeurs nulles.

Pour tester le bon fonctionnement de cette réalisation, il faut définir dans le programme principal la fonction test_RectangleGroup() de la façon suivante :

utiliser la fonction RectangleGroup_load() pour obtenir une structure RectangleGroup à partir du fichier rectangle_group.txt fourni plus haut,
pour chacune des structures Rectangle contenues, afficher lisiblement les valeurs des membres de cette structure ainsi que le résultat de la fonction Rectangle_area() qui lui est appliquée,
s'assurer du fait qu'il n'y ait pas de fuite mémoire avant de quitter cette fonction.

Le contrôle visuel de l'affichage produit sera l'occasion de corriger la réalisation si elle n'est pas conforme au fonctionnement attendu.

Aide pour l'entraînement

{} Recherche dans une structure RectangleGroup

Critères pour l'auto-correction

Après la réalisation d'un épreuve d'entraînement, il est nécessaire de s'auto-corriger pour estimer son niveau de préparation et le renforcer si nécessaire.
La correction consiste à attribuer une note de 0 à 20 pour chacun des critères suivants.

“Respecter les règles d'écritures élémentaires du langage”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

L'organisation, la forme et la syntaxe du code sont-elles conformes aux attentes de la première épreuve (fichiers de déclarations et de définitions, choix et conversion explicite des types, alternatives, boucles, déclarations et appels de fonctions...) ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

“Maîtriser l'usage courant des structures”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

La syntaxe est-elle toujours correcte (déclaration, initialisation, accès aux membres par . ou ->) ?
Le fait que la structure maintienne des données par l'intermédiaire de ses membres est-il toujours exploité (données transmises en plus de la structure, ou regénérées, par exemple) ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

“Maîtriser l'usage courant des pointeurs et tableaux”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

La syntaxe est-elle toujours correcte (prise d'adresse par &, accès à la donnée désignée par *, -> ou [] selon le besoin...) ?
La syntaxe n'est-elle pas parfois utilisée à mauvais escient (prise d'une adresse ou utilisation d'un pointeur alors que ce n'est pas nécessaire, ou bien confusion dans l'usage de const avec les pointeurs par exemple) ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

“Maîtriser l'usage courant de l'allocation dynamique”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

Des confusions subsistent-elles sur le type ou la taille en octets des blocs de données alloués ?
L'utilisation des données n'est-elle pas tentée avant leur allocation ?
La libération des données allouées n'intervient-elle pas prématurément ?
La libération des données allouées n'a-t-elle pas été oubliée ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

“Maîtriser l'usage courant des fichiers”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

Le mode d'ouverture du fichier est-il conforme à l'usage attendu ?
Les opérations sur le fichier respectent-elles les types manipulés (chaîne de format) ?
La fermeture du fichier a-t-elle lieu dans tous les cas (succès ou échec des opérations) ?
Le succès des opérations est-il systématiquement contrôlé ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

“Comprendre et respecter l'énoncé d'un problème trivial”
Quelques éléments à vérifier (pas nécessairement exhaustifs) :

Toutes les fonctions tentent-elles de réaliser exactement ce qui est décrit dans l'énoncé ?
Les tests ont-ils une chance fournir un diagnostic significatif (résultats récupéré, comparés, affichés...) ?
Les tests sont-ils suffisamment complets (variété dans les cas, contre-exemples, affichage compréhensible...) ?
L'avancée dans la réalisation est-elle suffisante pour évaluer significativement ce critère ?

Code source résultant

Si vous suivez scrupuleusement les énoncés et les rubriques d'aide, vous devez obtenir des fichiers de code source semblables à ceux-ci :

Fichier prog_training_2.c✎

Contenu du fichier prog_training_2.c

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include "time_utils.h"
#include "rectangle_utils.h"

#include <stdio.h>

//~~~~ First variant ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
test_Time(void)
{
    printf("\n~~~~ test_Time() ~~~~\n");
    Time t={5, 20.7};
    printf("%d:%g ~~> %g seconds\n",
        t.minute, t.second, Time_total_seconds(t));
    const double delta1=55.2;
    Time_add_seconds(&t, delta1);
    printf("adding %g seconds ~~> %d:%g\n",
        delta1, t.minute, t.second);
    const double delta2=-80.8;
    Time_add_seconds(&t, delta2);
    printf("adding %g seconds ~~> %d:%g\n",
        delta2, t.minute, t.second);
}

void
test_TimeCollection(void)
{
    printf("\n~~~~ test_TimeCollection() ~~~~\n");
    TimeCollection tc=TimeCollection_load("time_collection.txt");
    const int earliest_pos=TimeCollection_earliest_pos(&tc);
    for(int i=0; i<tc.count; ++i)
    {
        printf("%d:%g (%g)%s\n",
            tc.times[i].minute,
            tc.times[i].second,
            Time_total_seconds(tc.times[i]),
            i==earliest_pos ? " <~~ earliest" : "");
    }
    TimeCollection_destroy(&tc);
}

//~~~~ Second variant ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

void
test_Rectangle(void)
{
    printf("\n~~~~ test_Rectangle() ~~~~\n");
    Rectangle r={10.0, 20.0, 100.0, 50.0};
    printf("(%g;%g)%g×%g ~~> %g area\n",
        r.x, r.y, r.width, r.height, Rectangle_area(r));
    const double x1=5.5, y1=15.5;
    Rectangle_extend(&r, x1, y1);
    printf("extending with %g %g ~~> (%g;%g)%g×%g\n",
        x1, y1, r.x, r.y, r.width, r.height);
    const double x2=130.5, y2=75.5;
    Rectangle_extend(&r, x2, y2);
    printf("extending with %g %g ~~> (%g;%g)%g×%g\n",
        x2, y2, r.x, r.y, r.width, r.height);
}

void
test_RectangleGroup(void)
{
    printf("\n~~~~ test_RectangleGroup() ~~~~\n");
    RectangleGroup rg=RectangleGroup_load("rectangle_group.txt");
    const int largest_pos=RectangleGroup_largest_pos(&rg);
    for(int i=0; i<rg.count; ++i)
    {
        printf("(%g;%g)%g×%g (%g)%s\n",
            rg.rectangles[i].x,
            rg.rectangles[i].y,
            rg.rectangles[i].width,
            rg.rectangles[i].height,
            Rectangle_area(rg.rectangles[i]),
            i==largest_pos ? " <~~ largest" : "");
    }
    RectangleGroup_destroy(&rg);
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

int
main(void)
{
    test_Time();
    test_TimeCollection();

    test_Rectangle();
    test_RectangleGroup();

    return 0;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Fichier time_utils.h✎

Fichier time_utils.c✎

Fichier rectangle_utils.h✎

Fichier rectangle_utils.c✎

Contenu du fichier rectangle_utils.c

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include "rectangle_utils.h"

#include <stdio.h>
#include <stdlib.h>

double
Rectangle_area(Rectangle rect)
{
    return rect.width*rect.height;
}

void
Rectangle_extend(Rectangle *rect,
                 double x,
                 double y)
{
    if(x<rect->x)
    {
        rect->width+=rect->x-x;
        rect->x=x;
    }
    else if(x>rect->x+rect->width)
    {
        rect->width=x-rect->x;
    }
    if(y<rect->y)
    {
        rect->height+=rect->y-y;
        rect->y=y;
    }
    else if(y>rect->y+rect->height)
    {
        rect->height=y-rect->y;
    }
}

RectangleGroup
RectangleGroup_load(const char *filename)
{
    RectangleGroup rg={0, NULL};
    FILE *input=fopen(filename, "r");
    if(input!=NULL)
    {
        if((fscanf(input," %d ", &rg.count)==1)&&
           (rg.count>0))
        {
            rg.rectangles=(Rectangle *)malloc(rg.count*sizeof(Rectangle));
            if(rg.rectangles==NULL)
            {
                abort();
            }
            for(int i=0; i<rg.count; ++i)
            {
                if(fscanf(input, " ( %lg ; %lg ) %lg × %lg ",
                    &rg.rectangles[i].x,
                    &rg.rectangles[i].y,
                    &rg.rectangles[i].width,
                    &rg.rectangles[i].height)!=4)
                {
                    RectangleGroup_destroy(&rg);
                    break;
                }
            }
        }
        fclose(input);
    }
    return rg;
}

void
RectangleGroup_destroy(RectangleGroup *rg)
{
    free(rg->rectangles);
    rg->rectangles=NULL;
    rg->count=0;
}

int
RectangleGroup_largest_pos(const RectangleGroup *rg)
{
    int largest_pos=-1;
    double largest_area=0.0;
    for(int i=0; i<rg->count; ++i)
    {
        const double area=Rectangle_area(rg->rectangles[i]);
        if(largest_pos<0 || area>largest_area)
        {
            largest_pos=i;
            largest_area=area;
        }
    }
    return largest_pos;
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~