Exercice langage C les chaines de caractères en fonctions

 


Exercice 1

 Ecrire la fonction LONG_CH qui retourne la longueur d'une chaîne de caractères CH comme résultat. Implémentez LONG_CH sans utiliser de variable d'aide numérique.


Exercice 2

 Ecrire la fonction MAJ_CH qui convertit toutes les lettres d'une chaîne en majuscules, sans utiliser de variable d'aide.


Exercice 3

 Ecrire la fonction AJOUTE_CH à deux paramètres CH1 et CH2 qui copie la chaîne de caractères CH2 à la fin de la chaîne CH1 sans utiliser de variable d'aide.


Exercice 4

 Ecrire la fonction INVERSER_CH qui inverse l'ordre des caractères d'une chaîne CH. Utiliser la fonction LONG_CH (définie plus haut) et définir une fonction d'aide PERMUTER_CH qui échange les valeurs de deux variables du type char.


Exercice 5

 Ecrire la fonction NMOTS_CH qui retourne comme résultat le nombre de mots contenus dans une chaîne de caractères CH. Utiliser une variable logique, la fonction isspace et une variable d'aide N.


Exercice 6

 Ecrire la fonction MOT_CH qui retourne un pointeur sur le N-ième mot d'une chaîne CH s'il existe, sinon un pointeur sur le symbole de fin de chaîne.


Exercice 7

 Ecrire la fonction EGAL_N_CH qui retourne la valeur 1 si les N premiers caractères de CH1 et CH2 sont égaux, sinon la valeur 0. (Si N est plus grand que la longueur de CH1 ou de CH2, le résultat peut être 1 ou 0).


Exercice 8

 Utiliser la fonction EGAL_N_CH et LONG_CH pour écrire la fonction CHERCHE_CH qui retourne un pointeur sur la première apparition de CH1 dans CH2, sinon un pointeur sur le symbole de fin de chaîne.


Exercice 9

 Ecrire la fonction CH_ENTIER qui retourne la valeur numérique d'une chaîne de caractères représentant un entier (positif ou négatif) du type long. Si la chaîne ne représente pas une valeur entière correcte, la fonction arrête la conversion et fournit la valeur qu'elle a su reconnaître jusqu'à ce point.


Exercice 10

 Ecrire la fonction CH_DOUBLE qui retourne la valeur numérique d'une chaîne de caractères représentant un réel en notation décimale. Si la chaîne ne représente pas une valeur décimale correcte, la fonction arrête la conversion et fournit la valeur qu'elle a su reconnaître jusqu'à ce point. (Méthode: voir exercice 8.18.)


Exercice 11

 Ecrire la fonction ENTIER_CH qui construit une chaîne de caractères CH qui représente un nombre entier N du type long. N et CH sont les paramètres de la fonction ENTIER_CH. Utiliser la fonction INVERSER_CH définie plus haut.


Exercice 12

 Ecrire la fonction DOUBLE_CH qui construit une chaîne de caractères CH qui représente un nombre réel N avec 4 positions derrière la virgule. N et CH sont les paramètres de la fonction DOUBLE_CH.

Idée pour la conversion : Multiplier N par 104 et utiliser ENTIER_CH.

Représenter schématiquement la hiérarchie des appels des fonctions utilisées.




1
2
3
4
5
6
int LONG_CH(char *CH)
{
 char *P;
 for (P=CH ; *P; P++) ;
 return P-CH;
}

1
2
3
4
5
6
void MAJ_CH(char *CH)
{
 for ( ; *CH; CH++)
      if (*CH>='a' && *CH<='z')
          *CH = *CH-'a'+'A';
}



1
2
3
4
5
6
7
8
9
10
11
12
void AJOUTE_CH(char *CH1, char *CH2)
{
 while (*CH1) /* chercher la fin de CH1 */
        CH1++;
 while (*CH2) /* copier CH2 à la fin de CH1 */
       {
        *CH1 = *CH2;
        CH1++;
        CH2++;
       }
 *CH1='\0'; /* terminer la chaîne CH1 */
} 

 

Solution plus compacte :

1
2
3
4
5
void AJOUTE_CH(char *CH1, char *CH2)
{
 for ( ; *CH1 ; CH1++) ;
 for ( ; *CH1 = *CH2 ; CH1++, CH2++) ;
}

Comme la conditon d'arrêt est évaluée lors de l'affectation, le symbole de fin de chaîne est aussi copié.




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
void INVERSER_CH (char *CH)
{
 /* Prototypes des fonctions appelées */
 int LONG_CH(char *CH);
 void PERMUTER_CH(char *A, char *B);
 /* Variables locales */
 int I,J;
 /* Inverser la chaîne par permutations successives */
 J = LONG_CH(CH)-1;
 for (I=0 ; I<J ; I++,J--)
      PERMUTER_CH(CH+I, CH+J);
}
 
void PERMUTER_CH(char *A, char *B)
{
 char AIDE;
 AIDE = *A;
 *A   = *B;
 *B   = AIDE;
}
 
int LONG_CH(char *CH)
{
 . . .
}

 






1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <ctype.h>
 
int NMOTS_CH(char *CH)
{
 /* Variables locales */
 int N;        /* nombre de mots */
 int DANS_MOT; /* indicateur logique : */
               /* vrai si CH pointe à l'intérieur d'un mot */
 DANS_MOT=0;
 for (N=0; *CH; CH++)
     if (isspace(*CH))
         DANS_MOT=0;
     else if (!DANS_MOT)
         {
          DANS_MOT=1;
          N++;
         }
 return N;
}

 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <ctype.h>
 
