Copie de chaine de caracteres sans succes
bpasc...@googlemail.com
Ce code ne fonctionne pas et il me semble pas il y a avoir de
difficultés. Je pense avoir fait une erreur quelque part.
Voici:
#include <stdio.h>
int main(void)
{
char Ch1[40] ;
char Suj[80] ;
char FinSuj[60] ;
int i, j, k ;
int OK ;
printf("\n\nEntrez la chaine Ch1 : ") ;
fgets(Ch1, 40, stdin) ;
printf("\nEntrez la chaine Suj. : ") ;
fgets(Suj, 80, stdin) ;
OK = 1 ;
for ( i = 0 ; OK && Suj[i] ; i++ )
if ( Suj[i] == Ch1[0] )
{
for ( j = 1 ; Ch1[j] && (Ch1[j] == Suj[i+j] ) ; j++ )
;
if ( Ch1[j] == '\0' )
OK = 0 ;
}
if (!OK)
{
/* copie de la fin de Suj dans FinSuj */
i-- ;
for ( k = 0 ; Suj[i+j+k] ; k++ )
FinSuj[k] = Suj[i+j+k] ;
FinSuj[k] = '\0' ;
}
printf("\n%s", FinSuj) ;
printf("\n\n");
return 0 ;
}
Marc Espie
bpasc...@googlemail.com <bpasc...@googlemail.com> wrote:
>Bonjour,
>Ce code ne fonctionne pas et il me semble pas il y a avoir de
>Voici:
>
>#include <stdio.h>
>
>int main(void)
>{
> char Ch1[40] ;
> char Suj[80] ;
> char FinSuj[60] ;
>
> int i, j, k ;
> int OK ;
>
> printf("\n\nEntrez la chaine Ch1 : ") ;
> fgets(Ch1, 40, stdin) ;
fgets a une valeur de retour, c'est une fonction d'entree -> commence
par verifier que tout s'est bien passe, ensuite on en reparle.
(et accessoirement, un printf("Chaine: "); peut ne rien afficher.
Il FAUT le fflush(stdout); derriere si tu veux etre sur d'avoir quelque
chose...)
Benoit Izac
le 29/11/2009 à 16:13, bpascal a écrit dans le message
<c4f1c632-ff4a-4893...@m25g2000yqc.googlegroups.com> :
> Ce code ne fonctionne pas
Pour en être sûr, il faudrait savoir ce qu'il est censé faire.
> et il me semble pas il y a avoir de difficultés. Je pense avoir fait
> une erreur quelque part. Voici:
>
> #include <stdio.h>
>
> int main(void)
> {
> char Ch1[40] ;
> char Suj[80] ;
> char FinSuj[60] ;
>
> int i, j, k ;
> int OK ;
>
> printf("\n\nEntrez la chaine Ch1 : ") ;
fflush(stdout);
> fgets(Ch1, 40, stdin) ;
Il faut toujours tester le retour de fgets (et même faire un peu plus
pour être sûr de Ch1[]). Par exemple si je rentre 50 caractères et que
j'appuie sur ENTER (ça fait donc 51 comme le Pastis), tu auras 39
caractères dans Ch1 et les autres dans Suj[] (12 caractères). Je ne
pense pas que ce soit ce que tu attends.
> printf("\nEntrez la chaine Suj. : ") ;
> fgets(Suj, 80, stdin) ;
>
> OK = 1 ;
>
> for ( i = 0 ; OK && Suj[i] ; i++ )
> if ( Suj[i] == Ch1[0] )
> {
> for ( j = 1 ; Ch1[j] && (Ch1[j] == Suj[i+j] ) ; j++ )
Ici de devrait vérifier que tu n'es pas non plus en dehors de Suj[] car
il peut y avoir n'importe quoi derrière.
for (j = 1; Suj[i+j] && Ch1[j] && Ch1[j] == Suj[i+j]; j++)
> ;
> if ( Ch1[j] == '\0' )
> OK = 0 ;
> }
>
> if (!OK)
> {
> /* copie de la fin de Suj dans FinSuj */
> i-- ;
Même chose que précédemment, il faut t'assurer que Suj[i+j+k] soit
toujours dans Suj[] (dans ce qui a été entrée via stdin).
> for ( k = 0 ; Suj[i+j+k] ; k++ )
> FinSuj[k] = Suj[i+j+k] ;
> FinSuj[k] = '\0' ;
> }
>
> printf("\n%s", FinSuj) ;
>
> printf("\n\n");
>
> return 0 ;
> }
--
Benoit Izac
Benoit Izac
le 29/11/2009 à 16:13, bpascal a écrit dans le message
<c4f1c632-ff4a-4893...@m25g2000yqc.googlegroups.com> :
Je suis pas sûr de ce que tu as voulu faire, j'ai légèrement modifié ton
code et rajouté pas mal de commentaires.
#include <stdio.h>
#include <stdlib.h> /* pour exit(3) */
/* c'est plus pratique ; quand on veut modifier une taille, on a pas
* besoin de parcourir tout le programme */
#define STR_S 80
#define SUB_S 40
#define END_S 60
/* Demande une chaine et un sous-chaine. Si la sous-chaine apparaît
* dans la chaine principale le programme affiche ce qui reste dans la
* chaine principale après la première occurrence de la sous-chaine. */
int
main(void)
{
char str[STR_S]; /* la chaine principale */
char sub[SUB_S]; /* la sous-chaine */
char end[END_S]; /* la fin de la chaine */
int i, j, k;
int found;
/* ici il faut bien voir qu'aucune des variables ci-dessus n'a été
* initialisées. Il ne faut surtout pas les utiliser car elles
* peuvent contenir n'importe quoi, surtout pas de
* printf("%s", end) */
printf("Entrez la chaine principale : ");
/* comme il n'y a pas de '\n' à la fin du printf, pour être sûr de
* l'affichage il faut forcer le vidage du buffer de sortie */
fflush(stdout);
if (fgets(str, STR_S, stdin) == NULL) {
/* il y a eu une erreur, normalement, il faudrait chercher
* à savoir d'où elle vient ; on va faire simple, on se
* contente de quitter le programme */
exit(EXIT_FAILURE);
}
/* on va vérifier qu'il n'y a pas eu trop de caractères : on
* cherche la fin de la chaine puis on vérifie que le caractère
* précédent est bien un retour à la ligne */
for (i = 0; str[i]; i++)
;
/* i est au '\0' qui marque la fin de la chaine, on recule */
i--;
if (str[i] != '\n')
/* il n'y a pas de retour à la ligne donc il y a trop de
* caractères dans stdin : on quitte le programme */
exit(EXIT_FAILURE);
/* pendant qu'on est sur le '\n', on va le supprimer */
str[i] = '\0';
/* la même chose pour sub, une fonction serait pratique ici plutôt
* que de recopier le code */
printf("Entrez la sous chaine : ");
fflush(stdout);
if (fgets(sub, SUB_S, stdin) == NULL)
exit(EXIT_FAILURE);
for (i = 0; sub[i]; i++)
;
i--;
if (sub[i] != '\n')
exit(EXIT_FAILURE);
sub[i] = '\0';
/* pour le moment on à rien trouvé */
found = 0;
/* on parcourt str[] jusqu'à ce qu'on trouve */
for (i = 0; str[i]; i++) {
if (str[i] == sub[0]) {
/* on a trouvé */
found = 1;
/* on parcourt sub[] */
for (j = 1; sub[j]; j++) {
if (str[i+j] != sub[j]) {
/* c'est différent, on arrête de parcourir sub[] */
found = 0;
break;
}
if (str[i+j] == '\0') {
/* on est à la fin de str[], on sort */
found = 0;
break;
}
}
if (found)
/* on a trouvé on arrête de parcourir str[] */
break;
}
}
if (found) {
/* i était là où on avait trouvé (str[i] == sub[0])
* j était au '\0' de sub[]
* i + j sera donc au bon endroit
* attention à ne pas écrire plus loin que la taille de k[]
* on garde une place pour le zéro final */
for (k = 0; str[i + j + k] && k < (END_S - 1); k++)
end[k] = str[i + j + k];
end[k] = '\0';
printf("%s\n", end);
bpasc...@googlemail.com
implémentation d'un algorithme basique je le trouve intéressant pour
me pencher dessus.
Donc quand j'exécute le code avec par exemple : Ch1 = jour ... Ch2 =
bonjour ... ça fonctionne, le "trouve!" de la condition if s'affiche.
Cependant quand j'exécute avec Ch1 = bon ... Ch2 = bonjour ... rien
ne s'affiche
Voici:
#include <stdio.h>
int main(void)
{
char Suj[100] ;
char Ch1[40] ;
char Ch2[40] ;
char FinSuj[80] ;
int i, j, k ;
int ok = 1 ;
printf("\n\nEntrez la chaine a rech. Ch1 : ") ;
fgets(Ch1, 40, stdin) ;
printf("\nEntrez la chaine Sujet. : ") ;
fgets(Suj, 80, stdin) ;
for ( i = 0 ; ok && Suj[i] ; i++ )
{
if ( Suj[i] == Ch1[0] )
{
for ( j = 1 ; Ch1[j] && (Ch1[j] == Suj[i+j]) ; j++ )
;
if ( Ch1[j] == '\0' )
{
ok = 0 ;
printf("\ntrouve!") ;
}
}
}
printf("\n\n") ;
return 0 ;
}
Je ne souhaite pas faire appel aux pointeurs et aux fonctions autres
comme fflush car d'après le tutorial, ça n'est pas nécessaire. Je
connais un peu le mécanisme des pointeurs mais ne sachant pas si C
sera un langage sur lequel je vais concentrer mes efforts sur le long
terme, je porte mes efforts sur les algos. Je sais vous allez me dire
que C n'est pas bon pour les algos. Ca fait plusieurs que j'apprends
et j'ai pas envie de faire machine arrière.
Merci
Pascal
candide
> Je ne souhaite pas faire appel aux pointeurs et aux fonctions autres
> comme fflush car d'apr�s le tutorial, �a n'est pas n�cessaire.
????????
Et quel est ce tutorial qui �crit �a?
> terme, je porte mes efforts sur les algos.
Non, l� tu portes tes efforts sur les entr�es/sorties
> Je sais vous allez me dire
> que C n'est pas bon pour les algos.
Si mais �a d�pend des algos et �a d�pend de ce que tu veux faire. Mais
tu peux aller assez loin sans pointeur, juste avec
-- des fonctions (que tu �cris toi-m�me bien s�r)
-- des instructions for, while, if/else
-- des tableaux
-- printf
-- �ventuellement des structures
-- quelques op�rateurs bien s�
Marc Espie
bpasc...@googlemail.com <bpasc...@googlemail.com> wrote:
>Je ne souhaite pas faire appel aux pointeurs et aux fonctions autres
Mauvais tutoriel, changer de tutoriel.
Il est *necessaire* d'appeler fflush apres un printf sans "\n" au bout
si tu veux etre sur que les choses s'affichent avant le prochain fgets/scanf.
Si le meme tutoriel t'encourage aussi a ne pas verifier le code de retour
de fgets, c'est definitivement un tutoriel a eviter !
Comme repete 25 fois ici et ailleurs, le C est un langage carrement *hostile*
aux debutants. Toutes les mauvaises habitudes que tu prends maintenant vont
te faire gagner 30 secondes sur le coup, et te faire perdre des heures plus
tard. A toi de voir...
bpasc...@googlemail.com
> In article <06f71962-5c18-4279-aa5b-d70356bef...@e23g2000yqd.googlegroups.com>,
>
> bpascal...@googlemail.com <bpascal...@googlemail.com> wrote:
> >Je ne souhaite pas faire appel aux pointeurs et aux fonctions autres
>
C'est un conseil ou un ordre?
Tu es le président de la république :)
Réponse : voici l'adresse du tuto :
http://www.ltam.lu/Tutoriel_Ansi_C/
Exercice 8.23
La solution ne montre que l'usage de stdio.h ... car les exercices
appartiennent à chaque chapitre. Même si le code n'est pas actualisé,
je trouve l'ouvrage de cet auteur pédagogique. Pouvez-vous me montrer
quelque chose de mieux (tuto avec cours et exercices?). Alors est-ce
que je gagnerais à changer de tuto? Je vous renvoie la balle vous qui
critiquez à chacun de mes posts. Est-ce que je dois changer de groupe?
> Il est *necessaire* d'appeler fflush apres un printf sans "\n" au bout
> si tu veux etre sur que les choses s'affichent avant le prochain fgets/scanf.
> Si le meme tutoriel t'encourage aussi a ne pas verifier le code de retour
> de fgets, c'est definitivement un tutoriel a eviter !
J'ai volontairement remplacé le gets du code initiale par fgets (code
propre sans warning).
> Comme repete 25 fois ici et ailleurs, le C est un langage carrement *hostile*
> aux debutants. Toutes les mauvaises habitudes que tu prends maintenant vont
> te faire gagner 30 secondes sur le coup, et te faire perdre des heures plus
> tard. A toi de voir...
C'est tout vu, merci
bpasc...@googlemail.com
Je trouve le code très simple. J'ai déjà fait cet exercice il y a 2 ou
3 mois. Dans ma démarche d'autodidacte, j'étais arrivé au chapitre des
pointeurs, dans ce groupe fr.comp.lang.c ou comp.lang.c on m'a
fortement conseillé de coder avec des fonctions que je déclare et
appellent et j'ai décidé de faire une révision pour mieux approcher
les algorithmes avec les pointeurs même si j'avais déjà commencé. Je
pense que les fonctions des bibliothèques pourraient dépanner mais
pour apprendre je ne pense pas qu'aller trop vite est intéressant pour
la suite. C'est vrai qu'il y a des périodes ou je vais lentement.
C'est comme ça, c'est peut-être le changement de temps. C'est un autre
sujet, un autre groupe svp.
Pour reprendre le fil, ce code me paraît très carré càd plus que
cohérent et quand j'écris pour Ch1 : bon Ch2 jour, il ne se passe rien
alors que quand j'écris pour Ch1: jour et Ch2 : bonjour
???
Lucas Levrel
> Donc quand j'exécute le code avec par exemple : Ch1 = jour ... Ch2 =
> bonjour ... ça fonctionne, le "trouve!" de la condition if s'affiche.
> Cependant quand j'exécute avec Ch1 = bon ... Ch2 = bonjour ... rien
> ne s'affiche
Tu n'exécutes pas avec Ch1 = bon et Suj = bonjour, parce que ces chaînes
ne sont pas définies dans le source. Tu les entres au clavier. Donc tu
exécutes ce code, puis tu entres... quoi ? Pose-toi la question
précisément : que tapes-tu exactement sur le clavier ?
Essaye ça pour comparer :
#include <stdio.h>
int main(void)
{
char Suj[100]="bonjour" ;
char Ch1[40]="bon" ;
int i, j ;
int ok = 1 ;
for ( i = 0 ; ok && Suj[i] ; i++ )
{
if ( Suj[i] == Ch1[0] )
{
for ( j = 1 ; Ch1[j] && (Ch1[j] == Suj[i+j]) ; j++ )
;
if ( Ch1[j] == '\0' )
{
ok = 0 ;
printf("\ntrouve!") ;
}
}
}
printf("\n\n") ;
return 0 ;
}
--
LL
Marc Boyer
> On Dec 1, 7:26 pm, es...@lain.home (Marc Espie) wrote:
>> In article <06f71962-5c18-4279-aa5b-d70356bef...@e23g2000yqd.googlegroups.com>,
>> bpascal...@googlemail.com <bpascal...@googlemail.com> wrote:
>> >Je ne souhaite pas faire appel aux pointeurs et aux fonctions autres
>> >comme fflush car d'après le tutorial, ça n'est pas nécessaire.
>>
>> Mauvais tutoriel, changer de tutoriel.
>
> C'est un conseil ou un ordre?
On peut aller regarder le dit tutoriel, et après
10mn, le classer dans la longue liste des choses
trop approximatives pour être utilisable.
> http://www.ltam.lu/Tutoriel_Ansi_C/
Fabuleux.
Premier exemple: hello word:
#include <stdio.h>
main()
/* Notre premier programme en C */
{
printf("hello, world\n");
return 0;
}
Au paragraphe "3.1.1. Les types entiers", nous apprenons que les
int sont codés sur deux octets.
Le paragraphe "3.7.1. Les conversions de type automatiques" est un
régal en ce qui concerne les types non signés.
Mais bon...
Marc Boyer
--
En prenant aux 10% des francais les plus riches 12% de leurs revenus,
on pourrait doubler les revenus des 10% les plus pauvres.
http://www.inegalites.fr/spip.php?article1&id_mot=130
--
En prenant aux 10% des francais les plus riches 12% de leurs revenus,
on pourrait doubler les revenus des 10% les plus pauvres.
http://www.inegalites.fr/spip.php?article1&id_mot=130
Richard Delorme
> J'avoue passer beaucoup de temps sur ce code mais d'un point de vu
> me pencher dessus.
>
> Donc quand j'ex�cute le code avec par exemple : Ch1 = jour ... Ch2 =
> bonjour ... �a fonctionne, le "trouve!" de la condition if s'affiche.
> Cependant quand j'ex�cute avec Ch1 = bon ... Ch2 = bonjour ... rien
> ne s'affiche
[...]
> printf("\n\nEntrez la chaine a rech. Ch1 : ") ;
> fgets(Ch1, 40, stdin) ;
> printf("\nEntrez la chaine Sujet. : ") ;
> fgets(Suj, 80, stdin) ;
Dans le premier cas, tu compares "jour\n" et "bonjour\n", dans le second
"bon\n", et "bonjour\n". C'est le caract�re '\n' qui emp�che la seconde
comparaison de fonctionner.
--
Richard
Hamiral
> On Dec 1, 7:26 pm, es...@lain.home (Marc Espie) wrote:
>> In article <06f71962-5c18-4279-aa5b-d70356bef...@e23g2000yqd.googlegroups.com>,
>>
>> bpascal...@googlemail.com <bpascal...@googlemail.com> wrote:
>>> Je ne souhaite pas faire appel aux pointeurs et aux fonctions autres
>>> comme fflush car d'après le tutorial, ça n'est pas nécessaire.
>> Mauvais tutoriel, changer de tutoriel.
>
> C'est un conseil ou un ordre?
C'est vrai que ce tutoriel n'est pas beau. Il fait des suppositions sur
la plateforme et l'implémentation, en plus des erreurs basiques (la
fonction main déclarée simplement main() par exemple...). Je n'ai pas
regardé plus loin, mais tu devrais quand même suivre les conseils
(avisés) des personnes qui postent souvent ici (et ne sont donc pas des
charlots).
Essaye ici :
http://franckh.developpez.com/articles/c-ansi/bien-debuter-en-c/
Tu noteras que sur cette page tu trouves deux tutoriels écrits par
Emmanuel Delahaye, qui poste pas mal ici-même, ce qui peut aider...
Ham
Samuel Devulder
> Dans le premier cas, tu compares "jour\n" et "bonjour\n", dans le second
> "bon\n", et "bonjour\n". C'est le caract�re '\n' qui emp�che la seconde
> comparaison de fonctionner.
>
Bravo � toi et Lucas pour pointer le vrai pb du code de bpascal123.
Je me demande si bpascal123 a acc�s � un d�buggeur ligne � ligne? Avec
cet outil indispensable il aurait vite compris pourquoi son prog
semblait ne pas marcher comme il le voulait.
Finalement, le code est bon et le bug se situe entre l'interface
chaise-clavier.
sam.
bpasc...@googlemail.com
> Le 01/12/2009 17:56, bpascal...@googlemail.com a écrit :
>
> > J'avoue passer beaucoup de temps sur ce code mais d'un point de vu
> > me pencher dessus.
>
> > Donc quand j'exécute le code avec par exemple : Ch1 = jour ... Ch2 =
> > bonjour ... ça fonctionne, le "trouve!" de la condition if s'affiche.
> > Cependant quand j'exécute avec Ch1 = bon ... Ch2 = bonjour ... rien
> > ne s'affiche
>
> [...]
> > printf("\n\nEntrez la chaine a rech. Ch1 : ") ;
> > fgets(Ch1, 40, stdin) ;
> > printf("\nEntrez la chaine Sujet. : ") ;
> > fgets(Suj, 80, stdin) ;
>
> Dans le premier cas, tu compares "jour\n" et "bonjour\n", dans le second
> comparaison de fonctionner.
>
> --
> Richard
Réponse très explicite pour qui veut comprendre le manque de rigueur
sur mon code au niveau des E/S.
Merci aussi pour le distingo entre saisir une donnée et exécuter un
programme...
Au sujet des E/S, dans une autre discussion, il m'a été conseillé de
ne pas inclure '\n' à la fin de printf, ex. : "printf("\nBonsoir\n") ;
car le '\n' de fin est pris en compte dans le buffer pour le fgets
suivant.Par conséquent, je me suis mis à coder avec '\n' en début et
pas en fin : "printf("\nBonsoir") ; et ligne suivante (selon
l'affichage pour plus de clarté) printf("\n\n") afin d'éviter que le
'\n' de printf se répercute sur la prochaine saisie. Peine perdue,
j'avais oublié que la saisie côté utilisateur est également prise en
compte.
Parmi les réponses, une personne soutient que fflush est
indispensable. Je comprends que cette fonction agit comme on tire sur
une chasse d'eau, évacue tout ce qui se trouve en buffer. Il paraît
que ce n'est pas sans inconvénient.
Est-ce que tout simplement : while(getchar() != '\n') ne peut pas
suffire à cette situation?
J'arrête là, j'ai une grippe, certainement h1n1, ca sera la 2ème fois
donc je ne dois pas m'exprimer avec clarté ...demande votre
indulgence.
Pascal
bpasc...@googlemail.com
> Finalement, le code est bon et le bug se situe entre l'interface
> chaise-clavier.
>
> sam.
exact
Marc Espie
bpasc...@googlemail.com <bpasc...@googlemail.com> wrote:
>Parmi les r�ponses, une personne soutient que fflush est
>indispensable. Je comprends que cette fonction agit comme on tire sur
>que ce n'est pas sans inconv�nient.
>
>Est-ce que tout simplement : while(getchar() != '\n') ne peut pas
Tu te melanges les pinceaux entre l'entree standard et la sortie standard.
Celles-ci ne sont absolument pas liees, en particulier les tampons
correspondants n'ont aucun rapport !
Que tu mettes ou non des '\n' sur stdout (donc dans printf) tu ne les
reverras pas dans l'entree standard (en particulier pas dans getchar()).
Le fflush(stdout), c'est juste pour t'assurer que tu verras bien ton
message si tu n'as pas mis de '\n' au bout, avant de demander une entree
a l'utilisateur. Ca peut tomber en marche sans le fflush sur ton
implementation, mais ca fait du code qui "ne marche pas vraiment", alors
que c'est facile de faire portable. Reflexe:
printf() suivi d'une entree -> fflush au milieu.
(une des raisons pour lesquelles ca peut marcher, c'est que ce petit detail
a ete ameliore en C++, ou le langage explicite un lien entre cin et cout,
qui fait que ce genre de probleme ne s'y produit plus.
Si ton compilateur "partage" sa bibliotheque entre C et C++, il se peut
que les programmeurs aient garde ce lien. Il n'est pas *necessaire* en C,
mais il n'est pas *interdit* non plus.)
Antoine Leca
> Au sujet des E/S, dans une autre discussion, il m'a �t� conseill� de
> ne pas inclure '\n' � la fin de printf, ex. : "printf("\nBonsoir\n") ;
> car le '\n' de fin est pris en compte dans le buffer pour le fgets
> suivant.
Soit le conseil est mauvais, soit tu as mal compris.
En fait, et le guide que tu as cit� (pour ce que j'en ai vu) suit cette
m�me voie, il vaut mieux utiliser syst�matiquement \n � la fin de chaque
groupe �mis ; pas forc�ment chaque appel � printf(), mais s�rement avant
de passer � autre chose comme par exemple attendre d'autres donn�es de
la part de l'utilisateur.
> Parmi les r�ponses, une personne soutient que fflush est
> indispensable.
L� encore, il me semble que tu interpr�tes incorrectement. J'ai lu au
moins trois personnes soutenir que fflush() doit �tre syst�matiquement
utilis� _quand il n'y a pas de \n � la fin du format de printf_.
> Je comprends que cette fonction agit comme on tire sur
> une chasse d'eau, �vacue tout ce qui se trouve en buffer. Il para�t
> que ce n'est pas sans inconv�nient.
Peux-tu approfondir cette id�e ?
> Est-ce que tout simplement : while(getchar() != '\n') ne peut pas
> suffire � cette situation?
getchar() agit sur les donn�es entr�es ; printf() sur les donn�es
�mises. Il n'y a pas de lien (pour ce qui concerne le C) entre les deux.
Le fait que les caract�res puissent t'appara�tre m�lang�s � l'�cran est
d� � une interf�rence de ton syst�me, qui duplique sur l'�cran tous les
caract�res que tu tapes. Mais ce n'est pas obligatoire, c'est juste plus
pratique dans la plupart des cas, c'est donc pour cela que c'est la
situation par d�faut quand tu travailles avec une ligne de commandes.
Soignes toi bien.
Antoine
bpasc...@googlemail.com
C'est en anglais, ça vient des personnes qui postent fréquemement sur
comp.lang.c ;
You mean getchar rather than the second while. The trouble with using
fflush(stdin) is that it is not portable. Some systems provide it as
an extension but even if it is permitted, how can you be sure it does
what you want?
...
In fact the behavior of fflush(stdin) is undefined. Some
implementations define useful behavior for it, but in general it
should be avoided.
Apparemment d'après ce qui est dit fflush n'est pas toujours la
solution qu'on veut.
Mes connaissances et expériences sont très limitées à ce sujet (je
n'ai pas encore vu fflush dans un exercice) et peut-être ça relève du
détail pour un débutant...
> > Est-ce que tout simplement : while(getchar() != '\n') ne peut pas
> > suffire à cette situation?
>
> getchar() agit sur les données entrées ; printf() sur les données
> émises. Il n'y a pas de lien (pour ce qui concerne le C) entre les deux.
> Le fait que les caractères puissent t'apparaître mélangés à l'écran est
> dû à une interférence de ton système, qui duplique sur l'écran tous les
> caractères que tu tapes. Mais ce n'est pas obligatoire, c'est juste plus
> pratique dans la plupart des cas, c'est donc pour cela que c'est la
> situation par défaut quand tu travailles avec une ligne de commandes.
En fait, je voulais comparer fflush et le vidage du tampon avec getchar
(). Je ne sais pas si c'est ça que tu as expliqué.
> Soignes toi bien.
Merci
> Antoine
MErci pour votre aide,
Pascal
Alexandre Bacquart
>> Peux-tu approfondir cette id�e ?
>
> C'est en anglais, �a vient des personnes qui postent fr�quemement sur
> comp.lang.c ;
>
> You mean getchar rather than the second while. The trouble with using
> fflush(stdin) is that it is not portable. Some systems provide it as
> an extension but even if it is permitted, how can you be sure it does
> what you want?
> ...
> In fact the behavior of fflush(stdin) is undefined. Some
> implementations define useful behavior for it, but in general it
> should be avoided.
>
> solution qu'on veut.
Tu t'es m�lang� les pinceaux. Quand on parlait de fflush(), on voulait
parler de fflush(stdout) (et non pas fflush(stdin) qui a effectivement
un comportement ind�fini).
--
Alex
Antoine Leca
>> Peux-tu approfondir cette idï¿œe ?
>
> ...
> In fact the behavior of fflush(stdin) is undefined. Some
> implementations define useful behavior for it,
Oui, bonne remarque.
> but in general it should be avoided.
Lￜ je suis moins d'accord : si cela marche pour ton implￜmentation,
pourquoi s'en priver ?
Mais bon, c'est dans la ligne de comp.lang.c
> Apparemment d'aprï¿œs ce qui est dit fflush n'est pas toujours la
> solution qu'on veut.
Avec stdin (ou plus gï¿œnï¿œralement un flux entrant) : effectivement,
fflush() ne fait pas toujours ce que l'on veut.
Mais on parlait de flux sortants et en particulier de la sortie normale
(stdout), ou du moins c'est ce que j'avais compris.
> En fait, je voulais comparer fflush et le vidage du tampon avec getchar
> (). Je ne sais pas si c'est ￜa que tu as expliquￜ.
Pas exactement ; mais c'est bien le sujet dont parle les commentaires en
anglais : en effet, fflush() est destinￜ aux sorties, pas aux entrￜes ;
et penser que fflush(stdin) va vider le tampon est un mirage de la
symï¿œtrie apparente (mais pas rï¿œelle) des entrï¿œes-sorties en C : parfois
cela marche, parfois non, donc il faut faire trï¿œs attention.
Le reste de mon message reste d'actualitￜ.
Antoine
-ed-
<bpascal...@googlemail.com> wrote:
> Au sujet des E/S, dans une autre discussion, il m'a été conseillé de
> ne pas inclure '\n' à la fin de printf, ex. : "printf("\nBonsoir\n") ;
Absurde. Qui a bien pu de dire ça ? Tu es sûr que tu as bien compris
ce qu'on t'a dit ?
> car le '\n' de fin est pris en compte dans le buffer pour le fgets
> suivant.
Délirant ! Il n'y a aucune interaction entre le '\n' en sortie et le
'\n' en entrée !
> Par conséquent, je me suis mis à coder avec '\n' en début et
> pas en fin : "printf("\nBonsoir") ;
C'est mal. Le '\n' doit être placé à la fin de la ligne, car c'est
la ... marque de fin de ligne ! De plus, ça permet à printf() de se
comporter correctement et d'une manière portable (les caractères sont
sortis immédiatement). Sinon, on doit ajouter fflush(stdout) pour que
l'effet soit le même.
http://www.bien-programmer.fr/notes.php#fflush_stdout
> et ligne suivante (selon
> l'affichage pour plus de clarté) printf("\n\n") afin d'éviter que le
> '\n' de printf se répercute sur la prochaine saisie. Peine perdue,
> j'avais oublié que la saisie côté utilisateur est également prise en
> compte.
encore une fois, le '\n' en sortie n'affecte pas la saisie.
Par contre, et c'est peut être ça qui te trouble, tous les caractères
saisis avec fgets() sont 'échoisés' (echoed). En clair, il sont
reproduits sur l'interface de sortie (ecran, fenêtre de console,
télétype etc.) pour pouvoir savoir ce qu'on saisie et éventuellement,
le corriger, comme sur tout entrée interactive). Donc, quand on valide
la saisie avec la touche [ENTER], on entre un '\n' et celui-ci est
affiché, d'où un saut de ligne après la saisie.
Mais encore une fois, pour cet exercice, il est inutile de perdre du
temps à essayer de saisir du texte correctement (les bonnes méthodes
ont déjà été expliquées 3000 fois fgets(), + fclean(), à fonction
maison à chercher sur le site du zéro ...). Il suffit de travailler
avec 2 chaines initialisées. Ça suffit amplement pour coder et surtout
tester l'algorithme. De plus, tu aurais du indiquer quel est le
comportement attendu, car nous, on a pas l'énoncé. Le code n'est pas
la doc...
>
> Parmi les réponses, une personne soutient que fflush est
> indispensable. Je comprends que cette fonction agit comme on tire sur
> une chasse d'eau, évacue tout ce qui se trouve en buffer. Il paraît
> que ce n'est pas sans inconvénient.
Voir le lien ci dessus pour le rôle de fflush().
> Est-ce que tout simplement : while(getchar() != '\n') ne peut pas
> suffire à cette situation?
Aucun rapport avec fflush(stdout). Tu mélanges entrée et sortie...
getchar() concerne stdin...
> J'arrête là, j'ai une grippe, certainement h1n1, ca sera la 2ème fois
Impossible (ou alors, c'est une mutation, donc pas H1N1).
-ed-
<bpascal...@googlemail.com> wrote:
> > Peux-tu approfondir cette idée ?
>
> C'est en anglais, ça vient des personnes qui postent fréquemement sur
> comp.lang.c ;
>
> You mean getchar rather than the second while. The trouble with using
> fflush(stdin) is that it is not portable. Some systems provide it as
> an extension but even if it is permitted, how can you be sure it does
> what you want?
Personne ici n'a parlé d'utiliser fflush (stdin), pour les raison
évoquées dans cet article. Ce n'est pas défini par le langage C et le
comportement est donc indéfini.
Ne pas confondre fflush (stdout) qui force la sortie et qui est
parfaitement défini et portable, avec fflush (stdin) qui n'existe pas
vu du C standard (même si certains systèmes supporte cette extension
pour 'vider le flux stdin'). Effectivement, l'alternative portable (et
donc recommandée) est d'utiliser correctement getchar(), par exemple
(la fameuse fonction 'maison' ou 'communautaire' fclean() évoquée plus
haut).
bpasc...@googlemail.com
Cette question très simple est peut-être à vos yeux loin d'être
compliquée.
Je suis aussi en convalescence de grippe, ça devait pas être h1n1 mais
une grippe reste fatiguante...
En fait, personne n'a évoqué l'emploi de scanf et avec scanf j'obtiens
le bon résultat ???
Merci,
Pascal
Alexandre Bacquart
> En fait, personne n'a �voqu� l'emploi de scanf et avec scanf j'obtiens
> le bon r�sultat ???
L'ennui avec scanf, c'est qu'au d�but, on trouve toujours �a vachement
pratique et on se demande pourquoi personne n'en avait parl� avant.
Dans les faits, un programmeur C exp�riment� l'�voque rarement pour
faire de la saisie, voire pas du tout (� part le K&R mais bon, ce
bouquin n'est pas un programmeur C exp�riment�). C'est toujours le
d�butant qui d�barque avec...
Je te conseille vivement de fuir scanf() comme la peste (surtout que
t'as pas encore entam� les pointeurs), m�me si �a semble marcher pour
l'instant. Pour faire court, scanf() est le pendant de printf() et n'a
un comportement acceptable qu'avec des sorties de printf() redirig�es
sur scanf() (par exemple, la sortie stdout d'un programme vers l'entr�e
stdin d'un autre). Dans ce cas, c'est pratique, car on peut avoir les
m�mes arguments pour les deux, cha�nes de format compris. C'est un peu
comme une interface machine-machine quoi... mais cot� saisie
utilisateur, si tu tiens � tes cheveux, fuis !
Si tu n'es pas convaincu, alors ceci devrait t'aider le jour o� tu auras
un p�pin avec cette horreur :
http://xrenault.developpez.com/tutoriels/c/scanf/
--
Alex
Marc Espie
>http://xrenault.developpez.com/tutoriels/c/scanf/
Pour en remettre une couche dans le meme sens.
Je trouve que le plus souvent, l'apprentissage de scanf est une perte
de temps. A part au tout debut, pour permettre aux gens de rentrer des
nombres dans leurs programmes, des qu'on veut faire des trucs un peu
compliques, les particularites de scanf sont complexes a retenir pour
des resultats somme toutes peu interessants. Cote valeurs numeriques, je
joue le plus souvent avec strtod ou strtoul. Et cote chaines, soit ca se
fait a la main, soit j'aurai tres vite besoin d'un vrai moteur de regexps,
ou d'un bon vieux lex/yacc des familles.
bpasc...@googlemail.com
Suite à un autre post que j'ai intitulé "bricolage pour blabla", au
sujet de cette discussion, je pense avoir trouvé une solution
temporaire mais qui en tant que débutant me satisfait. Dans le sens ou
je n'ai pas besoin d'aller chercher des fonctions getchar() et fflush
stdin.
Voilà donc le code que je poste ici aussi surtout pour mémoire (pour
le retrouver sur usenet, c'est plus facile que sur mon dd) à moins
qu'une personne avec expérience me déconseille fortement de prendre
l'habitude de ce genre de bricolage. Mais je le répète, dès que je
progresse et trouve quelque chose plus complet, j'apprendrais alors à
m'en servir. En attendant, je fais avec les moyens du bord.
/*
*Ecrire un programme qui supprime la première occurrence
*d'une chaîne de caractères OBJ dans une chaîne de caractères SUJ.
*
*/
#include <stdio.h>
int main(void)
{
char Suj[50] ;
char Obj[30] ;
int i, j ;
int OK ;
int cnt1, cnt2 ;
printf("\n\nEntrez une chaine de caractere Suj : ") ;
fgets(Suj, 50, stdin) ;
printf("\nEntrez une chaine de caractere Obj : ") ;
fgets(Obj, 30, stdin) ;
/* Manip pour enlever '\n' si par exemple j
on entre pour sujet "bonjour" et pour obj "bon"
ds ce cas ca ne marche (en l'absence des 2
boucles qui suivent) pas alors que si on entre
"bon" au lieu de "jour" ça fonctionne...
*/
for ( i = 0 ; Suj[i] ; i++)
;
i = i - 1 ;
Suj[i] = '\0' ;
for ( i = 0 ; Obj[i] ; i++ )
;
i-- ;
Obj[i] = '\0' ;
OK = 0 ;
for ( i = 0 ; Suj[i] && !OK ; i++ )
if ( Suj[i] == Obj[0] )
{
for ( j = 1 ; Obj[j] && Suj[i+j] ; j++ )
;
if ( Obj[j] == '\0' )
OK = 1 ;
}
if ( OK )
{
i-- ;
for ( ; Suj[i+j] ; i++ )
Suj[i] = Suj[i+j] ;
Suj[i] = '\0' ;
}
printf("\nNvelle chaine : %s", Suj) ;
printf("\n\n") ;
return 0 ;
}
Pascal
bpasc...@googlemail.com
> Le 01/12/2009 17:56, bpascal...@googlemail.com a écrit :
>
> > me pencher dessus.
>
> > Donc quand j'exécute le code avec par exemple : Ch1 = jour ... Ch2 =
> > bonjour ... ça fonctionne, le "trouve!" de la condition if s'affiche.
> > Cependant quand j'exécute avec Ch1 = bon ... Ch2 = bonjour ... rien
> > ne s'affiche
>
> [...]
> > printf("\n\nEntrez la chaine a rech. Ch1 : ") ;
> > fgets(Ch1, 40, stdin) ;
> > printf("\nEntrez la chaine Sujet. : ") ;
> > fgets(Suj, 80, stdin) ;
>
> Dans le premier cas, tu compares "jour\n" et "bonjour\n", dans le second
> comparaison de fonctionner.
>
> --
> Richard
Ta réponse simple et concise m'a beaucoup donné à réfléchir et aidé à
trouver une réponse à mon problème peut-être temporaire mais qui me
convient en tant que débutant.
Merci
-ed-
<bpascal...@googlemail.com> wrote:
> printf("\n\nEntrez une chaine de caractere Suj : ") ;
> fgets(Suj, 50, stdin) ;
>
> printf("\nEntrez une chaine de caractere Obj : ") ;
> fgets(Obj, 30, stdin) ;
>
> /* Manip pour enlever '\n' si par exemple j
> on entre pour sujet "bonjour" et pour obj "bon"
> ds ce cas ca ne marche (en l'absence des 2
> boucles qui suivent) pas alors que si on entre
> "bon" au lieu de "jour" ça fonctionne...
> */
>
> for ( i = 0 ; Suj[i] ; i++)
> ;
> i = i - 1 ;
> Suj[i] = '\0' ;
>
> for ( i = 0 ; Obj[i] ; i++ )
> ;
> i-- ;
> Obj[i] = '\0' ;
Tu es désespérant. J'ai déjà donné (dans l'autre post) la manière
correcte de faire ce travail, et tu continues ton bricolage infâme...
Je ne sais plus quoi faire pour t'aider si tu ne tiens pas compte des
conseils qui te feront progresser, et pas rester dans ta condition
d'éternel débutant...
Samuel Devulder
> /* Manip pour enlever '\n' si par exemple j
> on entre pour sujet "bonjour" et pour obj "bon"
> ds ce cas ca ne marche (en l'absence des 2
> boucles qui suivent) pas alors que si on entre
> "bon" au lieu de "jour" �a fonctionne...
> */
>
> for ( i = 0 ; Suj[i] ; i++)
> ;
> i = i - 1 ;
> Suj[i] = '\0' ;
Tu fais des choses implicitement. Tu supposes que ta cha�ne se termine
en '\n\0'... C'est pas bon. Si tu veux faire un truc pr�cis, alors �cris
quelque chose de pr�cis.
Dans la cas pr�sent tu ne veut faire qu'une chose: couper ta cha�ne au
1er '\n' rencontr�. Dans ce cas, explicitement il te faut un test sur
'\n' quelque part. Si tu ne compares rien � '\n' ton code fera autre
chose que tu crois si ce que tu suppose ne se produit pas.
L'avantage d'�crire dans le code ce que tu veux faire plut�t que de
l'�crire dans le commentaire, c'est que tu coup le commentaire est quasi
inutile et ton code assez facilement d�buggable sans se prendre la t�te
� se demander comment on passe du commentaire au code. Il faut garder
les choses simples simple (c'est la m�thode KISS, Keep It Simple,
Stupid).
Dans certain langage on consid�re qu'un beau code se passe de
commentaire et se lit naturellement comme un texte. Les smalltalkistes
me comprendrons, les autres pardonnez mon abus, mais il y a de l'id�e:
si tu a l'intention de virer le '\n', alors fait un code qui vire le
'\n' et pas un code qui vire l'avant dernier caract�re de la cha�ne
accompagn� d'un commentaire disant que tu fais cela pour virer le '\n'
final, ce qui est juste faux si justement la cha�ne ne se termine pas
sur un '\n'.
Ca donnerait le code suivant qui je trouve est beaucoup plus clair et
n'a pas besoin d'un commentaire expliquant une manip de sioux pour un
truc finalement tr�s simple:
for(i=0; Suj[i]!='\0' && Suj[i]!='\n';) ++i;
Suj[i] = '\0';
Note: si la chaine ne contient pas de '\n', on �crit '\0' l� ou il y en
a d�j� un. C'est pas grave! En l'occurence le mieux est l'ennemi du
bien: si au lieu de Suj[i] = '\0' on avait �crit:
if(Suj[i] != '\0') Suj[i] = '\0';
On aurait inutilement alourdit le code sans changer son fonctionnement.
Toujours m�thode KISS: pourquoi faire compliqu� quand le truc simple
marche! Les bugs sont plus facilement visible sur un code simple qu'un
code compliqu�.
Une autre possibilit� est de faire un if dans la boucle for:
for(i=0; Suj[i]; ++i)
if(Suj[i]=='\n') {Suj[i] = '\0'; break;}
Si on aime pas le break, alors on peut �tre plus royaliste que le roi:
for(i=0; Suj[i];)
if(Suj[i]=='\n') Suj[i] = '\0'; else ++i;
En utilisant le fait que puisqu'on vient d'ecrire '\0' sur Suj[i], alors
on sortira forc�ment de la boucle si on incr�mente pas i. D'o� passage
du "++i" dans la partie "else".
Mais bon vu qu'on fait du C, le royaume du pointeur, l'�criture qui me
semble la plus naturelle pour faire ce que tu veux faire est celle-ci:
// on couple Suj au 1er '\n':
{char *s = Suj; while(*s && *s!='\n') ++s; *s = 0;}
C'est petit (1 ligne), pr�cis (ca fait exactement ce qu'on veut),
localis� (pas d'index d�clar� super loin et utilis� � deux endroit du
code: ici le pointeur s sert uniquement au d�coupage et n'est pas
visible ailleurs) et extensible (si on veut couper au 1er '\r' ou ' ' ce
coup ci).
Parfois c'est bien d'utiliser les tableaux surtout si on doit jouer avec
des i+1/i+2/i-1/i+j-1/etc, mais ici comme one ne fait qu'utiliser Suj[i]
ou Suj[j], je pense que les pointeurs sont plus indiqu�s. Mais c'est
purement une question de go�t.
Note: J'aime pas Suj[i] on dirait du pascal.. beurk. Si on veut faire du
C sans pointeur autant franchement apprendre un autre langage. Le gars
qui se pr�sente � moi en pr�tendant faire du C sans savoir manipuler et
utiliser les pointeurs il ne va pas faire illusion longtemps.
Au final l'id�e en utilisant les pointeur est aussi d'all�ger le code de
sorte � ce qu'il soit petit (en tout cas pas inutilement long: on est
pas pay� � la ligne), pr�cis (il fait *exactement* ce qu'on veut, et
localis� (il ne faut pas �tre envahissant, c'est plus simple pour
r�organiser le code par la suite).
Ensuite si tu t'aper�ois que tu as deux codes similaires qui font la
m�me chose (l'un sur Suj et l'autre sur Obj), et bien c'est signe qu'il
te faut une proc�dure ou une fonction. Dans un code �l�gant, on ne
r�p�te jamais deux fois le m�me traitement. On utilise une
fonction/proc�dure � la place!
Bon j'esp�re que ces quelques conseils te seront utile.
sam.
Marc Boyer
>
> Note: J'aime pas Suj[i] on dirait du pascal.. beurk. Si on veut faire du
> C sans pointeur autant franchement apprendre un autre langage. Le gars
On peut connaitre les pointeurs et vouloir que la syntaxe corresponde
à la sémantique et pas à la tambouille.
T'ecris *(i+Suj) ?
Personnellement, j'écris toujours
f(int[])
quand la sémantique est celle d'un tableau et
f(int*)
quand c'est un pointeur sur un int isolé.
Pareil, j'utilise NULL pour initialiser mes pointeurs,
et '\0' pour mes fins de chaine de caractères, alors que
0 irait aussi bien.
Senhon
"Samuel Devulder" <samuel-do...@geensys.com> a �crit dans le message
de groupe de discussion : 4b28e9ba$0$30517$426a...@news.free.fr...
> bpasc...@googlemail.com a �crit :
>
>
> Note: J'aime pas Suj[i] on dirait du pascal.. beurk. Si on veut faire du C
> sans pointeur autant franchement apprendre un autre langage. Le gars qui
> se pr�sente � moi en pr�tendant faire du C sans savoir manipuler et
> utiliser les pointeurs il ne va pas faire illusion longtemps.
Je suis � 110% d'accord avec toi, le C sans les pointeurs ce se serait
tristouille.
>
> Bon j'esp�re que ces quelques conseils te seront utile.
Oui, a n'en pas douter, aujourd'hui il a appris un puissant outil.
Bon ... Il a un peu tendance � tout m�langer, le langage, le syst�me,
google, l'assembleur, l'algorithme,... mais l� avec les pointeurs, il va
nous faire un feu d'artifice en 4D.
Samuel Devulder
> Le 16-12-2009, Samuel Devulder <samuel-do...@geensys.com> a écrit :
>> Note: J'aime pas Suj[i] on dirait du pascal.. beurk. Si on veut faire du
>> C sans pointeur autant franchement apprendre un autre langage. Le gars
>> qui se présente à moi en prétendant faire du C sans savoir manipuler et
>> utiliser les pointeurs il ne va pas faire illusion longtemps.
>
> On peut connaitre les pointeurs et vouloir que la syntaxe corresponde
> à la sémantique et pas à la tambouille.
> T'ecris *(i+Suj) ?
Perso les pointeurs c'est *s.. si on doit jouer avec *(s+machin) autant
écrire s[machin]. Mais bon ya pas de règle, il faut que ce soit simple.
Pas la peine de jouer des pointeurs (lire rouler des mécaniques) pour
montrer qu'on s'y connait. Idéalement j'utilise s[machin] quand s ne
bouge pas et *s quand on a du s++ ou du s += machin autour. En gros les
pointeurs quand on utilise le tableau (ou zone mémoire) localement et
tableau[machin] quand le tableau est vu comme une entité globale.
Mais bon pas de regles strictes en la matière, c'est une affaire de gout
tout ca.
> Personnellement, j'écris toujours
> f(int[])
> quand la sémantique est celle d'un tableau et
> f(int*)
> quand c'est un pointeur sur un int isolé.
Ca dépends.. Moi je passe "une adresse" de début de tableau (je suis
proche de l'ASM il est vrai). Je préfère volontiers le int *, mais tu as
raison que le int[] peut être utilisé. Les gouts et les couleurs...
sam.
-ed-
wrote:
> Moi je passe "une adresse" de début de tableau (je suis
> proche de l'ASM il est vrai). Je préfère volontiers le int *, mais tu as
> raison que le int[] peut être utilisé. Les gouts et les couleurs...
Techniquement, c'est pas "l'adresse du début de tableau" qu'on passe
(le type serait faux), mais "l'adresse du premier élément à traiter".
Je suis d'accord avec Marc. Je pense aussi qu'utiliser T tab[] au lieu
de T *tab est plus clair et nous rappelle qu'on a bel et bien affaire
à un tableau, et non à un élément simple (T *p).