Discussion :

[débutant_01]

je suis sur console c , et je veux savoir comment peut on contrôler les flèches du clavier , par exemple si j’appuie sur la flèche droite , j'affiche un message etc . la deuxième question , je veux savoir si on peut rendre la (console application ) plus interactif , comme en sdl tout le travail se fait sur la même surface , contrairement sur console l'exécution du programme est séquentielle page après page .

[Obsidian]

Bonjour,

Ça dépend essentiellement de la machine que tu utilises (on suppose que c'est un PC) et du système d'exploitation avec lequel tu travailles. Il n'y a rien de standard de ce côté parce que les « flèches » ne sont pas des caractères de contrôles de la table ASCII (ni des charsets qui en découlent). À titre indicatif, le Videotex (utilisé par le Minitel) mappait les touches gauche, droite, basse et haute sur les caractères 8, 9, 10 et 11, ce qui avait du sens puisqu'il correspondent respectivement à Backspace, Tabulation, Line Feed et Vertical Tab, donc à des déplacements dans les mêmes directions. Accessoirement, c'est presque également les touches choisies par VI et Vim pour se déplacer.

Sur PC, dans la console de DOS et Windows et sous UNIX, on utilise en général des terminaux virtuels émulant les anciens DEC, devenu norme ANSI ainsi que ECMA-48. Ça veut dire que quand tu vas appuyer sur une de ces touches, tu vas recevoir d'un coup quatre caractères : le caractère Escape (27), le crochet ouvrant « [ » et une lettre majuscule de A à D pour les directions hautes, basses, droite et gauche, respectivement.

De là, tu as trois possibilités :

• Tu gères la réception de ces séquences en mettant en place un système d'états ;
• Tu utilises une bibliothèque comme curses ou ncurses pour gérer tout cela pour toi ;
• Tu t'appuies sur le système d'événements de ton système d'exploitation s'il en propose un.

Si tu débutes complètement, la première solution reste la plus simple à mettre en place même si elle est loin d'être facile.

[Tagashy]

je ne sais pas si ma réponse t'aideras plus que celle de Obsidian mais je crois avoir compris ce que tu veut dire :
comme la très bien expliqué Obsidian mais en oubliant le quatrième caractère.

tu vas recevoir d'un coup quatre caractères : le caractère Escape (27), le crochet ouvrant « [ » et une lettre majuscule de A à D pour les directions hautes, basses, droite et gauche, respectivement.

les flèche du clavier sont mapper à 3 caractère et non 4, le 4 quatrieme dont parle Obsidian est entrée car sans lui tu as beau appuyer sur tes flèche ton programme fera rien cependant si tu veux qu'aux moment ou tu appuis sur une flèche quelle que chose se fasse sans avoir à appuyer sur entrée lis la suite sinon passe ton chemin si tu débute.

Sous Windows et Linux (peut être pas tous mais la majorité) quand tu est en console tu est dans un mode spécial sous Linux c'est cooked le nom sous Windows je ne le connais pas.
En fait ce mode te transforme des caractères comme entrée ou supr ce qui te permet de modifier ta chaine ou de la modifier au besoin et de la valider quand tu appuis sur entrée. seulement à ce moment la tes donnée sont envoyer à ton getc(), getchar(), fgets().
Sous Windows tu peux lire le flux d'entrée avec une fonction spéciale.
Sous Linux il faut changer de mode de lecture.
Dans les deux cas je t'invite à lire cet article de la faq

[Obsidian]

les flèche du clavier sont mapper à 3 caractère et non 4,

Très bonne remarque !
C'est une faute d'inattention de ma part. Les séquences CSI des touches du clavier tiennent bien sur trois caractères et non quatre. C'est une mauvaise habitude qui m'est restée, probablement à cause du rendu à l'écran : « ^[[A ».

le 4 quatrieme dont parle Obsidian est entrée car sans lui tu as beau appuyer sur tes flèche ton programme fera rien cependant si tu veux qu'aux moment ou tu appuis sur une flèche quelle que chose se fasse sans avoir à appuyer sur entrée lis la suite sinon passe ton chemin si tu débute.

Comme tu le précises plus bas, ceci ne s'applique en principe pas à fgetc() au niveau du programme C en lui-même, mais les terminaux des différents systèmes d'exploitation utilisent des disciplines de ligne qui permettent de les bufferiser en amont. Ça se modifie sous Unix avec stty depuis le shell ou termios depuis un programme C.

Sous Windows et Linux (peut être pas tous mais la majorité) quand tu est en console tu est dans un mode spécial sous Linux c'est cooked le nom sous Windows je ne le connais pas.
En fait ce mode te transforme des caractères comme entrée ou supr ce qui te permet de modifier ta chaine ou de la modifier au besoin et de la valider quand tu appuis sur entrée. seulement à ce moment la tes donnée sont envoyer à ton getc(), getchar(), fgets().

« cooked » est un raccourci passé à stty, qui revient en fait à lui passer d'un coup plusieurs flags de façon à remettre le terminal dans l'état « normal », vu de l'utilisateur, et qui effectue par défaut tous les traitements que l'on connaît. Il existe également « raw » au principe similaire mais servant à obtenir les effets inverses. Pour recevoir immédiatement les caractères depuis un terminal UNIX, il faut retirer le mode canonique : « -icanon ».

[Tagashy]

@Obsidian que veux tu dire par

Pour recevoir immédiatement les caractères depuis un terminal UNIX, il faut retirer le mode canonique : « -icanon ».

pour le faire je me suis servie de l'exemple de la FAQ

je te le montre en lui fournissant un code qui peut l'aider (ça lui mâche le boulot)

!!!!!!!!!!! ATTENTION SI TU SOUHAITE DÉVELOPPER TOI MÊME TON PROGRAMME NE COPIE PAS, INSPIRE TOI EN !!!!!!!!!!

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#include <termios.h> 
#include <unistd.h> 
#include <dirent.h>
#include <sys/types.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
 
int main()
{
	int c;
	while(c != EOF) {
		mode_raw(1);
c = getchar();
switch(c) {
	case EOF:cexit();
		break;
	case 4:cexit();
		break;
	case 27:c=getchar();
		if (c=='[')
		{
			c=getchar();
			switch(c){
				case 'A': /*fleche du haut*/
				break;
				case 'B': /*fleche du bas*/
				break;				
				case 'C': /*fleche de droite*/
				break;				
				case 'D': /*fleche de gauche*/
				break;
				}
		}
		break;
	default:
/*autre touche*/
		break;
	}
	}
	return 0;
}
 
void mode_raw(int activer) 
{ 
    static struct termios cooked; 
    static int raw_actif = 0; 
 
    if (raw_actif == activer) 
        return; 
 
    if (activer) 
    { 
        struct termios raw; 
 
        tcgetattr(STDIN_FILENO, &cooked); 
 
		raw = cooked; 
        cfmakeraw(&raw); 
        tcsetattr(STDIN_FILENO, TCSANOW, &raw); 
    } 
    else 
        tcsetattr(STDIN_FILENO, TCSANOW, &cooked); 
 
    raw_actif = activer; 
}
 
void cexit(void)
{
 
	mode_raw(0);
	putc('\n',stdout);
	exit(0);
}

il y as surement trop de librairie je ne sais plus lesquelles sont nécessaire ^^

[Obsidian]

@Obsidian que veux tu dire par…

Comme dit plus haut, « raw » et « cooked » ne sont pas des flags spécifiques : ce sont plutôt des profils types. « raw » signifie « brut » (« de décoffrage », si tu préfères) et « cooked » signifie « cuisiné » (« aux petits oignons »). La fonction cfmakeraw() est une extension non standard du monde BSD, de façon à replacer le terminal dans un mode où les services rendus sont réduits au minimum, par compatibilité avec les premières versions des vrais terminaux physiques :

Raw mode
cfmakeraw() sets the terminal to something like the "raw" mode of the old Version 7 terminal driver: input is available character by character, echoing is disabled, and all
special processing of terminal input and output characters is disabled. The terminal attributes are set as follows:

termios_p->c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
| INLCR | IGNCR | ICRNL | IXON);
termios_p->c_oflag &= ~OPOST;
termios_p->c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
termios_p->c_cflag &= ~(CSIZE | PARENB);
termios_p->c_cflag |= CS8;

