Discussion :

[labarre2002]

Bonjour

je dois ecrire une fonction qui affiche a l ecran un rectangle de x caracteres de largeur de y caracteres de hauteur.

Pourrais je avoir des explications sur la facon de proceder ?

Merci.

NB:je demande pas une code mais des explications ou un algorithme.

[foetus]

C'est assez trivial
Tu as 2 types de côtés : horizontal et vertical

Ton algorithme est en 3 parties :

1. afficher 1 côté horizontal. Prenons le caractère '-', tu vas afficher 1 ligne (*) ayant X fois le caractère. X valant largeur
2. afficher les 2 côtés verticaux. Sur Y lignes (*), tu vas afficher les caractères '|', Z espaces et '|'. Y valant hauteur - 2 (si tu retires les 2 côtés horizontaux, mais à toi de voir **). Z valant largeur - 2 (tu retires les 2 côtés verticaux **)
3. afficher 1 côté horizontal. (la même chose que l'étape 1)

* : 1 ligne se termine par 1 saut de ligne '\n'.

** : Ma solution n'est pas non plus 1 rectangle vide puisque tu peux remplacer les espaces de l'étape 2 par 1 caractère. Par contre, contrairement à @Sve@r, j'affiche les contours.
Et les côtés qu'ils soient visibles ou non, il faut savoir si 1 rectangle de dimensions largeur par hauteur inclus les côtés ou non.
Autrement dit, si l'intérieur du rectangle a comme dimension largeur par hauteur ou 2 de moins verticalement et horizontalement.

[Sve@r]

Bonsoir

je dois ecrire une fonction qui affiche a l ecran un rectangle de x caracteres de largeur de y caracteres de hauteur.
Pourrais je avoir des explications sur la facon de proceder ?

Deux boucles imbriquées. La première qui va de 0 à y, la seconde qui va de 0 à x.
A chaque itération de la seconde (celle qui va de 0 à x) tu affiches un caractère. Une fois cette boucle terminée tu affiches un saut de ligne ('\n') et la première (celle qui va de 0 à y) repars à l'itération suivante et la seconde boucle recommence.

Tu as 2 types de côtés : horizontal et vertical...

Comme quoi, la précision est importante. J'ai compris ça comme étant un rectangle plein de caractères (exemple plein de '*') et toi comme un rectangle tels qu'on les trace en maths.
Bon ben les deux façons de considérer le truc sont toutes deux tout aussi valables l'une que l'autre, on verra bien...

[koala01]

Salut,

Deux boucles imbriquées (...)

Ou non, car cela marche aussi avec deux boucles qui ne sont pas imbriquées si la première s'occupe de créer une "ligne" qui sera utilisée par la deuxième

D'ailleurs, à bien y réfléchir, il y aurait même moyen de s'en sortir avec une seule boucle et un modulo

[Sve@r]

Ou non, car cela marche aussi avec deux boucles qui ne sont pas imbriquées si la première s'occupe de créer une "ligne" qui sera utilisée par la deuxième
Je suis allé au plus simple. Dessiner un rectangle c'est dessiner n fois une ligne (une boucle donc). Et dessiner une ligne c'est dessiner n fois un pixel (une seconde boucle donc imbriquée dans la première par la force des choses)

Ensuite on peut déléguer le dessin de la ligne à une fonction (j'y avais d'ailleurs pensé au départ) mais bon quelque part ça reste toujours de l'imbriqué.

D'ailleurs, à bien y réfléchir, il y aurait même moyen de s'en sortir avec une seule boucle et un modulo

Oui, selon le même principe qui permet de transformer un tableau 2D en tableau 1D. Mais bon, on ne va pas non plus disserter sur la meilleure façon de faire ce truc absolument inutile qui est de dessiner un carré à l'écran

[foetus]

D'ailleurs, à bien y réfléchir, il y aurait même moyen de s'en sortir avec une seule boucle et un modulo

Même pas (*)

À 1 moment si tu veux gérer les contours, tu vas avoir des tests dans tous les sens.
Je préfère faire 1 macro avec le bout de code qui affiche 1 ligne avec 1 caractère (ou 2 si on affiche le contour) afin de réduire la taille du code.
Mais rester sur 1 double boucle pour la compréhension du code.

*: Pas testé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void display_array(size_t width, size_t height) {
    if ((width > 0) && (height > 0)) {
        char* array = malloc(((width + 1) * height + 1) /* * sizeof(char) */);
 
        if (array != NULL) {
            size_t col;
 
            memset(array, '*', ((width + 1) * height));
            *(array + (width + 1) * height) = '\0';
 
            for(col=0; col < height; ++col) { *(array + (width + 1) * col) = '\n';  }
 
            printf("%s", array);
 
            free(array);
        } else {
            printf("display_array: error malloc");
        }
    } else {
        printf("display_array: nothing to do 0x0");
    }
}

[Sve@r]

*: Pas testé

Et c'est aussi bien comme ça. Ah là là cte horreur. Un malloc et memset() juste pour ne pas avoir à faire de boucle (surtout que le memset, lui, il ne doit pas s'en priver)...

[Mat.M]

oui pourquoi allouer un tableau et faire un malloc ? Il suffit de faire deux boucles imbriquées et allumer pixel par pixel.
Après si vous voulez faire un tampon en mémoire l'API win32 permet de faire un "backbuffer" ; par contre sous Linux je ne sais pas comment ça se passe.
Sous Windows pour afficher un pixel il faut utiliser l'API SetPixel ,très lente.