CORRIGE DES EXERCICES

Chapitre 1
Exercice 1.1.
#include <stdio.h>
int main(void)
{int c,c1; c = c1 = 0;
while (( c = getchar()) != EOF )
/* test pour introduire les espaces séparateurs de mots, */
/* c1 mémorise le caractère de la saisie précédente */
{if (c1 ==' ' && c != ' ') printf(" ");
c1 = c;
if (c != ' ' && c != '\n' ) printf("%c",c);
}
}
// le fichier donnée est le fichier source
#include <stdio.h>int main(void) {int c,c1; c = c1 = 0;while (( c = getchar()) != EOF )/* test
pour introduire les blancs séparateurs de mots *//* c1 conserve le caractère de la saisie
précédente */ { if (c1 ==' ' && c != ' ') printf(" "); c1 = c;if (c != '' && c != '\n') printf("%c",c);
}}
Exercice 1.2
#include <stdio.h>
int main(void)
{int c ;
while (( c = getchar()) != EOF )
{if ( c == '\t') {printf("-");printf("\b>\n");}
if ( c == '\b') {printf("<");printf("\b-\n");}
}
}
Exercice 1.3
#include <stdio.h>
/* saisie d'un fichier texte */
/* mise d'un mot par ligne */
/* c : caractère courant */
int main(void)
{int c ;
while (( c = getchar()) != EOF )
{if (c != ' ') putchar(c);
else {while (c==' '); /* boucle sur les espaces */
putchar(' ');
}
}
// le fichier données est le fichier source
#include
<stdio.h>
/*
saisie
etc...

Chapitre 2
Exercice 2.1
#include <stdio.h>
#define MASQ 0001
int main(void)
{unsigned x,y,z = 0;
printf("\n\t saisie des données\n");
scanf("%d %d",&x,&y);
printf(" x = %d y = %d\n",x,y);
while (y != 0)
{if ((y & MASQ) != 0)
{printf("\n y impair");
z += x;
y--;
printf(" x = %d y = %d\n", x,y);
}
else
{printf("\n y pair");
y >>=1; /* y -> y/2 */
x <<=1; /* x -> x*2 */
printf(" x = %d y = %d\n", x,y);
}
}
printf(" \n résultat final ");
printf(" x = %d y = %d",x,y);
 printf(" \n z = %d",z);
}
// résultat
saisie des données
x = 12 y = 8
y pair x = 24 y = 4
y pair x = 48 y = 2
y pair x = 96 y = 1
y impair x = 96 y = 0
résultat final x = 96 y = 0
z = 96
Exercice 2.2
int main(void) /*comptage du nombre de bits à 1 d'un nombre entier */
{unsigned n;
printf("\n valeur du nombre : ");
scanf("%u",&n); /* saisie de n en format unsigned */
printf("\n nombre de bits à 1 de %d : %d \n",n,bitcount(n));
}
bitcount(unsigned i)
{int b; /* compteur */
for ( b = 0; i != 0; i >>= 1 ) /* décalage droite de 1 bit */
if ( i & 01) b++; /* et logique sur le dernier bit */
return(b);
}
// résultat
valeur du nombre : 15
nombre de bits à 1 de 15 : 4
Exercice 2.3
/* extraction à droite de n bits a partir du bit p */
/* du nombre entier x, le bit 0 est le bit le plus a droite */
#include <stdio.h>
int main(void)
{unsigned x, n, p;
printf("\n\t valeur du nombre x : " );
scanf("%d",&x);
printf("\n\t position : ");scanf("%d",&p);
printf("\n\t nombre de bits de droite : ");
scanf("%d",&n);
printf("\n\n\t résultat %x ", getbit(x,p,n));
}
int getbit(unsigned x,unsigned p,unsigned n)
{return ((x >> (p+1-n)) & ~(~0 << n));}
/* explication : */
/* >>(x >> (p+1-n)) */
/* décalage vers la droite de x */
/* (non(0) << n) */
/* création d'un masque 1111--100 */
/* non(non(0) << n) */
/* création du masque 0000--011 */
// résultats
valeur du nombre x : 63
position : 4
nombre de bits de droite : 2
résultat 3