« cooked » n'existe donc pas a priori mais est en fait le pendant inverse du mode raw. La commande stty reconnaît ces dénominations et règle d'un coup tous les flags du terminal. C'est écrit dans la man page de stty :

cooked
identique à brkint ignpar istrip icrnl ixon opost isig icanon, les caractères « eof » et « eol » ayant leur valeur par défaut
-cooked
identique à raw

raw
identique à -ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr -icrnl -ixon -ixoff -iuclc -ixany -imaxbel -opost -isig -icanon -xcase min 1 time 0
-raw
identique à cooked

On voit qu'en réalité, ces flags font beaucoup de choses, comme par exemple définir les caractères spéciaux qui serviront à interrompre une séquence ou envoyer un signal. L'utilisation d'une discipline de ligne en particulier qui exploite ces caractères spéciaux etla bufferisation de la saisie sont liées à l'utilisation du mode canonique, comme décrit dans la man page (voir section « canonical and non-canonical modes »). À partir du moment où on le désactive, ce sont toutes les fonctions interactives du terminal qui passent en sommeil.

Il n'y a donc qu'un seul flag à modifier si l'on veut lire les caractères directement, ce qui permet d'éviter d'avoir à effacer tous les autres paramètres avec raw ou cooked, ce qui est appréciable si l'utilisateur a défini les siens.