C et C++ TP6
Par O. Bailleux, Maître de conférences HDR à l'université de Bourgogne.
Buffer d’affichage et tortue graphique
Dans ce TP, nous allons développer un système permettant de simplifier l’affichage à l’écran de graphiques constitués de caractères ASCII. Le principe consiste à placer les caractères à afficher dans un buffer d’affichage, c’est à dire un tableau à deux dimensions, puis ensuite d’afficher à l’écran le contenu de ce tableau.
Nous appliquerons ce principe à la réalisation d’un système de création de dessins qui a été adopté pour la première fois par un langage de programmation appelé Logo.
Buffer d’affichage
Représentation en mémoire
La figure ci-dessous illustre la représentation en mémoire de notre buffer d’affichage :

Le buffer est un tableau dont chaque cellule sauf la dernière pointe un tableau contenant une chaine de caractères. La dernière cellule contient NULL. Chaque chaine représente une ligne d’affichage.
L’intérêt est qu’on peut garnir ces lignes de caractères dans un ordre quelconque et réaliser l’affichage une fois que le tableau est rempli.
La hauteur de l’affichage final est le nombre de lignes, et la largeur est la longueur des chaines représentant ces lignes.
Le buffer sera créé dynamiquement et stocké entièrement dans le tas.
Création du buffer
Question 1
Vous devez implémenter la fonction…
char* creeString(char c, int n);
…qui crée une chaîne de caractère située dans le tas, contenant n fois le caractère c.
Par exemple, l’appel creeString('A', 10) retourne l’adresse d’un tableau situé dans le tas contenant la chaine "AAAAAAAAAA".
Le moyen de créer un tel tableau est présenté dans la partie E, section E.dec1.
Question 2
Vous devez implémenter la fonction…
char** creeBuffer(int hauteur, int largeur);
…qui crée un buffer d’affichage tel que décrit plus haut. Chaque ligne du buffer doit être créée par un appel à la fonction creeString introduite dans la question précédente. La section E.dec3 du cours aborde la création dans le tas de tableaux à 2 dimensions.
Affichage du buffer
Question 3
Vous devez implémenter la fonction…
void affiche(char** buffer);
…qui affiche à l’écran le contenu du buffer d’affichage désigné par le paramètre buffer.
La fonction suivante permet de tester les fonctions de création et d’affichage :
void test1(void)
{
int h = 5; int l = 10;
char** buffer = creeBuffer(h, l);
buffer[0][0] = '#';
buffer[0][l-1] = '#';
buffer[h-1][l-1] = '#';
buffer[h-1][0] = '#';
affiche(buffer);
effaceBuffer(buffer);
affiche(buffer);
}
Elle doit afficher des # aux 4 coins de la zone d’affichage.
# #
# #
Destruction du buffer
Question 4
Vous devez implémenter la fonction…
void deleteBuffer(char** buffer);
…qui libère toute la mémoire occupée par le buffer désigné par le paramètre buffer.
Cette fonction doit être appelée à l’issue de l’exécution de la dernière ligne de la fonction test1 pour éviter toute fuite mémoire. Mais on ne voit pas à l’exécution si la mémoire est bien libérée? Demandez à votre enseignant de TP de vérifier si votre solution est correcte.
Effacement du buffer
Vous devez implémenter la fonction…
void effaceBuffer(char** buffer);
…qui remplit le buffer désigné par le paramètre buffer avec des espaces. Vous devez tester cette fonction.
Tortue graphique
Principe
Le principe d’une tortue graphique est le suivant :
- On positionne une tortue imaginaire, qui transporte un crayon tout aussi imaginaire, à un emplacement de l’espace d’affichage désigné par ses coordonnées (colonne, ligne).
- On définit la "mine" du crayon. Dans un véritable système graphique, la mine est définie par une couleur, une épaisseur, un type de trait. Dans notre système rudimentaire, la mine est le caractère qui sera écrit lorsqu’on déplacera le crayon. (Un exemple est donné plus bas).
- On définit l’orientation de la tortue, c’est à dire la direction et le sens de son déplacement. Dans notre système, il devra y avoir 4 sens possibles : Nord, Sud, Est et Ouest, désignées par les caractères
'N','S','E'et'O'. - On demande à la tortue de se déplacer sur une certaine distance.
- On recommence tout ou partie de ces actions autant de fois que nécessaire pour tracer le dessin souhaité.
Voici un exemple d’utilisation :
void test2(void)
{
int h = 20; int l = 40;
char** buffer = creeBuffer(h, l);
setCur(4, 9); setMine('X'); // Ligne A
setDir('N'); deplaceCrayon(buffer, 4); // Ligne B
setDir('E'); deplaceCrayon(buffer, 6);
setDir('S'); deplaceCrayon(buffer, 4);
setDir('O'); deplaceCrayon(buffer, 6);
setMine(' '); // Ligne C
setDir('S'); deplaceCrayon(buffer, 3); // Ligne D
setMine('@'); // Ligne E
setDir('E'); deplaceCrayon(buffer, 10); // Ligne F
setDir('N'); deplaceCrayon(buffer, 7);
setDir('E'); deplaceCrayon(buffer, 6);
setDir('S'); deplaceCrayon(buffer, 10);
setDir('O'); deplaceCrayon(buffer, 16);
setDir('N'); deplaceCrayon(buffer, 3); // Ligne G
affiche(buffer); // Ligne H
}
En ligne A, on positionne la tortue (et le crayon) à l’emplacement où le tracé va commencer et on définit la mine 'X', i.e. le crayon écrira des X en se déplaçant.
En ligne B, on déplace le crayon de 4 positions vers le nord, ce qui trace une ligne verticale de 4 X.
Ensuite on continue le tracé.
En ligne C, on change de mine pour que le prochain déplacement écrive des espaces.
En ligne D, on oriente la tortue vers le sud et on la déplace de 3 positions.
En ligne E, on change la mine pour lui donner la valeur '@'.
Les lignes F à G continuent le tracé en écrivant des @.
Toutes ces opérations n’ont réalisé aucun affichage à l’écran. Les écritures ont été faites dans le buffer.
La ligne H affiche le résultat :
XXXXXXX @@@@@@@
X X @ @
X X @ @
X X @ @
XXXXXX @ @
@ @
@ @
@@@@@@@@@@@ @
@ @
@ @
@@@@@@@@@@@@@@@@@
Fonctions de dessin
L’exemple précédent utilise les fonctions setCur, setDir, setMine, deplaceCrayon.
Vous devez définir toutes ces fonctions – ainsi que les variables globales nécessaires à leur exécution – et les tester.
Approfondissement
L’implémentation du système d’affichage décrit dans les sections précédentes fait appel à un tableau dynamique à deux dimensions et à différentes variables globales.
Proposez une implémentation basée sur le même principe, mais en encapsulant dans une structure toutes les données exploitées par le système d’affichage, c’est à dire le buffer d’affichage et toutes les données qui étaient placées dans des variables globales dans la version précédente.