char *MOT_CH(int N, char *CH)
{
 /* Variables locales */
 int DANS_MOT; /* indicateur logique : */
               /* vrai si CH pointe à l'intérieur d'un mot */
 DANS_MOT=0;
 for ( ; N>0 && *CH ; CH++)
     if (isspace(*CH))
         DANS_MOT=0;
     else if (!DANS_MOT)
         {
          DANS_MOT=1;
          N--;
          CH--; /* Pour réajuster l'effet de l'incrémentation */
         }
 return CH;
}

 



 

1
2
3
4
5
6
7
8
9
int EGAL_N_CH(int N, char *CH1, char *CH2)
{
 while (--N && *CH1==*CH2)
    {
     CH1++;
     CH2++;
    }
 return (*CH1==*CH2);
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
char *CHERCHE_CH(char *CH1, char *CH2)
{
 /* Prototypes des fonctions appelées */
 int LONG_CH(char *CH);
 int EGAL_N_CH(int N, char *CH1, char *CH2);
 /* Variables locales */
 int L;
 /* Recherche de CH1 dans CH2 */
 L=LONG_CH(CH1);
 while (*CH2 && !EGAL_N_CH(L, CH1, CH2))
          CH2++;
 return CH2;
}
 
int LONG_CH(char *CH)
{
 . . .
}
 
int EGAL_N_CH(int N, char *CH1, char *CH2)
{
 . . .
}

 


 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
long CH_ENTIER(char *CH)
{
 /* Variables locales */
 long N;
 int SIGNE;
 /* Traitement du signe */
 SIGNE = 1;
 if (*CH=='-') SIGNE = -1;
 if (*CH=='-' || *CH=='+') CH++;
 /* Conversion des chiffres */ 
 for (N=0 ; *CH>='0' && *CH<='9' ; CH++)
         N = N*10 + (*CH-'0');
 return SIGNE*N;
}
 

 






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
#include <ctype.h>
#include <math.h>
 
double CH_DOUBLE(char *CH)
{
 /* Variables locales */
 double N; /* résultat numérique */
 int SIGNE; /* signe de la valeur rationnelle */
 int DEC; /* positions derrière la virgule  */
 
 /* Initialisation des variables */
 N = 0.0;
 SIGNE = 1;
 /* Traitement du signe */
 if (*CH=='-') SIGNE = -1;
 if (*CH=='-' || *CH=='+') CH++;
 /* Positions devant le point décimal */
 for ( ; isdigit(*CH); CH++)
     N = N*10.0 + (*CH-'0');
 /* Traitement du point décimal */
 if (*CH=='.') CH++;
 
 /* Traitement des positions derrière le point décimal */
 for (DEC=0; isdigit(*CH); CH++)
    {
     N = N*10.0 + (*CH-'0');
     DEC++;
    }
 /* Calcul de la valeur à partir du signe et */
 /* du nombre de décimales. */
 return SIGNE*N/pow(10,DEC);
}

 




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
#include <stdio.h>
 
void ENTIER_CH(long N, char *CH)
{
  /* Prototypes des fonctions appelées */
 void INVERSER_CH(char *CH);
 /* Variables locales */
 int I;
 int SIGNE;
 /* Traitement du signe */
 SIGNE = (N<0) ? -1 : 1;
 if (N<0) N=-N;
 /* Conversion des chiffres (à rebours) */
 I=0;
 do
    {
     *(CH+I) = N % 10 + '0';
     I++;
    }
 while ((N/=10) > 0);
 /* Ajouter le signe à la fin de la chaîne */
 if (SIGNE<0)
    {
     *(CH+I)='-';
     I++;
    }
 /* Terminer la chaîne */
 *(CH+I)='\0';
 /* Inverser la chaîne */
 INVERSER_CH(CH);
}
 
void INVERSER_CH (char *CH)
{
 /* Prototypes des fonctions appelées */
 int LONG_CH(char *CH);
 void PERMUTER_CH(char *A, char *B);
 . . .
}
 
int LONG_CH(char *CH)
{
 . . .
}
 
void PERMUTER_CH(char *A, char *B)
{
 . . .
}

 



 

solex07

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
void DOUBLE_CH(double N, char *CH)
 
{ /* Prototypes des fonctions appelées */
 int LONG_CH(char *CH); 
void ENTIER_CH(long N, char *CH); 
/* Variables locales */ 
int I,L; 
/* Conversion */ 
N *= 10000.0; 
ENTIER_CH((long)N, CH); 
/* Conversion forcée est facultative */ 
L=LONG_CH(CH); for (I=L; I>=L-4; I--) 
/* Libérer une position pour le */
 *(CH+I+1) = *(CH+I); 
/* point décimal. */
 *(CH+L-4)='.'; 
} 
void ENTIER_CH(long N, char *CH) 
{ 
/* Prototypes des fonctions appelées */ 
void INVERSER_CH(char *CH);
 . . . } 
void INVERSER_CH (char *CH) { 
/* Prototypes des fonctions appelées */
 int LONG_CH(char *CH); 
void PERMUTER_CH(char *A, char *B);
 . . . } 
int LONG_CH(char *CH) { . . . } 
void PERMUTER_CH(char *A, char *B) { . . . }