Langage C

[fatal_error]

le fonctionnement de base c'est de saisir ton caractère. De valider entree (genre si tas fait une faute de frappe, ca serait ballo si on prend en compte ta réponse sans que tu aies eu le temps de la valider).

Donc c'est complètement normal d'avoir à valider une réponse lorsqu'on t'a posé une question.

Maintenant, si tu veux détecter que l'utilisateur a tapé une lettre, tu utilises pas cin, mais un event. Tu peux par exemple regarder du coté de ncurses, de la SDL (c'est un peu overkill), ou bien de conio que je ne connais pas.

[Dlzlogic]

Petite intervention (merci d'avance à Ampholyte de participe).
J'ai fait dernièrement une petite appli. Le but était de permettre à un jeune enfant de taper des lettres sur un clavier, naturellement sans avoir besoin de faire "enter".
Naturellement le programme permet de tester si l'enfant a tapé la bonne lettre.
Pour des raisons techniques (son père ne travaille que sous linux et sa mère que sous Mac, et moi je n'ai que Windows) c'est écrit dans un environnement indépendant de ces 3 OS.

[Rockleader]

Petite intervention (merci d'avance à Ampholyte de participe).
J'ai fait dernièrement une petite appli. Le but était de permettre à un jeune enfant de taper des lettres sur un clavier, naturellement sans avoir besoin de faire "enter".
Naturellement le programme permet de tester si l'enfant a tapé la bonne lettre.
Pour des raisons techniques (son père ne travaille que sous linux et sa mère que sous Mac, et moi je n'ai que Windows) c'est écrit dans un environnement indépendant de ces 3 OS.

C'est donc bien cela qu'il faut faire alors; mais la question c'est comment faire

[Dlzlogic]

Ce soir, il est un peu tard.
Il y a un OS Unix, un autre OS Windows, il y a peu de différence d'utilisation entre les deux, sauf la saisie, c'est à dire ce qui concerne stdin.
Concernant l'appli que j'ai faite, c'est certainement basé que PHP et Javascript (je me souviens plus), et je te dis tout demain.
[Encore une fois, j'aimerais bien que Ampholyte participe.]

[ampholyte]

Bonjour,

Désolé pour cette réponse tardive, j'ai été un peu pris ces derniers temps.

Concernant les booléans, il est maintenant possible de les utiliser en incluant :

Code: Tout sélectionner

#include

Pour faire une boucle avec choix d'utilisateur sur un scanf, je ferais comme ceci :

Code: Tout sélectionner

#include
#include

/* On vide stdin */
void purge(void);

/* On vérifie si c est égale à Y/y/O/o */
bool check(char c);

int main(void) {
    bool loop = true;
    char c = 0;

    do {

        fprintf(stdout, "Poursuivre (o / n) ? \n"); /* Ou printf */

        scanf("%c", &c);

        purge();

        loop = check(c);

        /* Traitement */

    } while (loop);
}

void purge(void) {
    int c = 0;

    /* On lit stdin jusqu'à ce que l'on tombe sur EOF ou \n
     * Cela permet de vider le buffer en cas de mauvaise saisie utilisateur
     * (La fonction fflush n'est plus recommandée ) */
     

    while ((c = getchar()) != '\n' && c != EOF);
}

bool check(char c) {
    char verif[4 + 1] = "yYoO";
    int i = 0;

    for (i = 0; i  On poursuit le programme.

2eme tour :
On récupère n (n précédent) => On arrete le programme.

Pour corriger ce problème, on lit stdin en entier à chaque fois. C'est pour cette raison que la fonction fgets est beaucoup mieux pour traiter la réception d'une chaine de caractère.

On peut également lire une ligne entière avec un scanf :

[CODE]
char toto[125 + 1] = {0};

/* On lit jusqu'à obtenir le \n

scanf("%[^\n]", toto); /* Mais il faut également faire attention à la taille de la chaine => sinon segfault (dépassement du buffer toto) */
[/CODE]

On peut encore pousser le vice plus loin

[CODE]
char toto[125 + 1] = {0};

/* On lit jusqu'à obtenir le \n ou 125 caractères */
scanf("%125[^\n]", toto);

[/CODE]

On peut encore faire plus compliquer, mais je te laisse lire la doc ou regarder ce lien :
[url]http://xrenault.developpez.com/tutoriels/c/scanf/#L4.3[/url]

Pour lire en temps réel, je suis tombé sur le code suivant ([url]http://stackoverflow.com/questions/1513734/problem-with-kbhitand-getch-for-linux[/url]) :

[CODE]
/* Raw mode demo */
/* See exactly what is being transmitted from the terminal. To do this
   we have to be more careful. */

#include
#include
#include
#include
#include

struct termios oldtermios;

int ttyraw(int fd)
{
    /* Set terminal mode as follows:
       Noncanonical mode - turn off ICANON.
       Turn off signal-generation (ISIG)
        including BREAK character (BRKINT).
       Turn off any possible preprocessing of input (IEXTEN).
       Turn ECHO mode off.
       Disable CR-to-NL mapping on input.
       Disable input parity detection (INPCK).
       Disable stripping of eighth bit on input (ISTRIP).
       Disable flow control (IXON).
       Use eight bit characters (CS8).
       Disable parity checking (PARENB).
       Disable any implementation-dependent output processing (OPOST).
       One byte at a time input (MIN=1, TIME=0).
    */
    struct termios newtermios;
    if(tcgetattr(fd, &oldtermios) < 0)
        return(-1);
    newtermios = oldtermios;

    newtermios.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
    /* OK, why IEXTEN? If IEXTEN is on, the DISCARD character
       is recognized and is not passed to the process. This
       character causes output to be suspended until another
       DISCARD is received. The DSUSP character for job control,
       the LNEXT character that removes any special meaning of
       the following character, the REPRINT character, and some
       others are also in this category.
    */

    newtermios.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
    /* If an input character arrives with the wrong parity, then INPCK
       is checked. If this flag is set, then IGNPAR is checked
       to see if input bytes with parity errors should be ignored.
       If it shouldn't be ignored, then PARMRK determines what
       character sequence the process will actually see.

       When we turn off IXON, the start and stop characters can be read.
    */

    newtermios.c_cflag &= ~(CSIZE | PARENB);
    /* CSIZE is a mask that determines the number of bits per byte.
       PARENB enables parity checking on input and parity generation
       on output.
    */

    newtermios.c_cflag |= CS8;
    /* Set 8 bits per character. */

    newtermios.c_oflag &= ~(OPOST);
    /* This includes things like expanding tabs to spaces. */

    newtermios.c_cc[VMIN] = 1;
    newtermios.c_cc[VTIME] = 0;

    /* You tell me why TCSAFLUSH. */
    if(tcsetattr(fd, TCSAFLUSH, &newtermios) < 0)
        return(-1);
    return(0);
}


int ttyreset(int fd)
{
    if(tcsetattr(fd, TCSAFLUSH, &oldtermios) < 0)
        return(-1);

    return(0);
}

void sigcatch(int sig)
{
    ttyreset(0);
    exit(0);
}

void main()
{
    int i;
    char c;

    /* Catch the most popular signals. */
    if((int) signal(SIGINT,sigcatch) < 0)
    {
        perror("signal");
        exit(1);
    }
    if((int)signal(SIGQUIT,sigcatch) < 0)
    {
        perror("signal");
        exit(1);
    }
    if((int) signal(SIGTERM,sigcatch) < 0)
    {
        perror("signal");
        exit(1);
    }

    /* Set raw mode on stdin. */
    if(ttyraw(0) < 0)
    {
        fprintf(stderr,"Can't go to raw mode.\n");
        exit(1);
    }

    while( (i = read(0, &c, 1)) == 1)
    {
        if( (c &= 255) == 0177) /* ASCII DELETE */
            break;
        printf( "%o\n\r", c);
    }

    if(ttyreset(0) < 0)
    {
        fprintf(stderr, "Cannot reset terminal!\n");
        exit(-1);
    }

    if( i < 0)
    {
        fprintf(stderr,"Read error.\n");
        exit(-1);
    }

    exit(0);
}


Ce code permet de lire et d'afficher en temps réel les frappes utilisateurs (touche backspace pour sortir). Il fait appel à beaucoup de notion que tu n'as sûrement pas vu.

La fonction khbit a été implantée pour linux sur ce site : http://linux-sxs.org/programming/kbhit.html
Tu peux également utiliser cette fonction pour faire ce que tu souhaites.

Personnellement je ne te le conseille pas (ou pas tout de suite du moins). Apprend déjà à ne plus faire des petites erreurs et de rentrer dans la logique du C ("==" pour les tests par exemple).

PS : Désolé pour ce roman =) (je rattrape mon retard)

[Rockleader]

Je crois que j'ai plus ou moins digéré les parties qu'il fallait =)

Est il possible de faire la même chose avec une boucle while simple ? J'avoue que je n'aime pas la logique

Fait .... tant que...

On lit d'abord les instructions; alors que ce n'est peut être pas la peine de les lire si on a pas besoin d'entrer dans la boucle.

Pour moi il est plus logique de faire

Tant que .... Fait.... même si en C on exprime pas clairement le fait après un while comme en ada.


Je suis désolé si parfois je parle de truc un peu trop théorique, c'est en partie du à mon prof qui nous parle beaucoup de méthodologie, mais qui au final ne nous donne pas ou peu de code; ce qui fait que l'on n'a aucune réelle structure de base et que j'essaie de les trouver un peu partout.

Je trouve d'autant plus stupide de faire cela, car même si la théorie est importante, à partir du moment où on l'a vu pour un langage, les méthodes resteront plus ou moins similaire; alors que la syntaxe si on l'a pas on est obligatoirement bloqué. Quitte à ce que l'on nous explique des différences lorsqu'on arrive sur certains points importants.


Merci pour vos réponses à tous; mais comme le dit ampholyte; pour le moment j'essaie de rester simple.

[Dlzlogic]

Bonjour,
@ Amplolyte, je me doutais bien que tu connaissais la réponse à cette question.
@ Rockleader, il ne faut pas dire une boucle "tant que ... faire" est plus logique qu'une boucle "faire ... tant que", ce sont deux approches différentes, on utilise l'une ou l'autre suivant les cas.
La syntaxe dépend du langage, c'est généralement un détail, par contre la logique est la même pour tous les langages (ou presque) et c'est ça qui est indispensable à acquérir.
Comme promis, voila le jeu dont je parlais.
http://www.dlzlogic.com/Martin/JeuMartin.HTM

PS. J'ai lu le tutoriel de developpez.com. On peut regretter qu'il ne soit fait aucune allusion à la méthode habituellement conseillée, cad (f)gets puis sscanf.

[ampholyte]

Comme le dis très bien Dlzlogic, la boucle "tant que ... faire" et "faire ... tant que" sont deux boucles différentes.

La première passe une obligatoirement une fois dans la boucle.

La seconde ne passe pas toujours dans la boucle.

J'ai préféré utiliser une boucle tant que ... faire car c'est ma façon de faire et que je la trouve plus logique dans cet exemple. Par ailleurs l'avantage de cette boucle c'est de pouvoir faire une première boucle si tu ne connais l'initialisation des variables.

En reprenant exactement le même code qu'avant, il est très rapide de passer d'une boucle do while à une boucle while.

Code: Tout sélectionner

#include
#include

/* On vide stdin */
void purge(void);

/* On vérifie si c est égale à Y/y/O/o */
bool check(char c);

int main(void) {
    bool loop = true;
    char c = 0;

    while (loop) { /* Je sais que loop = true par l'initialisation*/
        fprintf(stdout, "Poursuivre (o / n) ? \n"); /* Ou printf */

        scanf("%c", &c);

        purge();

        loop = check(c);

        /* Traitement */

    }
}

void purge(void) {
    int c = 0;

    /* On lit stdin jusqu'à ce que l'on tombe sur EOF ou \n
     * Cela permet de vider le buffer en cas de mauvaise saisie utilisateur
     * (La fonction fflush n'est plus recommandée ) */
     

    while ((c = getchar()) != '\n' && c != EOF);
}

bool check(char c) {
    char verif[4 + 1] = "yYoO";
    int i = 0;

    for (i = 0; i < 4; i++) {
        if (c == verif[i]) {
            return true;
        }
    }

    return false;
}

PS. J'ai lu le tutoriel de developpez.com. On peut regretter qu'il ne soit fait aucune allusion à la méthode habituellement conseillée, cad (f)gets puis sscanf.

C'est normal le tutoriel parle uniquement de la fonction scanf ^^. Il y a d'autres tutoriels sur les différentes façons d'écrire et lire un flux de donnée : http://emmanuel-delahaye.developpez.com/tutoriels/c/notes-langage-c/?page=Page6

[fatal_error]

Code: Tout sélectionner

#include

int main(void) {
  WINDOW *w=initscr();
  timeout(-1);
  char c = 'O';
  while(c!='N'){
    c = getch();
    printw ("%d %c\n", c, c);
  }
  endwin();
  return 0;
}

Code: Tout sélectionner

gcc main.c -lncurses -o output

qui permet de détecter chaque caractère saisi.

noter le printw

[Dlzlogic]

Bonsoir fatal_error,
Pour moi, l'un des gros avantages du C est sa normalisation.
Je ne suis pas sûr que ton exemple rentre dans ce contexte.
Mon compilateur ne connait pas curses.h
Je préfère largement la solution en gérant stdin astucieusement.

[fatal_error]

et comment tu remplies stdin depuis ton terminal?
ps:un peu hatif sur la portabilité ou non de curses

[Dlzlogic]

Je te demande pardon, je suis d'accord pour tout (sauf qu'on donne de mauvais conseils à un débutant en informatique).
Y'a tout de même eu un précédent sur ce forum, notre ami a perdu beaucoup de temps et a fait fausse route il y a deux ou trois ans, à cause de mauvais conseils. (plus de détails par MP).

[Rockleader]

Une petite question quand au code d'ampholyte.

lorsque tu écris:

char verif[4 + 1] = "yYoO";

Pourquoi ce 4+1 ?
Etant donné que les tableaux commence à 0; j'aurais juste mis char verif[3] ou bien char verif[4-1]

Etant donné que le 4ème caractère O sera indicé par 3.




Une autre question; est il possible d'inclure avec une bibliothèque le nombre complexe i dans un calcul pour avoir un résultat; racine d'un trinôme par exemple.
J'ai tenté un simple i en ayant mis la biblio math mais le compilateur ne semble pas comprendre le i.

[Dlzlogic]

Une petite question quand au code d'ampholyte.

lorsque tu écris:

char verif[4 + 1] = "yYoO";

Pourquoi ce 4+1 ?
Etant donné que les tableaux commence à 0; j'aurais juste mis char verif[3] ou bien char verif[4-1]

Etant donné que le 4ème caractère O sera indicé par 3.




Une autre question; est il possible d'inclure avec une bibliothèque le nombre complexe i dans un calcul pour avoir un résultat; racine d'un trinôme par exemple.
J'ai tenté un simple i en ayant mis la biblio math mais le compilateur ne semble pas comprendre le i.

Bonjour,
Le tableau verif doit contenir une chaine de 4 caractères.
En C, la fin d'une chaine est marquée par le "zéro terminai", donc un caractère.
Pour stocker "yYoO" il faut donc réserver un espace de 5 caractères.
Il ne faut surtout pas confondre un nombre (de données) avec son rang.

Je ne crois pas que le C ait prévu une librairie complex (en C++ la classe existe)
Un nombre complexe, Z=a + ib
On peut toujours s'amuser à faire une structure COMPLEX

Code: Tout sélectionner

typedef struct COMPLEX
{
  float a;
  float b;
};

//et on pourra alors écrire
COMPLEX z;
z.a=partie_reelle;
z.b=partie_imaginaire;


J'ai tenté un simple i en ayant mis la biblio math

Qu'appelles-tu "biblio math" ?
Un simple 'i' n'a de sens que pour les matheux, les physiciens utilisent un simple 'j'. Pour un compilateur, "un simple i" ne peut être qu'une variable.
Je t'ai dit dans une réponse précédente que un complexe n'était qu'un ensemble de 2 nombres.

[Rockleader]

Ok pour le tableau j'ai compris merci !

par biblio math je voulais dire la bibliothèque que l'on inclus en faisant

#include

Pour le complexe; ça reste une optimisation, j'essaierai de revenir dessus si j'ai le temps; par ailleurs je suppose que l'on nous a dis de programmer en C, cela veut donc dire que l'on ne doit pas toucher aux fonctions du C++ bien que cela doit être je suppose sensiblement identique.

[Dlzlogic]

Oui, la librairie math contient les différentes fonction mathématiques, du genre abs, fabs, fonctions trigo, log, floor.
La différence principale entre le C et le C++ est l'existence des classes.
Si ton cours porte sur le C et non le C/C++, contente toi du C.
Si tu veux utiliser les complexes, crée toi simplement une structure.
Par contre apporte toute ton attention à l'utilisation des pointeurs, des listes chainées, des manipulations de chaine etc.

Petite précision sur l'emploi des termes :
Le C est un langage. Il définit une liste de mots clés, une liste d'opérateurs, et une syntaxe. Il n'y a pas à proprement parler de fonction C. Par contre il y a un certain nombres de bibliothèques qui contiennent des fonctions écrites en C.

[Rockleader]

En ce qui concerne la répétition; j'ai voulu essayer de refaire par moi même pour voir si je comprenais le code; ou du moins si je saurais le réutiliser; mais à priori ça bloque. :mur:


Je n'ai pas réalisé la fonction purge en partant du principe que si l'utilisateur se plante de valeur, tant pis pour lui (comme dirais mon prof; à partir du moment ou dans le prédicat d'entrée on dit qu'il faut entrer telle ou telles valeurs, on peut pas me faire de procès si l'utilisateur ne les rentres pas^^)

Je verrais tout de même cela plus tard.


Le problème vient bien de la vérification ici.


Voilà à quoi ressemble mon code

Code: Tout sélectionner

#include
#include
#include
#include

bool verif(char c);

int main()
{

  bool continu=true;
  char c=0;

  while (continu)

  {
   /*traitement*/

    printf("Voulez vous calculer une nouvelle équation (o/n)");
    scanf("%c",&c);
    continu=verif(c);
  }

  bool verif(char c)
  {
      char rep[2+1] ="oO";
      int i = 0;

    for (i = 0; i < 2; i++)
        {
        if (c == rep[i])
            {
            return true;
            }
        }

    return false;
  }
return(0);
}




Cela e fonctionne pas et mon compilateur me retourne l'erreur suivante: undefined reference to 'verif'

Etant donné que j'ai utilisé la même structure qu'ampholyte, je ne comprends pas ce qui coince; à moins que la fonction purge ne soit nécessaire au bon fonctionnement et/ou que j'ai mal crocheté ou parenthésé quelque part.

[Dlzlogic]

L'explication est simple : le C n'admet pas les fonctions imbriquées.
Il est impossible d'imbriquer des fonctions pour la raison suivante : l'un des principes fondamentaux du C est l'allocation et la récupération d'espace mémoire.
Ceci signifie que si le programme a besoin d'une fonction, il la charge et l'exécute jusqu'à la fin, c'est à dire le return.
L'adresse de retour, c'est à lire la ligne suivant l'appel de la fonction est stocké dans la pile (stack). C'est la raison pour laquelle la récursivité est à utiliser avec parcimonie (voir une discussion il y a pas très longtemps). C'est le principe du LiFo (last in first out).

D'autre part, il ne faut jamais dire (et en tout cas pas à un futur employeur) "l'utilisateur n'a qu'à pas se tromper".

[Rockleader]

L'explication est simple : le C n'admet pas les fonctions imbriquées.
Il est impossible d'imbriquer des fonctions pour la raison suivante : l'un des principes fondamentaux du C est l'allocation et la récupération d'espace mémoire.
Ceci signifie que si le programme a besoin d'une fonction, il la charge et l'exécute jusqu'à la fin, c'est à dire le return.
L'adresse de retour, c'est à lire la ligne suivant l'appel de la fonction est stocké dans la pile (stack). C'est la raison pour laquelle la récursivité est à utiliser avec parcimonie (voir une discussion il y a pas très longtemps). C'est le principe du LiFo (last in first out).

D'autre part, il ne faut jamais dire (et en tout cas pas à un futur employeur) "l'utilisateur n'a qu'à pas se tromper".

Je dois le placer ou du coup le code ? Parce que j'avoue que je ne vois pas.

je peux bien déclarer la fonction avant mon main; mais il faudra bien l'utiliser à moment donné.

Je vais essayer quelques test x)


Pour l'histoire de l'employeur, je suis tout à fait d'accord; c'est pour ça que je n'apprécie pas trop ce que dis notre prof là dessus et que je disais cela avec humour. Je ne crois pas qu'une gestion d'erreur soit parfaite, mais il faut s'en rapprocher le plus possible à mon avis. Mais pour le moment je suis sur les bases donc ><

[fatal_error]

Donc pour la définition de ta fonction verif:
avant toute utilisation de ta fonction verif, il faut que celle-ci soit déclarée
c'est à dire qu'au moins sa signature ai été écrite:

Code: Tout sélectionner

bool verif();//declaration
int main(){
 verif()
}...
bool verif(){
 //implementation plus tard
}

évidément si tu fais directement l'implementation avant le main, non seulement tu la déclare mais également tu la définis (puisque tu l'as implémentée)

Ca explique pourquoi tu prends undefined reference to verif.

Maintenant, essayer de définir verif dans le corps de main n'a aucun sens. Et n'est pas non plus possible me semble-t-il.

------------
ton professeur a parfaitement raison pour le coup: si dans ton cahier des charges il est précisé que l'utilisateur doit saisir des lettres dans a-z
S'il saisit des chiffres, et que le programme crache, c'est son problème. Bien sûr, il pourra se plaindre, mais tu pourras lui dire de lire le cahier des charges.