Chapitre 3
Exercice 3.1
#include <stdio.h>
#define YES 1
#define NO 0
int main(void)
/* Comptage du nombre de lignes, de mots, de caractères du fichier d'entrée standard */
{int c,nl,nmot,ncar,dansmot;
dansmot = NO; nl = nmot = ncar = 0 ;
while ((c = getchar()) != EOF )
{++ ncar;
if ( c == '\n' ) ++ nl;
if ( c == ' ' || c == '\n' || c == '\t') dansmot= NO;
else if (dansmot == NO) {dansmot = YES; ++nmot; }
}
printf("nombre de lignes : %d \nnombre de mots : %d ncar %d\n", nl, nmot, ncar);
}
// le fichier données est le fichier source
nombre de lignes : 18
nombre de mots : 106 ncar 518
Exercice 3.2
#include <stdio.h>
int main(void)
{/* initialisation */
int c,i,lettre, autre;
int chiffre[10];
lettre = autre = 0;
for(i = 0; i < 10; ++i) chiffre[i] = 0;
while ((c = getchar()) != EOF)
/* traitement des chiffres */
if( c >= '0' && c <= '9') ++chiffre[c-'0'];
/* traitement des caractères spéciaux */
else
if (c == ' ' || c == '\n' || c == '\t') ++lettre; else ++autre;
printf("nombre de chiffres :");
for(i = 0;i <10;++i) printf(" %d",chiffre[i]);
printf("\nespaces blancs = %d,autres = %d\n",lettre, autre);
}
// le fichier données est le fichier source
nombre de chiffres : 9 3 0 0 0 0 0 0 0 1
espaces blancs = 85, autres = 387
Exercice 3.3
int main(void)
/* programme d'affichage des années bissextiles*/
{int annee;
printf("\n liste des années bissextiles\n");
for (annee = 1000; annee < 2001; annee++)
if ( annee % 4 == 0 && annee % 100 != 0 || annee % 400 == 0)
printf("%d ",annee);
}
// résultats
liste des années bissextiles
1004 1008 1012 1016 1020 1024 1028 1032 1036 1040 1044 1048 1052 1056
....
1984 1988 1992 1996 2000
Exercice 3.4 : histogramme des caractères d'un fichier
#define TAILLE 37
#define NLETTRES 26
#define NCHIFFRES 10
#include <stdio.h>
int main(void)
{/* définitions et initialisations */
int c, i, j ,k , tab[TAILLE] , somme =0;
float total = 0., pour = 0.;
for(i = 0 ; i < TAILLE ; i++) tab[i] = 0;
/* saisie des variables */
while((c = getchar()) !=EOF)
{
/* remplissage du tableau (lettres) */
if( (( c>= 'A') && (c <= 'Z')) ||
(( c>= 'a') && (c <= 'z')) ) tab[(c-'A') %32 ] ++;
else /* chiffres */
if ( (c>= '0') && (c <= '9')) tab[(c -'0')+NLETTRES]++;
else tab[TAILLE-1]++; /* divers */
} /* fin de la saisie */
/* calcul de l'effectif total */
for(i = 0; i < TAILLE;i++) somme += tab[i];
printf("somme = %d\n",somme);
/* affichage des résultats */
for(i = 0; i < NLETTRES;i++) /* boucle sur les lettres */
{
printf( " %c ", i+'A');
pour = (float)tab[i] /(float) somme; /* sommation des pourcentages */
total += pour;
k = (int) ( 100 * pour);
for (j = 0; j < k ; j++) printf("x");
printf("\n");
}
for(i = NLETTRES; i < NLETTRES+NCHIFFRES; i++) /* boucle sur les chiffres */
{printf( " %c ", i+'0' - NLETTRES);
pour = (float)tab[i] /(float) somme;
total += pour;
k = (int) ( 100 * pour);
or (j = 0; j < k ; j++) printf("x");
printf("\n");
}
printf( " divers %s ");
pour = (float) tab[TAILLE-1] /(float) somme ;
total += pour;
k = (int) (100 * pour) ;
for (j = 0; j < k ; j++) printf("x");
printf("\n");
printf(" pourcentage traité : %6.2f\n", 100 * total);
return(1);
}
// le fichier de données est le fichier source
somme = 1545
A xxx
B
C x
D x
E xxxx
F xxx
G
H
I xxxxx
J
K
L xxx
M x
N xx
O xxx
P x
Q
R xxx
S xxx
T xxxxx
U x
V
W
X
Y
Z
0 x
1
2
3
4
5
6
7
8
9
divers xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
pourcentage traité : 100.00
Exercice 3.5
#include <stdio.h>
#define MAX 25
int main(void)
{int c , i , j, nl ,n =0 , effec[MAX];
float fr[MAX];
/* MAX nombre maximum de caractères par mot */
/* nl nombre de lettres par mot */
/* c caractère courant */
/* effec : tableau des effectifs */
/* n nombre de caractères pris en compte */
/* dans les effectifs */
/* initialisation */
c = nl = 0;
for (i = 0; i < MAX; i++) effec[i] = 0; fr[i] = 0.; }
/* constitution du tableau des effectifs */
while (( c = getchar()) != EOF)
{if ( c != ' ') nl++; /* on est dans un mot ? */
else
{if (nl > 0 && nl <= MAX )
{effec[nl-1]++;
n++;
nl = 0;
}
else if (nl != 0 )
{ printf(" erreur : nl = %d\n",nl);nl =0;}
}
}
if ( n == 0) exit();
/* calcul de la fréquence d'apparition de chacune des occurrences */
for ( i = 0; i < MAX; i++) fr[i] = (float) effec[i] / n;
/* impression du tableau des effectifs */
printf("\n\t tableau des effectifs\n");
for (i =0; i < MAX; i++) printf("ef[%2d] = %d\t ",i,effec[i]);
/* tableau des pourcentages */
printf("\n\t tableau des pourcentages \n");
for (i =0; i < MAX; i++) printf("pr[%2d] = %4.2f\t ",i,fr[i]);
/* tracé de l'histogramme */
printf("\n\n\n\t tracé de l'histogramme\n");
for ( i = 0; i < MAX; i++)
{printf("%4d ",i);
for (j = 0;j < (int)100*fr[i]; j++) printf("*");
printf("\n");
}
}
// le fichier données est le fichier source
tableau des effectifs
ef[ 0] = 59 ef[ 1] = 41 ef[ 2] = 25 ef[ 3] = 10
ef[ 4] = 14 ef[ 5] = 9 ef[ 6] = 13 ef[ 7] = 4
ef[ 8] = 11 ef[ 9] = 5 ef[10] = 2 ef[11] = 6
ef[12] = 2 ef[13] = 2 ef[14] = 1 ef[15] = 3
ef[16] = 1 ef[17] = 2 ef[18] = 0 ef[19] = 4
ef[20] = 0 ef[21] = 0 ef[22] = 1 ef[23] = 0
ef[24] = 0
tableau des pourcentages
pr[ 0] = 0.27 pr[ 1] = 0.19 pr[ 2] = 0.12 pr[ 3] = 0.05
pr[ 4] = 0.07 pr[ 5] = 0.04 pr[ 6] = 0.06 pr[ 7] = 0.02
pr[ 8] = 0.05 pr[ 9] = 0.02 pr[10] = 0.01 pr[11] = 0.03
pr[12] = 0.01 pr[13] = 0.01 pr[14] = 0.00 pr[15] = 0.01
pr[16] = 0.00 pr[17] = 0.01 pr[18] = 0.00 pr[19] = 0.02
pr[20] = 0.00 pr[21] = 0.00 pr[22] = 0.00 pr[23] = 0.0
pr[24] = 0.00
tracé de l'histogramme
0 ****************************
1 ********************
2 ************
3 *****
4 *******
5 *****
6 *******
7 **
8 ******
9 ***
10 *
11 ***
12 *
13 *
14 *
15 **
16 *
17 *
18
19 **
20
21
22 *
23
24
Exercice 3.6
#include <stdio.h>
int main(void) /* test de l 'instruction case */
{int c, i, ndigit[10];
long nbseparateur, nchar;
nbseparateur = nchar = 0;
/* affectation multiple */
for ( i = 0; i < 10; i++) ndigit[i] = 0;
while ((c = getchar()) != EOF)
switch(c)
{/* test sur les chaînes numériques */
/* et comptage du nombre d'occurrences */
case '0' :
case '1' :
case '2' :
case '3' :
case '4' :
case '5' :
case '6' :
case '7' :
case '8' :
case '9' : ndigit[c - '0']++; break;
/* '0' fournit le code ASCII de 0 */
/* c fournit le code ASCII de c */
/* La différence fournit l'indice */
/* dans le tableau */
/* cas particuliers : blancs, */
/* nouvelle ligne, tabulation */
case ' ':
case '\t ':
case '\n ': nbseparateur++; break;
/* autres cas */
default : nchar++;
break;
}
printf(" tableau des chiffres = ");
for(i = 0; i < 10; i++) printf(" %d ",ndigit[i]);
printf("\nespaces blancs : %ld, caractères %ld\n", nbseparateur, nchar);
}
// le fichier donnée est le fichier source
tableau des chiffres = 9 4 1 1 1 1 1 1 1 1
espaces blancs : 120, caractères 699

Chapitre 5
Exercice 5.2 : La fonction 91 est définie de la façon suivante :
f(n) = n - 10 si n  100
f(n) = f(f(n+11)), 0  n 100
Quand n est supérieur à 100, il n'y a pas de problème.
Dans le cas où n est inférieur ou égal à 100, l'appel de fonction est doublement récursif.
Toutefois, il est possible de calculer cette fonction très simplement.
On a sur l'intervalle ]89,100]
89  n  100  100  n+11 111
 f(n+11) = n+11-10 = n+1
 f(n) = f(f(n+11)) = f(n+1) = constante
Le calcul est alors évident : on choisit n = 100 et on obtient :
f(n) = f(100) = f(101) = 101 - 10 = 91
Sur l'intervalle ]78,89], on a :
78  n  89  89  n+11  100  f(n+11) = 91
 f(n) = f(f(n+11)) = f(91) = 91
On procède ainsi de proche en proche sur les intervalles ]67,78], ]56,67], etc...
Le programme est le suivant :
#include <stdio.h>
int main(void ) /* fonction quatre vingt onze */
{int i;
for (i=0; i < 5;i++)
printf("\n valeur de n : %d f(n) = %d\n",i,f(i));
return(1);
}
f(int n)
{if ( n > 100) return(n-10);
printf("n = %d ",n);
return(f(f(n+11)));
}
// résultats
n = 0 n = 11 n = 22 n = 33 n = 44 n = 55 n = 66 n = 77 n = 88 n = 99
n = 100 n = 91 n = 92 n = 93 n = 94 n = 95 n = 96 n = 97 n = 98 n = 99
...
n = 100 n = 91 n = 92 n = 93 n = 94 n = 95 n = 96 n = 97 n = 98 n = 99
n = 100
valeur de n : 0 f(n) = 91
n = 1 n = 12 n = 23 n = 34 n = 45 n = 56 n = 67 n = 78 n = 89 n = 100
n = 91 n = 92 n = 93 n = 94 n = 95 n = 96 n = 97 n = 98 n = 99 n = 100
...
 n = 91 n = 92 n = 93 n = 94 n = 95 n = 96 n = 97 n = 98 n = 99 n = 100
