TD 1

Université de Savoie, UFR SFA INFO523
L3 INFO 2013–2014
TD 1, tableaux, fonctions, en C
On rappelle que int getchar() lit un caractère sur l’entrée standard, où EOF à la fin du fichier.
Inversement, la fonction int putchar(int) écrit un caractère sur la sortie standard, et retourne EOF
seulement si une erreur s’est produite.
L’exemple suivant ne fait que recopier l’entrée sur la sortie.
#include <stdio.h>
int main()
{
int c;
int error = 0;
while ( ( c = getchar() ) != EOF )
{
if ( putchar( c ) == EOF )
{
error = 1;
break;
}
}
return error;
}
Exercice 1 : Recopie (v2)

Modifiez le code précédent pour qu’il n’y ait pas l’affectation dans le test de boucle.
Exercice 2 : Lecture ligne à ligne

Pour simplifier, on va dire que chaque ligne ne dépasse 256 octets. En C, on définira donc une
constante NBCHARMAX ainsi:
#define NBCHARMAX 256
On va écrire une fonction qui lira une ligne complète de l’entrée pour la mettre dans un tableau de
caractère (mémoire TAMPON). La chaı̂ne mémorisée ne contiendra pas le caractère fin de ligne (’\n’)
mais bien le caractère fin de chaı̂ne (’\0’).
#include <stdio.h>
#include <string.h>
#define NBCHARMAX 256
/* Retourne EOF si la lecture sur l’entrée standard est finie, 0 sinon. */

int lit_ligne( char tampon[] )
{
... // a completer
}
int main()
1
{
char tampon[ NBCHARMAX + 1 ];
while ( lit_ligne( tampon ) != EOF )
{
// Affiche le nombre de caractères puis la chaine de caractères.
printf( "%d : %s\n", strlen( tampon ), tampon );
}
return 0;
}
Exercice 3 : Codes ascii et chiffrement de César

Les caractères sont codés par des entiers en C, par défaut sous forme d’un codage ASCII (Main-
tenant, cela peut être plus évolué genre iso-latin-1 ou UTF8). Pour obtenir l’entier codant un caractère,
rien de plus simple en C : il suffit de placer le caractère entre apostrophes. Dans tous les systèmes de
codage, les lettres latines sont consécutives de ’a’ à ’z’ et de ’A’ à ’Z’.
Ecrivez maintenant une fonction qui prend en entrée une chaı̂ne de caractères et la modifie pour
qu’elle contienne maintenant son chiffrement de César. On rappelle que le chiffrement de César décalait
de 13 lettres chaque caractère: a 7→ n, b 7→ o, . . . , z 7→ m. L’avantage de ce chiffrement est que pour
le déchiffrer il suffit de faire la même opération.
#include <stdio.h>
#include <string.h>
int lit_ligne( char tampon[] ) ...
void cesar( char tampon[] )

{
... // a completer
}
int main()
{
char tampon[ NBCHARMAX + 1 ];
while ( lit_ligne( tampon ) != EOF )
{
cesar( tampon );
puts( tampon ); // affiche la chaine chiffree
}
return 0;
}
Exercice 4 : Elimination de caractères

Ecrivez maintenant une fonction qui élimine un caractère donné en paramètre d’une chaı̂ne de
caractères données en entrée. La chaı̂ne de caractères peut donc être modifiée (raccourcie).
int supprime_car( char tampon[], char supp_c )

{ ... }
Exercice 5 : Recherche d’une sous-chaı̂ne

Soient s1 et s2 deux chaı̂nes de caractères. Ecrire la fonction qui recherche l’index de la premier
caractère dans s1 où on trouve la chaı̂ne s2, -1 si s2 n’est pas un facteur de s1. On donnera aussi un
indice de départ dans s1.
2
S’en servir pour faire l’équivalent de la commande unix grep, qui retourne toutes les lignes où elle
trouve l’occurence de la chaı̂ne donnée. Par exemple:
moi@machine$ cat td1.tex | grep fonction

standard, où EOF à la fin du fichier. Inversement, la fonction
On va écrire une fonction qui lira une ligne complète de l’entrée pour
Ecrivez maintenant une fonction qui prend en entrée une cha^ ıne de
Ecrivez maintenant une fonction qui élimine un caractère donné en
Soient $s1$ et $s2$ deux cha^ ınes de caractères. Ecrire la fonction qui
moi@machine$
Est-ce selon vous une façon efficace de rechercher une sous-chaı̂ne ? Des idées ?
Exercice 6 : Découpage d’une chaı̂ne en mots (Tokenizer)

On se donnera une structure Token pour stocker le mot courant, puis on écrira cinq fonctions pour
manipuler les Token. Elles auront pour prototypes:
void Token_init( Token* t, char* str, char delim );

char* Token_valeur( Token* t);
bool Token_fini( Token* t);
void Token_suivant( Token* t);
void Token_termine( Token* t);
Ainsi le programme suivant
#include "Token.h"
int main()
{
char s[] = "Nous irons tous au paradis";
Token tok;
Token_init( &tok, s, ’ ’ );
for( ; ! Token_fini( &tok ); Token_suivant( &tok ) )
printf( "%s\n", Token_valeur( &tok ) );
Token_termine( &tok );
}
affichera:
Nous
irons
tous
au
paradis
Dans tout cet exercice, on supposera qu’un Token ne peut excéder 256 caractères.

TD 1

Transféré par

Droits d'auteur :

Formats disponibles

TD 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TD 1

Transféré par

Droits d'auteur :

Formats disponibles

Université de Savoie, UFR SFA INFO523

Exercice 1 : Recopie (v2)

Exercice 2 : Lecture ligne à ligne

#define NBCHARMAX 256

#define NBCHARMAX 256

/* Retourne EOF si la lecture sur l’entrée standard est finie, 0 sinon. */

Exercice 3 : Codes ascii et chiffrement de César

int lit_ligne( char tampon[] ) ...

void cesar( char tampon[] )

Exercice 4 : Elimination de caractères

int supprime_car( char tampon[], char supp_c )

Exercice 5 : Recherche d’une sous-chaı̂ne

moi@machine$ cat td1.tex | grep fonction

Exercice 6 : Découpage d’une chaı̂ne en mots (Tokenizer)

void Token_init( Token* t, char* str, char delim );

Ainsi le programme suivant

Vous aimerez peut-être aussi