Université de Savoie, UFR SFA INFO523

L3 INFO 2013–2014

TD 1, tableaux, fonctions, en C

On rappelle que int getchar() lit un caractère sur l’entrée standard, où EOF à la fin du fichier.
Inversement, la fonction int putchar(int) écrit un caractère sur la sortie standard, et retourne EOF
seulement si une erreur s’est produite.
L’exemple suivant ne fait que recopier l’entré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 précédent pour qu’il n’y ait pas l’affectation dans le test de boucle.

Exercice 2 : Lecture ligne à ligne

Pour simplifier, on va dire que chaque ligne ne dépasse 256 octets. En C, on définira donc une
constante NBCHARMAX ainsi:

#define NBCHARMAX 256

On va écrire une fonction qui lira une ligne complète de l’entrée pour la mettre dans un tableau de
caractère (mémoire TAMPON). La chaı̂ne mémorisée ne contiendra pas le caractère fin de ligne (’\n’)
mais bien le caractère fin de chaı̂ne (’\0’).

#include <stdio.h>
#include <string.h>

#define NBCHARMAX 256

/* Retourne EOF si la lecture sur l’entré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 caractères puis la chaine de caractères.
printf( "%d : %s\n", strlen( tampon ), tampon );
}
return 0;
}

Exercice 3 : Codes ascii et chiffrement de César

Les caractères sont codés par des entiers en C, par défaut sous forme d’un codage ASCII (Main-
tenant, cela peut être plus évolué genre iso-latin-1 ou UTF8). Pour obtenir l’entier codant un caractère,
rien de plus simple en C : il suffit de placer le caractère entre apostrophes. Dans tous les systèmes de
codage, les lettres latines sont consécutives de ’a’ à ’z’ et de ’A’ à ’Z’.
Ecrivez maintenant une fonction qui prend en entrée une chaı̂ne de caractères et la modifie pour
qu’elle contienne maintenant son chiffrement de César. On rappelle que le chiffrement de César décalait
de 13 lettres chaque caractère: a 7→ n, b 7→ o, . . . , z 7→ m. L’avantage de ce chiffrement est que pour
le déchiffrer il suffit de faire la même opé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 caractères

Ecrivez maintenant une fonction qui élimine un caractère donné en paramètre d’une chaı̂ne de
caractères données en entrée. La chaı̂ne de caractères peut donc être modifié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 caractères. Ecrire la fonction qui recherche l’index de la premier
caractère dans s1 où on trouve la chaı̂ne s2, -1 si s2 n’est pas un facteur de s1. On donnera aussi un
indice de départ dans s1.

2
 S’en servir pour faire l’équivalent de la commande unix grep, qui retourne toutes les lignes où elle
trouve l’occurence de la chaı̂ne donnée. Par exemple:

moi@machine$ cat td1.tex | grep fonction

standard, où EOF à la fin du fichier. Inversement, la fonction
On va écrire une fonction qui lira une ligne complète de l’entrée pour
Ecrivez maintenant une fonction qui prend en entrée une cha^ ıne de
Ecrivez maintenant une fonction qui élimine un caractère donné en
Soient $s1$ et $s2$ deux cha^ ınes de caractères. Ecrire la fonction qui
moi@machine$

Est-ce selon vous une façon efficace de rechercher une sous-chaı̂ne ? Des idées ?

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

On se donnera une structure Token pour stocker le mot courant, puis on é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 excéder 256 caractères.