valeur de n : 1 f(n) = 91
La suite est identique...
Exercice 5.3
#include <stdio.h>
int main(void)
/* passage par valeur */
{char chaine[100]; int c;
void squezze(char [], int ); /* prototype */
c = getchar();
printf("\n caractère à supprimer dans la chaîne %c\n",c);
printf("\n\t\t saisir la chaîne\n");
scanf("\n %s",chaine);
printf("\n\t chaîne saisie : %s\n",chaine);
squezze(chaine,c);
return(1);
}
void squezze(char s[], int c)
{int i,j;
for (i=j=0;s[i] != '\0';i++) if(s[i] != c) s[j++] = s[i];
s[j] = '\0';
printf("\n nouvelle chaine %s \nfin du travail",s);
}
// le fichier données est le fichier source
caractère à supprimer dans la chaîne #
saisir la chaîne
chaîne saisie : #include
nouvelle chaîne include
fin du travail
Exercice 5.4
#include <stdio.h>
#define LONG 100
int main(void)
{char chaine[LONG];
void reverse(char []); /* prototype */
printf("\n\t saisir la chaîne : ");
scanf("%s",chaine);
reverse(chaine);
return(1);
}
void reverse(char s[]) /* fonction inverse d'une chaîne de caractères */
{int c, i ,j;
int strlen(char []);
for ( i = 0, j = strlen(s)-1; i<j; i++, j--)
{c = s[i]; s[i] = s[j]; s[j] = c;}
printf("\n\t résultat\n chaîne inverse : %s",s);
}
strlen(char s[])
{int i;
i = 0;
while(s[i] != '\0') i++;
return(i);
}
// le fichier de données est le fichier source
saisir la chaîne :
résultat
chaîne inverse : edulcni#
Exercice 5.5
#include <stdio.h>
int main(void)
{char chaine[100];
int atoi(char chaine[]); /* prototype */
printf("\n\t\t saisir la chaîne\n");
scanf("\n %s",chaine);
printf("\n\t chaîne saisie : %s",chaine);
printf("\n\t conversion entière %d", atoi(chaine));
return(1);
}
atoi(char s[]) /* fonction de conversion entière de la chaîne s */
{int i,n = 0;
for( i= 0; s[i] >='0' && s[i] <= '9'; ++i)
n = 10 *n + s[i] - '0';
return(n);
}
// le fichier de données est le fichier source
saisir la chaîne
chaîne saisie : main(void)
conversion entière 0
Exercice 5.6
#include <stdio.h>
#define MAXLINE 1000
char line[MAXLINE];
char save[MAXLINE];
int maximum;
int main(void) /* recherche de la ligne la plus longue d'un fichier */
{int len;
extern int maximum;
extern char save[];
int getline(void);
void copy(void);
maximum = 0;
while (( len = getline()) > 0)
if (len > maximum)
{ maximum = len; copy();}
if(maximum >0) printf("%s",save);
return(1);
}
int getline(void) /* définition de getline */
{int c,i;
extern char line[];
for (i = 0; i < MAXLINE -1 && (c = getchar()) != EOF && c !='\n';++i) line[i] = c;
if ( c == '\n') {line[i] = c;++i;}
line[i] = '\0';
return(i);
}
void copy(void)
{int i;
extern char line[] , save [];
i = 0;
while ((save[i] = line [i]) != '\0') ++i;
}
// le fichier données est le fichier source
/* recherche de la ligne la plus longue d'un fichier */
Exercice 5.7
/* transmission des arguments d'un tableau par valeur */
/* en réalité, c'est quand même une transmission par adresse */
#define TAILLE 50
int main(void)
{int tab[TAILLE];
int i;
void modif(int []);
for(i=0;i<TAILLE;i++) tab[i] = i ;
printf("tableau initial\n");
for(i=0;i<TAILLE;i++) printf("%d %c", tab[i], ((i%10 == 0) || (i == TAILLE-1)) ? '\n ': ' ');
modif(tab);
printf("tableau modifié\n");
for(i=0;i<TAILLE;i++) printf("%d %c", tab[i], ((i%10 == 0) || (i == TAILLE-1)) ? '\n ': ' ');
return(1);
}
void modif(int a[])
{int i;
for(i= 0; i < TAILLE;i++) a[i] = 2*i;
}
// résultat
tableau initial
0
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
tableau modifié
0
2 4 6 8 10 12 14 16 18 20
22 24 26 28 30 32 34 36 38 40
42 44 46 48 50 52 54 56 58 60
62 64 66 68 70 72 74 76 78 80
82 84 86 88 90 92 94 96 98
Exercice 5.8 somme partielle des composantes d'un tableau.
#define TAILLE 10
int main(void)
{
/* prototypes des fonctions utilisées */
float somme (float [],int);
float sommec(float (*) [],int);
float sommeb(float *, int );
float tab[TAILLE];
int i , p;
/* initialisation */
for (i = 0; i < TAILLE; i++) tab[i] = (float) i ;
printf("&tab %x tab = %x *tab=%6.2f *&tab=%6.2f\n", &tab, tab, *tab, *&tab);
/* calcul à partir de tab[0] seulement */
printf("\nfonction somme\n");
for (i = 0; i < TAILLE; i++) printf(" somme = %6.2f\n",somme(tab,i));
/* impression des adresses et contenus */
for (i = 0 ; i < TAILLE; i++)
printf("&tab[%d]=%x *&tab[%d]=%6.2f\n", i, &tab[i], i , *&tab[i]);
for (i = 0; i < TAILLE ; i++)
{p = TAILLE-i;
printf("somme partielle = %6.2f\n", somme(tab,p));
/*: exercice: pourquoi est-ce faux ?
printf("somme partielle = %6.2f\n", somme(tab[i],p));
*/
}
/* résultat exact mais programmation lourde */
printf("\nfonction sommec\n");
for (i = 0; i < TAILLE ; i++)
{p = TAILLE-i;
printf("somme partielle = %6.2f\n", sommec(&tab[i],p));
/* exercice: pourquoi est-ce faux?
printf("somme partielle = %6.2f\n", sommec(tab[i],p));
*/
}
/* résultat exact et programmation élégante */
printf("\nfonction sommec\n");
for (i =0; i < TAILLE; i++)
{ p = TAILLE-i;
printf("somme partielle = %6.2f\n", sommec((tab+i),p));
}
/* résultat exact et programmation élégante */
printf("\nfonction sommeb\n");
for (i =0; i < TAILLE; i++)
{ p = TAILLE-i;
printf("somme partielle = %6.2f\n", sommeb((tab+i),p));
/*
exercice: pourquoi est-ce faux?
printf("somme partielle = %6.2f\n", sommeb((tab[i],p));
*/
}
return(1);
}
float somme (float tableau[], int n)
{ int i; float aux = 0. ;
for (i = 0; i < n ; i++) aux += tableau[i];
return aux;
}
float sommeb (float *tableau, int n)
{ int i; float aux = 0.;
for (i = 0; i < n; i++) aux += tableau[i];
return aux;
}
float sommec (float (*tableau)[], int n)
{ int i; float aux = 0.;
for (i = 0; i < n; i++) aux += (*tableau)[i];
return aux;
}
// résultats
&tab ffba tab = ffba *tab= 0.00 *&tab= 0.00
fonction somme
somme = 0.00
somme = 0.00
somme = 1.00
somme = 3.00
somme = 6.00
somme = 10.00
somme = 15.00
somme = 21.00
somme = 28.00
somme = 36.00
&tab[0]=ffba *&tab[0]= 0.00
&tab[1]=ffbe *&tab[1]= 1.00
&tab[2]=ffc2 *&tab[2]= 2.00
&tab[3]=ffc6 *&tab[3]= 3.00
&tab[4]=ffca *&tab[4]= 4.00
&tab[5]=ffce *&tab[5]= 5.00
&tab[6]=ffd2 *&tab[6]= 6.00
&tab[7]=ffd6 *&tab[7]= 7.00
&tab[8]=ffda *&tab[8]= 8.00
&tab[9]=ffde *&tab[9]= 9.00
somme partielle = 45.00
somme partielle = 36.00
somme partielle = 28.00
somme partielle = 21.00
somme partielle = 15.00
somme partielle = 10.00
somme partielle = 6.00
somme partielle = 3.00
somme partielle = 1.00
somme partielle = 0.00
fonction sommec
somme partielle = 45.00
somme partielle = 45.00
somme partielle = 44.00
somme partielle = 42.00
somme partielle = 39.00
somme partielle = 35.00
somme partielle = 30.00
somme partielle = 24.00
somme partielle = 17.00
somme partielle = 9.00
fonction sommec
somme partielle = 45.00
somme partielle = 45.00
somme partielle = 44.00
somme partielle = 42.00
somme partielle = 39.00
somme partielle = 35.00
somme partielle = 30.00
somme partielle = 24.00
somme partielle = 17.00
somme partielle = 9.00
fonction sommeb
somme partielle = 45.00
somme partielle = 45.00
somme partielle = 44.00
somme partielle = 42.00
somme partielle = 39.00
somme partielle = 35.00
somme partielle = 30.00
somme partielle = 24.00
somme partielle = 17.00
somme partielle = 9.00
Exercice 5.9
Version tableau
#include <stdio.h>
#define TAILLE 300
int main(void) /* copie de chaîne première version*/
{int i;
void strcopy(char [],char []);
char copie[TAILLE], chaine[TAILLE];
char *pchaine = "bonjour";
/* remplissage de la chaîne initiale */
for(i=0;*pchaine !='\0';chaine[i++]=*pchaine++);
chaine[i] = '\0';
printf("\n longueur de la chaîne initiale : %d",i);
printf("\n chaîne initiale %s ",chaine);
strcopy(chaine,copie); /* copie effective */
printf("\n chaîne initiale %s copie %s ", chaine,copie);
return(1);
}
void strcopy(char s[],char t[])
{int i = 0;
while (( t[i] = s[i] ) != '\0') i++;
printf("\n chaîne initiale %s",s);
printf("\n copie %s ",t);
}
// résultat
longueur de la chaîne initiale : 7
chaîne initiale bonjour
chaîne initiale bonjour
copie bonjour
chaîne initiale bonjour copie bonjour
Version pointeur
#include <stdio.h>
#define TAILLE 300
int main(void) /* copie de chaîne première version */
{int i;
void strcopy(char [],char []);
...idem cas précédent
return(1);
}
void strcopy(const char *s,char *t)
{while (( *t++ = *s++ ) != '\0'); }
// résultat
longueur de la chaîne initiale : 7
chaîne initiale bonjour
chaîne initiale bonjour copie bonjour
Version pointeurs et test simplifié
#include <stdio.h>
#define TAILLE 300
int main(void)
{int i;
void strcopy(const char *, char *);
...idem cas précédent
return(1);
}
void strcopy(const char *s, char *t)
/* le test est réduit à sa plus simple expression */
{ while (*t++ = *s++); }
// résultat
longueur de la chaîne initiale : 7
chaîne initiale bonjour
chaîne initiale bonjour copie bonjour
Exercice 5.10
Version tableau
#include <stdio.h>
#define LON 500
int main(void)
/* concaténation de deux chaînes de caractères */
/* le résultat est dans chaine2 */
/* première version utilisant un tableau */
{char chaine1[LON],chaine2[LON];
void strcat(char [],char []);
printf("\t programme de concaténation de chaîne\n");
printf("\t saisir dans l'ordre chaine1, chaine2\n");
scanf("\n %s",chaine1);
scanf("\n %s",chaine2);
strcat(chaine1,chaine2);
return(1);
}
void strcat(char s[],char t[])
{int i,j;
i = j = 0;
while (s[i] != '\0') i++;
/* lecture de la première chaîne */
while ((s[i++] = t[j++]) != '\0');
/* remplissage de la première chaîne avec la deuxième */
printf("\n chaîne totale %s ",s);
}
// le fichier données est le fichier source
programme de concaténation de chaîne
saisir dans l'ordre chaine1,chaine2
chaîne totale #include"stdio.h"
Version pointeur
#include <stdio.h>
#define LON 500
int main(void)
/* concaténation de deux chaînes de caractères résultat dans chaine2 */
{char chaine1[LON],chaine2[LON];
void strcat(char *, char *);
...idem cas précédent
return(1);
}
void strcat(char *s, char *t)
{while (*s != '\0') s++; /* lecture de la première chaîne */
while ((*s++ = *t++) != '\0');
/* remplissage de la première chaîne avec la deuxième */
}
// le fichier données est le fichier source
programme de concaténation de chaîne
saisir dans l'ordre chaine1,chaine2
chaine1 = #include
chaine2 = "stdio.h"
chaîne totale #include<stdio.h>
Exercice 5.11
#define SIZE 4
#define TAILLE 3
int main(void)
{ int tab[TAILLE][SIZE] ;
int i, j , (*pt[TAILLE])[] , (*aux)[];
/* pt est un tableau de pointeurs sur des tableaux d'entiers */
/* initialisation */
for ( i = 0; i < TAILLE ; i++)
{
pt[i] = &tab[i];
for(j = 0 ; j < SIZE ; j++)
tab[i][j] = SIZE*i+j;
}
/* impression */
for(i = 0 ; i < TAILLE ; i++)
{
printf(" &tab[%d] = %x ",i, &tab[i]);
printf(" pt[%d] = %x\n", i , pt[i]);
for(j = 0 ; j < SIZE ; j++)
{ printf(" tab[%d][%d] = %d", i, j , tab[i][j]);
printf(" (*pt[%d])[%d] = %d\n", i ,j , (*pt[i])[j]);
}
printf("\n");
}
/* modification du tableau pt */
 aux = pt[0] ;
pt[0] = pt[2] ;
pt[2] = aux;
/* impression du résultat */
for(i = 0 ; i < TAILLE ; i++)
{
printf(" &tab[%d] = %x ",i, &tab[i]);
printf(" pt[%d] = %x\n", i , pt[i]);
for(j = 0 ; j < SIZE ; j++)
{ printf(" tab[%d][%d] = %d", i, j , tab[i][j]);
printf(" (*pt[%d])[%d] = %d\n", i ,j , (*pt[i])[j]);
}
printf("\n");
}
return(1);
}
// résultat
&tab[0] = ffd4 pt[0] = ffd4
tab[0][0] = 0 (*pt[0])[0] = 0
tab[0][1] = 1 (*pt[0])[1] = 1
tab[0][2] = 2 (*pt[0])[2] = 2
tab[0][3] = 3 (*pt[0])[3] = 3
&tab[1] = ffdc pt[1] = ffdc
tab[1][0] = 4 (*pt[1])[0] = 4
tab[1][1] = 5 (*pt[1])[1] = 5
tab[1][2] = 6 (*pt[1])[2] = 6
tab[1][3] = 7 (*pt[1])[3] = 7
&tab[2] = ffe4 pt[2] = ffe4
tab[2][0] = 8 (*pt[2])[0] = 8
tab[2][1] = 9 (*pt[2])[1] = 9
tab[2][2] = 10 (*pt[2])[2] = 10
tab[2][3] = 11 (*pt[2])[3] = 11
&tab[0] = ffd4 pt[0] = ffe4
tab[0][0] = 0 (*pt[0])[0] = 8
tab[0][1] = 1 (*pt[0])[1] = 9
tab[0][2] = 2 (*pt[0])[2] = 10
tab[0][3] = 3 (*pt[0])[3] = 11
&tab[1] = ffdc pt[1] = ffdc
tab[1][0] = 4 (*pt[1])[0] = 4
tab[1][1] = 5 (*pt[1])[1] = 5
tab[1][2] = 6 (*pt[1])[2] = 6
tab[1][3] = 7 (*pt[1])[3] = 7
&tab[2] = ffe4 pt[2] = ffd4
tab[2][0] = 8 (*pt[2])[0] = 0
tab[2][1] = 9 (*pt[2])[1] = 1
tab[2][2] = 10 (*pt[2])[2] = 2
tab[2][3] = 11 (*pt[2])[3] = 3
Exercice 5.12 : tableaux multi-indices
int main(void){ int i, j, k, tab[5] = {0, 1}, tab2[5], tab5[2][3] = {0, 1, 2, 4, 5, 6} ;
int tab6[2][3][4] = { 1 , 2 , 3, 4 , 5 , 6, 7, 8 , 9, 10 ,11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24};
static int tab3[5] = {0, 1}, tab4[5];
/* intialisation globale pour tab */
for ( i = 0; i < 5; i++)
printf(" tab[ %d ] = %d ", i , tab[i]);
printf("\n");
/* initialisation par défaut fantaisiste pour tab2 */
for (i = 0 ; i < 5; i++)
printf(" tab2[ %d ] = %d ", i , tab2[i]);
printf("\n");
/* initialisation nulle par défaut */
for ( i = 0; i < 5; i++)
printf(" tab3[ %d ] = %d ", i , tab3[i]);
printf("\n");
/* initialisation nulle par défaut */
for ( i = 0; i < 5; i++)
printf(" tab4[ %d ] = %d ", i , tab4[i]);
printf("\n");
for ( i = 0 ; i < 2 ; i++)
{for( j = 0 ; j < 3; j++) printf("tab5[%d][%d] = %d",i,j,tab5[i][j]);
 printf("\n");
}
/* impression de tab6 */
for (i= 0 ; i < 2 ; i++)
for (j = 0 ; j< 3; j++)
{for( k = 0 ; k < 4 ; k++)
printf("tab6[%d][%d][%d]=%d",i,j,k,tab6[i][j][k]);
printf("\n");
}
return(1);
}
// résultat
tab[ 0 ] = 0 tab[ 1 ] = 1 tab[ 2 ] = 0 tab[ 3 ] = 0 tab[ 4 ] = 0
tab2[ 0 ] = 512 tab2[ 1 ] = 400 tab2[ 2 ] = 2060 tab2[ 3 ] = 5592 tab2[ 4 ] = 512
tab3[ 0 ] = 0 tab3[ 1 ] = 1 tab3[ 2 ] = 0 tab3[ 3 ] = 0 tab3[ 4 ] = 0
tab4[ 0 ] = 0 tab4[ 1 ] = 0 tab4[ 2 ] = 0 tab4[ 3 ] = 0 tab4[ 4 ] = 0
tab5[0][0] = 0 tab5[0][1] = 1 tab5[0][2] = 2
tab5[1][0] = 4 tab5[1][1] = 5 tab5[1][2] = 6
tab6[0][0][0]=1tab6[0][0][1]=2tab6[0][0][2]=3tab6[0][0][3]=4
tab6[0][1][0]=5tab6[0][1][1]=6tab6[0][1][2]=7tab6[0][1][3]=8
tab6[0][2][0]=9tab6[0][2][1]=10tab6[0][2][2]=11tab6[0][2][3]=12
tab6[1][0][0]=13tab6[1][0][1]=14tab6[1][0][2]=15tab6[1][0][3]=16
tab6[1][1][0]=17tab6[1][1][1]=18tab6[1][1][2]=19tab6[1][1][3]=20
tab6[1][2][0]=21tab6[1][2][1]=22tab6[1][2][2]=23tab6[1][2][3]=24
Exercice 5.13
#include <stdio.h>
#define MAXLINE 100
int main(int argc, char *argv[])
{char line[MAXLINE] , *s;
long lineno = 0;
int exept = 0, nombre = 0;
int index(char s[],char t[]); /* prototype */
int getline(char s[],int lim); /* prototype */
/* (*++argv)[0]) : *argv[0] est */
/* un pointeur sur une chaîne de caractères */
/* argv[0] est une chaîne de caractères */
/* (*argv)[0] pointe le premier caractère */
/* de la chaîne pointée */
/* *++argv incrémente le pointeur *argv */
while (--argc >0 && (*++argv)[0] == '-')
/* argv[0]+1 est le deuxième caractère pointé */
for (s = argv[0]+1; *s != '\0';s++)
switch (*s)
{case 'x' : exept = 1; break;
case 'n' : nombre = 1; break;
default : printf("find : option illégale %c\n",*s); argc = 0; break;
}
if (argc != 1) printf("Utilisation : find -x -n \n");
else
while (getline(line,MAXLINE) > 0 )
{lineno++;
if ((index(line,*argv) >=0) != exept)
{if (nombre) printf("%ld : ",lineno); printf("%s\n",line);}
}
return(1);
}
int getline(char s[],int lim)
{int c,i;
i = 0;
while (--lim > 0 && (c = getchar()) != EOF && c !='\n')
s[i++] = c;
if ( c == '\n' && c != EOF ) s[i++] = c;
s[i] = '\0';
return(i);
}
int index(char s[],char t[])
/* s : ligne courante */
/* t : chaîne de caractères recherchée */
{int i,j,k;
for(i=0; s[i] != '\0';i++)
{
for(j=i,k=0;t[k] !='\0' && s[j] == t[k]; j++,k++);
if(t[k] == '\0') return(i);
}
return(-1);
}
// résultat : le fichier de données est le fichier source
// où la chaîne recherchée est line
{char line[MAXLINE], *s;
long lineno = 0;
int getline(char s[],int lim);/* prototype */
while (getline(line,MAXLINE) > 0 )
{lineno++;
if ((index(line,*argv) >=0) != exept)
{if (nombre) printf("%ld : ",lineno);
printf("%s\n",line);
int getline(char s[],int lim)
// la chaîne recherchée avec l'option -n est inc
1 : #include <stdio.h>
Exercice 5.14
char op[]="+-*/%"; /* opérateurs autorisés */
/* définition des différentes fonctions */
double plus (float x,float y)
{return((double)x+(double)y);}
double moins(float x , float y)
{return((double)x-(double)y);}
double prod(float x, float y)
{return ((double)x * (double)y);}
double quot(float x, float y)
{return ((double)x / (double)y);}
double reste(float x, float y)
{return((double) ( (int) x % (int) y));}
/* f est un tableau de pointeurs sur les fonctions précédentes */
#include <stdio.h>
int main(void)
{/* initialisation du tableau f */
double plus(float, float), moins(float,float);
double prod(float,float), quot(float, float);
double reste (float,float);
double (*f[])(float,float)= {plus, moins, prod, quot ,reste};
float m = 0.,n = 0;
int i =0 ; /* indice dans le tableau f de la fonction recherchée */
int ind (char *, char); /* prototype */
char c = '\0'; /* opération à exécuter */
do
{printf("saisir dans l'ordre un nombre, un opérateur(+ - * / %), un nombre\n");
scanf("%f %c %f",&m,&c,&n);
printf("valeurs de saisie %6.2f %c %6.2f\n ",m,c,n);
fflush(stdin); /* vidage du tampon de saisie */
switch(c)
{case '+' :
case '-' :
case '*' :
case '/' :
case '%' : break;
default : printf("erreur de saisie\n");return(-1);
}
i = ind (op,c);
if(i == -1) {printf("erreur de saisie\n"); return(-1);}
printf("résultat : %6.2f\n",(*f[i])(m,n));
m = n =0.; c ='\0';
printf("nouvelle saisie ? (0/1)\n");
scanf("%d",&i);
}
while(i);
return(1);
}
int ind(char * chaine, char c) /* fonction de décodage de l'opérateur */
{int b =1, i = 0;
while(b && chaine[i]) b = chaine[i++] !=c;
/*
compte tenu des règles de priorité des opérateurs, cette expression est équivalente à
{if (chaine[i] != c) b = 1; else b = 0; i++; }
*/
/* exercice: cette expression peut-elle s'écrire :
if(chaine[i++] == c) b = 0 ;
*/
printf("b = %d i = %d\n",b,i);
return((b)?-1:i-1);
}
// résultat
saisir dans l'ordre un nombre, un opérateur(+ - * / %), un nombre
valeurs de saisie 4.00 * 6.30
b=0i=3
résultat : 25.20
nouvelle saisie ? (0/1)
saisir dans l'ordre un nombre, un opérateur(+ - * / %), un nombre
valeurs de saisie 6.00 % 3.60
b=0i=5
résultat : 0.00
nouvelle saisie ? (0/1)
saisir dans l'ordre un nombre, un opérateur(+ - * / %), un nombre
valeurs de saisie 7.00 / 5.23
b=0i=4
résultat : 1.34
nouvelle saisie ? (0/1)

Chapitre 6
Exercice 6.1 : hiérarchie des opérateurs *, ++, --,
#include <stdio.h>
int main(void)
{
int i = 16, j = 32, k = 64 , l = 128, m = 256, o = 512, p = 1024;
int x = 0;
int *pt =&p;
printf(" valeur d'initialisation\n");
printf(" i = %d",i);
printf(" &i = %x\n", &i);
printf(" j = %d &j = %x\n",j,&j);
printf(" k = %d &k = %x\n l = %d &l = %x\n",k,&k,l,&l);
printf(" m = %d &m = %x\n o = %d &o = %x\n",m,&m,o,&o);
printf(" p = %d &p = %x\n",p,&p);
printf(" \n\névaluation de pt\n");
printf(" i = %d *pt = %d pt = %x\n", i, *pt, pt);
*pt++; /* sémantique équivalente: *(pt++) */
printf("\n\n évaluation de *pt++\n");
printf(" *pt = %d pt = %x\n", *pt, pt);
(*pt)++; /* pt inchangé, contenu du pointeur modifié */
printf("\n\n évaluation de (*pt)++\n");
printf(" *pt = %d pt = %x\n", *pt, pt);
x=*(pt++); /* post-incrémentation: x = *pt; pt++ ; */
printf("\n\n évaluation de x = *(pt++)\n");
printf(" x =%d *pt = %d pt = %x\n", x, *pt, pt);
x=*pt++; /* post-incrémentation x = *pt; pt++ */
printf("\n\n évaluation de x = *pt++\n");
printf(" x =%d *pt = %d pt = %x\n", x, *pt, pt);
x=(*pt)++; /* x = *pt; (*pt)= (*pt)+1 ; */
printf("\n\n évaluation de x = (*pt)++\n");
printf(" x =%d *pt = %d pt = %x\n", x, *pt, pt);
x=*(++pt); /* pt++ ; x = *pt; */
printf("\n\n évaluation de x = *(++pt)\n");
printf(" x =%d *pt = %d pt = %x\n", x, *pt, pt);
pt = &p;
x=++*pt; /* x = *pt; pt++ */
printf("\n\n évaluation de x = ++*pt\n");
printf(" x =%d *pt = %d pt = %x\n", x, *pt, pt);
x=++(*pt); /* x = (*pt)+1 */
printf("\n\n évaluation de x = ++(*pt)\n");
printf(" x =%d *pt = %d pt = %x\n", x, *pt, pt);
pt = &l;
printf("\n\n évaluation de x = (*pt++)--\n");
x = (*pt++)--; /* x = (*p)++; p--; */
printf(" *pt = %d pt = %x\n", *pt, pt);
printf(" x = (*pt++)-- = %d\n",x);
(*pt++)--; /* Lvalue nécessaire */
printf("\n\n évaluation de (*pt++)--\n");
printf(" *pt = %d pt = %x\n", *pt, pt);
printf("\n\n évaluation de x = (*(pt++))--\n");
x = (*(pt++))--; /* pt++; x = *(pt--) */
printf(" *pt = %d pt = %x\n", *pt, pt);
printf(" x = (*(pt++))-- = %d\n",x);
return(1);
}
// résultat
valeur d'initialisation
i = 16 &i = fff2
j = 32 &j = fff0
k = 64 &k = ffee
l = 128 &l = ffec
m = 256 &m = ffea
o = 512 &o = ffe8
p = 1024 &p = ffe6
évaluation de pt
i = 16 *pt = 1024 pt = ffe6
évaluation de *pt++
*pt = 512 pt = ffe8
évaluation de (*pt)++
*pt = 513 pt = ffe8
évaluation de x = *(pt++)
x =513 *pt = 256 pt = ffea
évaluation de x = *pt++
x =256 *pt = 128 pt = ffec
évaluation de x = (*pt)++
x =128 *pt = 129 pt = ffec
évaluation de x = *(++pt)
x =64 *pt = 64 pt = ffee
évaluation de x = ++*pt
x =1025 *pt = 1025 pt = ffe6
évaluation de x = ++(*pt)
x =1026 *pt = 1026 pt = ffe6
évaluation de x = (*pt++)--
*pt = 64 pt = ffee
x = (*pt++)-- = 129
évaluation de (*pt++)--
*pt = 32 pt = fff0
évaluation de x = (*(pt++))--
*pt = 16 pt = fff2
x = (*(pt++))-- = 32
Exercice 6.2
#include <stdio.h>
#define TAILLE 5
struct intfloat {int entier; float flottant;} ;
int main(void)
{int i;
struct intfloat tableau[TAILLE];
void modifLvaleur(struct intfloat *, struct intfloat []);
void modifRvaleur(struct intfloat *, struct intfloat []);
void imprime(struct intfloat [], struct intfloat *);
/* initialisation */
for(i = 0; i < TAILLE ; i++)
{tableau[i].entier = 2*i; tableau[i].flottant = (float)(3*i+1);}
printf("Valeurs d'initialisation\n");
imprime (tableau,tableau);
modifLvaleur(tableau, tableau);
modifRvaleur(tableau, tableau);
return(0);
}
void modifLvaleur(struct intfloat *pt, struct intfloat tableau[])
{void imprime(struct intfloat [], struct intfloat *);
int i;
struct intfloat **pp = &pt;
printf("\nappel de modifLvaleur");
printf("\n\tpp = %x\t*pp = %x\n",pp, *pp);
printf("\neffet de ++pt ->entier");
++pt ->entier;/* incrémentation du champ entier */
imprime(tableau,pt);
printf("\neffet de i=(++pt) ->entier");
i=(++pt)->entier; /* post-incrémentation du pointeur pt */
imprime(tableau,pt);
printf("\ti= %d\n",i);
printf("\neffet de ++pt ->flottant"); /* incrémentation du champ flottant */
++pt ->flottant;
imprime(tableau,pt);
i=(pt++)->entier; /* post-incrémentation du pointeur pt */
printf("\neffet de i=(pt++) ->entier");
imprime(tableau,pt);
printf("\ti= %d\n",i);
i=pt++->entier; /* post-incrémentation du pointeur pt */
printf("\neffet de i=pt++->entier");
imprime(tableau,pt);
printf("\ti= %d\n",i);
printf("\n\t*pp = %x",*pp);
printf("\t(*pp)->flottant = %3.1f\n",(*pp)->flottant);
i=(*pp)->entier++; /* post-incrémentation du champ entier */
printf("\neffet de i=(*pp)->entier++");
imprime(tableau,*pp);
printf("\ti= %d\n",i);
i=(*pp)++->entier; /* post-incrémentation du pointeur *pp */
printf("\neffet de i=(*pp)++->entier");
imprime(tableau,*pp);
printf("\ti= %d\n",i);
i=(*pp++)->entier; /* post-incrémentation du pointeur pp */
printf("\neffet de i=(*pp++)->entier");
imprime(tableau,*pp);
printf("\ti= %d\n",i);
}
void modifRvaleur(struct intfloat *pt, struct intfloat tableau[])
{void imprime(struct intfloat [], struct intfloat *);
int i = 32;
struct intfloat **pp = &pt;
printf("\nappel de modifRvaleur");
printf("\n\tpp = %x\t*pp = %x",pp, *pp);
printf("\neffet de (++pt) ->entier =i");
(++pt)->entier=i; /* pré-incrémentation du pointeur pt */
imprime(tableau,pt);
(pt++)->entier =i; /* post-incrémentation du pointeur pt */
printf("\neffet de (pt++) ->entier =i");
imprime(tableau,pt);
pt++->entier =i; /* post-incrémentation du pointeur pt */
printf("\neffet de pt++->entier=i");
imprime(tableau,pt);
/* (*pp)->entier++=i; L-valeur obligatoire */
(*pp)++->entier=i; /* post-incrémentation du pointeur *pp */
printf("\neffet de (*pp)++->entier=i");
imprime(tableau,*pp);
(*pp++)->entier =i; /* post-incrémentation du pointeur pp */
printf("\neffet de (*pp++)->entier=i");
imprime(tableau,*pp);
}
void imprime(struct intfloat tableau[], struct intfloat *p)
{int i;
printf("\n\tpt = %x\n",p);
for (i = 0 ; i < TAILLE; i++) printf("\t%d",tableau[i].entier);
printf("\n");
for (i = 0 ; i < TAILLE; i++) printf("\t%3.1f",tableau[i].flottant);
printf("\n");
}
// résultat
Valeurs d'initialisation
pt = ffd6
0 2 4 6 8
1.0 4.0 7.0 10.0 13.0
appel de modifLvaleur
pp = ffd2 *pp = ffd6
effet de ++pt ->entier
pt = ffd6
1 2 4 6 8
1.0 4.0 7.0 10.0 13.0
effet de i=(++pt) ->entier
pt = ffdc
1 2 4 6 8
1.0 4.0 7.0 10.0 13.0
i= 2
effet de ++pt ->flottant
pt = ffdc
1 2 4 6 8
1.0 5.0 7.0 10.0 13.0
effet de i=(pt++) ->entier
pt = ffe2
1 2 4 6 8
1.0 5.0 7.0 10.0 13.0
i= 2
effet de i=pt++->entier
pt = ffe8
1 2 4 6 8
1.0 5.0 7.0 10.0 13.0
i= 4
*pp = ffe8 (*pp)->flottant = 10.0
effet de i=(*pp)->entier++
pt = ffe8
1 2 4 7 8
1.0 5.0 7.0 10.0 13.0
i= 6
effet de i=(*pp)++->entier
pt = ffee
1 2 4 7 8
1.0 5.0 7.0 10.0 13.0
i= 7
effet de i=(*pp++)->entier
pt = ffd6
1 2 4 7 8
1.0 5.0 7.0 10.0 13.0
i= 8
appel de modifRvaleur
pp = ffd2 *pp = ffd6
effet de (++pt) ->entier =i
pt = ffdc
1 32 4 7 8
1.0 5.0 7.0 10.0 13.0
effet de (pt++) ->entier =i
pt = ffe2
1 32 4 7 8
1.0 5.0 7.0 10.0 13.0
effet de pt++->entier=i
pt = ffe8
1 32 32 7 8
1.0 5.0 7.0 10.0 13.0
effet de (*pp)++->entier=i
pt = ffee
1 32 32 32 8
1.0 5.0 7.0 10.0 13.0
effet de (*pp++)->entier=i
pt = ffd6
1 32 32 32 32
1.0 5.0 7.0 10.0 13.0
Exercice 6.3
#include <stdio.h>
struct complexe { float x; float y;}; /* variable globale */
int main(void) /* norme ANSI */
{struct complexe z,z1,z2;
/* définitions */
/* prototypes */
void lecture(struct complexe *);
void imp(struct complexe);
void add(struct complexe, struct complexe, struct complexe *);
void mul(struct complexe, struct complexe, struct complexe *);
/* lecture et impression des données */
lecture(&z1); imp(z1);
lecture(&z2); imp(z2);
/* addition et impression du résultat */
add(z1,z2,&z); imp(z);
/* multiplication et impression du résultat */
mul(z1,z2,&z); imp(z);
}
void lecture(struct complexe *z)
{float x; /* variable auxiliaire pour la partie réelle */
printf(" saisie du nombre complexe :\n ");
printf(" partie réelle : ");
scanf("%f",&x); z->x=x; /* saisie directe pour la partie imaginaire */
printf(" partie imaginaire : ");
scanf("%f",&(*z).y);
}
void imp(struct complexe z)
/* impression du nombre complexe z */
{printf(" partie réelle : ");
printf("%6.2f\n",z.x);
printf(" partie imaginaire : ");
printf("%6.2f\n",z.y);
}
void add(struct complexe z1, struct complexe z2, struct complexe *z )
/* addition de deux nombres complexes z1, z2 */
/* résultat dans z */
{printf(" addition des nombres z1, z2\n");
z -> x = z1.x + z2.x;
z -> y = z1.y + z2.y;
}
void mul(struct complexe z1, struct complexe z2, struct complexe *z )
/* multiplication de deux nombres complexes */
/* z1, z2; résultat dans z */
{printf("multiplication des nombres z1, z2\n");
z -> x = z1.x * z2.x - z1.y * z2.y;
z -> y = z1.x * z2.y + z1.y * z2.x;
}
// résultat
saisie du nombre complexe :
partie réelle : 4.00
partie imaginaire : 8.00
saisie du nombre complexe :
partie réelle : 7.00
partie imaginaire : 4.00
addition des nombres z1, z2
partie réelle : 11.00
partie imaginaire : 12.00
multiplication des nombres z1, z2
partie réelle : -4.00
partie imaginaire : 72.00
Exercice 6.4
#include <stdio.h>
#include <string.h>
#define MAX 20 /* nombre maximum de noms */
#define ever (;;) /* boucle de saisie */
/* structures de portée globales */
struct pers {char nom [20 ]; struct pers *tsuc;};
typedef struct {char nom[20];} name;
void main(void)
{int i,k;
struct pers liste [MAX ];
/* prototypes */
void saisie(void); /* saisie des noms */
void tri(struct pers liste [ ]); /* tri avec les pointeurs */
int lire(struct pers liste[]); /* lecture des donnees */
saisie(); /* saisie de la liste dans un fichier */
k=lire(liste); /* constitution des pointeurs des successeurs */
printf("Liste non triée\n\n");
printf("Numéro Adresse Nom Adresse du successeur\n");
for(i=0;i<k;i++) printf("%3d %7x %-13s %x\n",i, &liste [i ],liste [i ].nom,liste [i ].tsuc);
tri(liste);
}
void saisie(void) /* saisie des données */
{FILE *fp;
name accueil = {""}, vide = {""};
fp=fopen("personnel","a");
for ever
{printf("Donnez le nom : ");
gets (accueil.nom);
if (!strlen(accueil.nom)) break;
/* fin de saisie */
fwrite((char*)&accueil,sizeof(accueil), 1,fp);
fflush(fp); /* vidage du tampon après chaque saisie */
accueil=vide; /*réinitialisation entre deux saisies*/
}
fclose(fp); /* fermeture du fichier */
}
int lire(struct pers liste [ ]) /* remplissage de la structure liste */
/* et constitution du tableau tsuc */
{FILE *fp;
name accueil;
/* initialisation */
int i;
struct pers *pred ,*j;
int st(char *, char *); /* fonction de comparaison de chaînes*/
char *strcpy(char *, const char *); /* prototype */
liste [0 ].tsuc = &liste [0 ]; i = 1; /* initialisation */
fp=fopen("personnel","r");
while (fread((char*)&accueil,sizeof(accueil),1,fp))
/* chargement d'un enregistrement de longueur sizeof(accueil) du fichier */
/* dont l'étiquette logique est fp dans le champ mémoire accueil */
{strcpy((char *)liste [i ].nom, (char *)accueil.nom);
/* initialisation de la recherche */
pred = &liste [0 ]; j = liste [0 ].tsuc;
while (j !=&liste [0 ] && st(j->nom, liste [i ].nom))
{pred = j; j = j->tsuc;}
/* modification du champ tsuc */
liste [i ].tsuc = j;
pred->tsuc = &liste [i ];
i++; /* enregistrement suivant */
}
fclose(fp);
return(i);
}
int st(char *s, char *t) /* comparaison de chaîne de caractères */
{int ret;
ret = strcmp(s,t);
if (ret == 0) return(-1);
if (ret<0) return(1); else return(0);
}
void tri(struct pers liste [ ])
{struct pers *j;
j = liste [0 ].tsuc;
printf("\n\ntri par ordre alphabétique\n");
while(j!=&liste [0 ]) {printf(" %s\n",j->nom); j = j->tsuc;}
}
// résultat
Liste non triée
Numéro Adresse Nom Adresse du successeur
0 fe24 feea
1 fe3a JACQUES febe
2 fe50 ROMAIN fe24
3 fe66 CLAUDE fea8
4 fe7c MARIE-SOL fed4
5 fe92 PIERRE fe50
6 fea8 CLAUDE fe3a
7 febe JULIE fe7c
8 fed4 NOEL fe92
9 feea CAROLINE fe66
tri par ordre alphabétique
CAROLINE
CLAUDE
CLAUDE
JACQUES
JULIE
MARIE-SOL
NOEL
PIERRE
ROMAIN

Chapitre 8
Exercice 8.1
#include <stdio.h>
int main(int argc,char *argv[])
/* version de la commande UNIX cat */
/* recopie du (des) fichier (s) d'entrée sur la sortie standard */
/* récupération desmessages d'erreurs qui ne sont donc pas dans le fichier de sortie */
{FILE *fp,*fopen(const char *, const char*);
int fclose(FILE *);
void filecopy(FILE *);
if (argc == 1) filecopy(stdin); /* si pas d'argument, copie sur la sortie standard
*/
else
while (--argc >0)
if ((fp = fopen(*++argv,"r")) == NULL)
{fprintf(stderr,"cat : can't open %s\n",*argv);
exit(1);}
else {filecopy(fp);fclose(fp);}
exit(0);
}
void filecopy(FILE *fp) /* recopie du fichier fp sur la sortie
standard*/
{int c;
while ((c = getc(fp)) != EOF) putc(c,stdout);
}
Exercice 8.2
#include <stdio.h>
int main(int argc, char *argv[])
/*
/* */
{FILE *fp1,*fp2;
/* prototypes */
FILE *fopen(char *FILE, char *mode);
void filecopy(FILE *, FILE *);
switch(argc)
{/* si pas d'argument, copie sur la sortie standard */
case 1 : filecopy(stdin,stdout);break; /* recopie sur la sortie standard */
case 2 :
if ((fp1 = fopen(*++argv,"r")) == NULL) /* erreur sur le fichier d'entrée */
{fprintf(stderr,"cat : can't open %s\n",*argv);
exit(2);
}
else {filecopy(fp1,stdout); fclose(fp1); break;}
case 3 : /* cas général */
if ((fp1 = fopen(*++argv,"r")) == NULL) /* erreur sur le fichier d'entrée */
{ fprintf(stderr,"cat : can't open %s\n",*argv); exit(1);}
else
/* erreur sur le fichier de sortie */
if ((fp2 = fopen(*++argv,"w")) == NULL)
{ fprintf(stderr,"cat : can't open %s\n",*argv); exit(2);}
else /* pas d'erreur*/
{filecopy(fp1,fp2);
fclose(fp1);
fclose(fp2);
break;
}
default : fprintf(stderr,"cat : use two files"); exit(3);
}
exit(0);
}
void filecopy(FILE *fp1, FILE *fp2) /* recopie du fichier fp1 dans le fichier fp2 */
{int c;
while ((c = getc(fp1)) != EOF) putc(c,fp2);
}
Exercice 8.3
#include <stdlib.h>
#include <stdio.h>
#define Taille 10
#define Nombre_structure 5
typedef struct chaine {float Tab[Taille]; chaine * pred;} chaine;
void main (void)
{ int i;
chaine * debut, * nouvelle, *ancienne;
chaine * initialiser(void);
void remplir(chaine *, int);
void chainer(chaine *, chaine*);
void parcourt(chaine*);
/* initialisation de la liste */
printf( "debut : Taille chaine : %d\n", sizeof(chaine)) ;
debut=initialiser();
remplir(debut,0);

/* creation de la liste */
for (i=0; i < Nombre_structure;i++)
{nouvelle=initialiser();
remplir(nouvelle,i+1);
chainer(nouvelle,debut);
debut=nouvelle;
}
parcourt(nouvelle);
}

chaine * initialiser(void)
{chaine * nouveau;
nouveau=(chaine*)calloc(1,sizeof(chaine));
printf("nouveau = %x\n",nouveau);
return nouveau;
}

void remplir(chaine * courante,int n)

{int i;
for(i=0; i < Taille; i++) courante->Tab[i]=(float) n*i;
courante->pred=(chaine *) NULL;
printf("fonction remplir\n");
}

void chainer(chaine * nouvelle, chaine * precedente)

{nouvelle->pred=precedente;
printf("fonction chainer\n");
}

void parcourt(chaine * depart)

{int i;
cout << "parcourt" << endl;
while(depart->pred !=(chaine *) NULL)
{ for(i=0; i < Taille; i++) printf(" %g", depart->Tab[i]);
printf("\n");
printf("%x \n",depart->pred);
depart=depart->pred;
}
}
// résultat
debut : Taille chaine : 44
nouveau = 8049ba0
fonction remplir
nouveau = 8049bd0
fonction remplir
fonction chainer
nouveau = 8049c00
fonction remplir
fonction chainer
nouveau = 8049c30
fonction remplir
fonction chainer
nouveau = 8049c60
fonction remplir
fonction chainer
nouveau = 8049c90
fonction remplir
fonction chainer
parcourt
0 5 10 15 20 25 30 35 40 45
8049c60
0 4 8 12 16 20 24 28 32 36
8049c30
0 3 6 9 12 15 18 21 24 27
8049c00
0 2 4 6 8 10 12 14 16 18
8049bd0
0 1 2 3 4 5 6 7 8 9
8049ba0