Fonctions de manipulations de chaînes de caractères

Version imprimable

Bonjour,

Afin de m'entraîner, j'ai choisi de coder les fonctions de manipulation de chaînes de caractères dont je vais avoir besoin moi-même.

Voilà où j'en suis pour le moment :

Code:

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
 
int taille = 0; /* Variable stockant temporairement la taille d'une chaîne de caractères donnée */
char *COPIE = NULL; /* pointeur de type char vers une chaîne de caractères (utiliser lors des copies de chaînes) */
char *CONCATENE = NULL; /* pointeur de type char vers une chaîne de caractères (utiliser lors de de la concaténation de chaînes) */
 
char str1[] = "Bonjour !";
char str2[] = "Bonjour ! ";
char str3[] = "Mon ami, ";
char str4[] = "comment vas-tu  ";
char str5[] = "Ma foi je vais bien,";
char str6[] = "et toi ???";
char str7[] = "i jev";
 
int COMPARE_CH(char str1[], char str2[]);
int COMPTER_CH(char str[]);
int RECHERCHER_CH(char str1[], char str2[]);
char *COPIER_CH(char str[]);
char *CONCATENER_CH(char str1[], char str2[]);
 
/* Fonction : CONCATENER_CH
 * But : Concatène deux chaînes de caractères.
 * Argument : str1[] -> chaîne de caractères 1.
              str2[] -> chaîne de caractères 2.
 * Return : Renvoie un pointeur vers le premier élément de la nouvelle chaîne obtenue.
 *-------------------------------------------------------------------------------------*/
 
char *CONCATENER_CH(char str1[], char str2[])
{
    int i = 0;
    int j = 0;
    int a;
    int taille_str1 = 0;
    int taille_str2 = 0;
 
    COMPTER_CH(str1);
    taille_str1 = taille;
    COMPTER_CH(str2);
    taille_str2 = taille;
    /* printf("taille str1 = %d\ntaille str2 = %d\n", taille_str1, taille_str2); */
 
    if ((CONCATENE = (char *)malloc((taille_str1+taille_str2)+2-1)) == NULL)
    {
        printf("Erreur d'allocation mémoire !");
        exit(EXIT_FAILURE);
    }
 
    for (a = 0; a < taille_str1; a++)
    {
        CONCATENE[a] = str1[i];
        i++;
    }
 
    for (a = 0; a < taille_str2; a++)
    {
        CONCATENE[(taille_str1)+a] = str2[j];
        j++;
    }
 
    CONCATENE[(taille_str1+taille_str2)] = '\0';
    return(CONCATENE);
 
    /* Vérification
    for (a = 0; a <= (taille_str1+taille_str2); a++)
    {
        printf("CONCATENE[%d] = %d\n", a, CONCATENE[a]);
    }
    return(CONCATENE);
    Fin vérification */
}
 
/* Fonction : RECHERCHER_CH
 * But : Rechercher une sous-chaîne de caractères dans une autre chaîne de caractères plus grande.
 * Argument : str1[] -> chaîne de caractères dans laquelle s'effectuera la recherche.
              str2[] -> chaîne de caractères à rechercher.
 * Return : Renvoie 1 si la recherche aboutie, 0 le cas échéant.
 *-------------------------------------------------------------------------------------*/
 
int RECHERCHER_CH(char str1[], char str2[])
{
    int a;
    int i = 0;
    int j = 0;
    int taille_str1 = 0;
    int taille_str2 = 0;
 
    COMPTER_CH(str1);
    taille_str1 = taille;
    COMPTER_CH(str2);
    taille_str2 = taille;
 
    /* Vérification visuelle, à virer
    printf("Taille str1 = %d\nTaille str2 = %d\n", taille_str1, taille_str2);
    printf("%s\nstr2[0] = %c\nstr2[1] = %c\nstr2[2] = %c\nstr2[3] = %c\nstr2[4] = %c\n", str2, str2[0], str2[1], str2[2], str2[3], str2[4]);
    fin vérification visuelle */
 
    for (a = 0; a < taille_str1; a++)
    {
        if (str1[i] == str2[0])
        {
            do
            {
                /* printf("J = %d\n", j); */
                /* Vérification visuelle */
                /* printf("STR1 : %c => STR2 : %c\n", str1[i], str2[j]); */
                /* Fin vérification visuelle */
            }
            while (str1[i++] == str2[j++] && j < taille_str2);
 
            if (str1[i-1] == str2[j-1])
            {
                if (j == taille_str2)
                {
                    return(1);
                }
            }
        }
        else
        {
            i++;
            j = 0;
        }
    }
    return(0);
}
 
/* Fonction : COPIER_CH
 * But : Copier une chaîne de caractères dans une autre chaîne.
 * Argument : str[] -> chaîne de caractères à recopier.
 * Return : COPIE -> pointeur sur le premier élément de la chaîne copiée.
 *-------------------------------------------------------------------------------------*/
 
char *COPIER_CH(char str[])
{
    /* free(COPIE);  facultatif */
    /* printf("COPIE : %s\n", COPIE); */
    int i = 0;
    int j = 0;
    int a = 0;
 
    COMPTER_CH(str);
    /* printf("Taille = %d\n", taille); */
 
    if ((COPIE = (char *)malloc(taille+1)) != NULL)
    {
        while (a < taille)
        {
            COPIE[j] = str[i];
            a++;
            i++;
            j++;
        }
        COPIE[j] = '\0';
    }
    else
    {
        printf("Erreur d'allocation de mémoire !");
        exit(EXIT_FAILURE);
    }
    /* system("pause"); */
    /* vérification
    for (a = 0; a <= taille; a++)
    {
        printf("COPIE[%d] = %d\n", a, COPIE[a]);
    }
        for (a = 0; a <= taille; a++)
    {
        printf("COPIE[%d] = %c\n", a, COPIE[a]);
    }
    printf("\n");
    fin vérification */
    return(COPIE);
}
 
/* Fonction : COMPTER_CH
 * But : Mesure la taille d'une chaîne de caractères, caractère '\0' <null> compris. Attention : on compte à partir de 0 !!!
         Exemple : si la fonction renvoie taille = 6, cela singifie qu'il a 7 caractères dans la chaîne : 0-1-2-3-4-5-6.
 * Argument : str[] -> chaîne de caractères à mesurer.
 * Return : taille -> un entier représentant la taille de la chaîne.
 *-------------------------------------------------------------------------------------*/
 
int COMPTER_CH(char str[])
{
    int i = 0;
    taille = 0;
 
    while (str[i] != '\0') /* Tant que l'on ne rencontre pas le caractère null... */
    {
        taille++; /* on incrémente la taille et le compteur i de 1 */
        i++;
    }
    return(taille); /* et on renvoie la taille de la chaîne */
}
 
/* Fonction : COMPARE_CH
 * But : Comparer deux chaînes de caractères.
 * Argument : str1[] -> chaîne de caractères une.
 *            str2[] -> chaîne de caractères deux.
 * Return : Renvoie 1 si les deux chaînes sont identiques, 0 le cas échéant.
 *-------------------------------------------------------------------------------------*/
 
int COMPARE_CH(char str1[], char str2[])
{
    int i = 0;
    int j = 0;
 
    do /* On boucle tant que str1[i] OU str2[j] n'est pas équivalent au caractère null */
    {
        /* vérification
        printf("str1[%d] = %d ? str2[%d] = %d\n", i, str1[i], j, str2[j]);
        fin vérification */
 
        if (str1[i] != str2[j]) /* si str1[i] est différent de str2[j], alors les deux chaînes ne sont pas identiques */
        {
            return(0); /* on quitte la fonction en renvoyant 0 */
        }
        i++; /* tant qu'on ne rencontre pas le caractère de fin de châine, on incrémente les compteurs */
        j++;
    }  while (str1[i] != '\0' || str2[j] != '\0');
 
    return(1);
}
 
int main ()
{
    COMPTER_CH(str1);
    printf("Taille de %s = %d\n", str1, taille);
    COMPTER_CH(str2);
    printf("Taille de %s = %d\n", str2, taille);
 
    if ((COMPARE_CH(str1, str2)) == 1)
    {
        printf("Les deux chaînes sont identiques !\n");
    }
    else
    {
        printf("Les deux chaînes sont différentes !\n");
    }
 
    COPIER_CH(str1);
    printf("Chaîne copiée = %s\n", COPIE);
    COPIER_CH(str2);
    printf("Chaîne copiée = %s\n", COPIE);
    COPIER_CH(str3);
    printf("Chaîne copiée = %s\n", COPIE);
    COPIER_CH(str4);
    printf("Chaîne copiée = %s\n", COPIE);
    COPIER_CH(str5);
    printf("Chaîne copiée = %s\n", COPIE);
    COPIER_CH(str6);
    printf("Chaîne copiée = %s\n", COPIE);
 
    if ((RECHERCHER_CH(str5, str7)) == 1)
    {
        printf("Chaîne %s trouvée !\n", str7);
    }
    else
    {
        printf("Chaîne %s non trouvée !\n", str7);
    }
    CONCATENER_CH(str3, str4);
    printf("Chaîne concaténée : %s\n", CONCATENE);
}

Dans un souci pédagogique, que pensez-vous du code ? Est-ce bien codé ? En voyant ce code, auriez-vous des conseils à me donner pour plus de rigueur et de "propreté" ?

Par ailleurs, j'ai testé un maximum mes différentes fonctions, je n'ai pour le moment pas réussi à faire planter le programme ou bien à obtenir un résultat erroné... mais bon va falloir que je continue à tester je pense.

Merci par avance :ccool:

11/10/2009, 13h20
Obsidian

Bonjour,

Citation:

Envoyé par Merillym

Dans un souci pédagogique, que pensez-vous du code ? Est-ce bien codé ? En voyant ce code, auriez-vous des conseils à me donner pour plus de rigueur et de "propreté" ?

Ton programme est proprement rédigé et c'est bien mais, en règle générale, on évite les variables globales autant que possible. Et toi, tu en fais largement usage en début de programme.

Bon courage.

Citation:

Envoyé par Obsidian

Bonjour,

Ton programme est proprement rédigé et c'est bien mais, en règle générale, on évite les variables globales autant que possible. Et toi, tu en fais largement usage en début de programme.

Bon courage.
Code:

1 2 3 4 5 6 7 8 char str1[] = "Bonjour !"; char str2[] = "Bonjour ! "; char str3[] = "Mon ami, "; char str4[] = "comment vas-tu "; char str5[] = "Ma foi je vais bien,"; char str6[] = "et toi ???"; char str7[] = "i jev";
Celles-ci n'apparaîtront jamais en variables globales, là c'est juste pour faire les tests pour vérifier si mes fonctions marchent bien.

Par contre, concernant celles-ci :

int taille = 0;
char *COPIE = NULL;
char *CONCATENE = NULL;

Je n'ai aucune idée comme faire, car si je ne les mets pas en variables globales, le compilateur me signale tout le temps des "undeclarated use of" etc. Si vous avez des conseils ou astuces, je suis preneur.

Merci pour ta réponse:D

11/10/2009, 14h15
souviron34
Citation:

Envoyé par Merillym

Je n'ai aucune idée comme faire, car si je ne les mets pas en variables globales, le compilateur me signale tout le temps des "undeclarated use of" etc. Si vous avez des conseils ou astuces, je suis preneur.
1. Les passer en paramètres
2. Faire de l'allocation dynamique et retourner les adresses
:D
11/10/2009, 14h19
Merillym

Citation:

Envoyé par souviron34

[LIST=1]
Faire de l'allocation dynamique et retourner les adresses

J'ai essayé, mais je n'ai pas réussi... je débute aussi, ça ne fait que 15 jours que je fais du C. J'ai jamais fait de langage de programmation avant et j'apprends en autodidacte avec livres et tuto.

Je peux avoir un exemple concret pour illustrer ?

Merci ;)

par exemple, ta fonction CONCATENER_CH et ta variable CONCATENE..
Code:

1 2 3 4 5 6 7 8 9 char *CONCATENER_CH(char str1[], char str2[]) { int i = 0; char *result=NULL ; ... return(result); }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int main ( void ) { char *CONCATENE=NULL ; int s = EXIT_SUCCESS ; ..... if ( (CONCATENE = CONCATENER_CH(str3, str4)) != NULL ) printf("Chaîne concaténée : %s\n", CONCATENE); else s = EXIT_FAILURE ; return s ; }
Là, dans ce que tu fais, tu retournes bien un pointeur, mais dont tu ne te sers pas, et en plus tu as la chaîne en globale..

PS : faire un exit dans une fonction est dangereux et de mauvaise pratique. Mieux vaut retourner NULL et tester le retour de la fonction, quitte éventuellement à mettre comme j'ai mis un statut (qui peut être général au main,et évolutif à chaque appel de fonction).

11/10/2009, 15h06
Merillym

Bon j'ai testé et compris, ça marche nickel :ccool:

Par contre, comment faire avec la variable taille ?

Les fonctions de manipulations de chaînes de caractères sont utilisées au sein d'autres fonctions... si je ne déclare pas taille, CONCATENE et COPIE comme variables globales, j'ai plein de "undeclarated use of".

Ma question est donc la suivante : dois-je les laisser en variables globales, car constamment utilisées, ou y a-t-il une solution plus "propre" ?

Merci !
11/10/2009, 15h46
souviron34

Citation:

Envoyé par Merillym

Par contre, comment faire avec la variable taille ?

Si tes chaînes sont des vraies chaînes (terminées par le caractère '\0' comme c'est fait dans l'initialisation que tu as, ou par un sprintf ou strcpy) , alors il suffit d'utiliser la fonction strlen..

Citation:

Envoyé par Merillym

Les fonctions de manipulations de chaînes de caractères sont utilisées au sein d'autres fonctions... si je ne déclare pas taille, CONCATENE et COPIE comme variables globales, j'ai plein de "undeclarated use of".

Je t'ai donné l'exemple.. Déjà c'est plus propre de déclarer dans le main, et snuite de s'en servir..

Je ne passerais pas à travers tout le code, mais le principe est simple : paramètre...
11/10/2009, 15h57
Merillym

Oki pour strlen, mais justement, je ne voulais pas utiliser cette fonction et la coder moi-même, uniquement pour m'entraîner.

Je crois que je ne saisis pas bien ce que tu entends par paramètre... :)

Citation:

Envoyé par Merillym

Oki pour strlen, mais justement, je ne voulais pas utiliser cette fonction et la coder moi-même, uniquement pour m'entraîner.

Alors il te faut passer la taille en paramètre, ou bien te faire ta propre fonction TA_STRLEN qui va chercher (jusqu'à infini ou très grand nombre) le caractère '\0'..

Citation:

Envoyé par Merillym

Je crois que je ne saisis pas bien ce que tu entends par paramètre... :)

Dans tes fonctions COPIE et CONCATENER, tu fais une allocation et tu retournes un pointeur..

C'est très bien, et tu devrais t'en servir comme je l'ai montré dans mon exemple du main tout à l'heure.. Là tu ne t'en sers pas.. Et donc tu les déclares en global..

Sinon, tu peux aussi (et c'est ça un paramètre) écrire :
Code:

1 2 3 4 5 6 7 8 9 10 11 void CONCATENER_CH(char str1[], char str2[], char **Result) { int i = 0; if ((*Result= (char *)malloc((taille_str1+taille_str2)+2-1)) != NULL) { ... (*Result)[a] = str1[i]; ... } }
mais c'est moins direct pour s'en servir à la sortie..

11/10/2009, 17h12
diogene
Prenons le cas de la variable globale taille. Cette globale sert pour toi d'intermédiaire entre fonctions
Code:

1 2 3 4 5 char *CONCATENER_CH(char str1[], char str2[]) { .... COMPTER_CH(str1); // sert à positionner la variable taille taille_str1 = taille; // pour l'utiliser ici
Un codage naturel serait d'écrire simplement

Code:

taille_str1 = COMPTER_CH(str1);

Ce qui est possible puique la fonction COMPTER_CH renvoie la bonne valeur. Si on supprime l'utilisation de taille, celle-ci devient :
Code:

1 2 3 4 5 6 int COMPTER_CH(char str[]) { int i = 0; while (str[i] != '\0') i++ ; return i ; /* et on renvoie la taille de la chaîne */ }
Même chose pour COPIE, qui est renvoyé par COPIER_CH et CONCATENE renvoyé par CONCATENER_CH : on peut les supprimer pour faire
Code:

1 2 3 printf("Chaîne copiée = %s\n", COPIER_CH(str1)); .... printf("Chaîne concaténée : %s\n", CONCATENER_CH(str3, str4));
11/10/2009, 17h40
Merillym

Merci à vous deux :)

Citation:

tu devrais t'en servir comme je l'ai montré dans mon exemple du main tout à l'heure.. Là tu ne t'en sers pas.. Et donc tu les déclares en global..

C'est fait, j'ai corrigé mes deux fonctions ;)

Je vais appliquer vos conseils et continuer mes tests.

Concernant strlen, je pensais que COMPTER_CH remplissait son rôle mais j'ai dû oublier quelques chose.
11/10/2009, 17h49
diogene

Citation:

Concernant strlen, je pensais que COMPTER_CH remplissait son rôle mais j'ai dû oublier quelques chose.

Il le faisait, mais c'est son utilisation qui était mauvaise : tu ne tenais pas compte que la valeur de retour donnait l'information cherchée et tu passais par la globale taille. A partir du moment où on utilise la valeur de retour, on n'a plus besoin de taille et on peut aussi le supprimer de la fonction (dans la fonction d'origine, on avait toujours taille == i)

Et voilà ! J'ai appliqué tous vos conseils ( et surtout j'ai compris ce que je faisais ) :

Code:

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
 
int COMPARE_CH(char str1[], char str2[]);
int COMPTER_CH(char str[]);
int RECHERCHER_CH(char str1[], char str2[]);
char *COPIER_CH(char str[]);
char *CONCATENER_CH(char str1[], char str2[]);
 
/* Fonction : CONCATENER_CH
 * But : Concatène deux chaînes de caractères.
 * Argument : str1[] -> chaîne de caractères 1.
              str2[] -> chaîne de caractères 2.
 * Return : Renvoie un pointeur vers le premier élément de la nouvelle chaîne obtenue.
 *-------------------------------------------------------------------------------------*/
 
char *CONCATENER_CH(char str1[], char str2[])
{
    char *RESULT = NULL;
 
    int i = 0;
    int j = 0;
    int a;
    int taille_str1 = COMPTER_CH(str1);
    int taille_str2 = COMPTER_CH(str2);
 
    if ((RESULT = (char *)malloc((taille_str1+taille_str2)+2-1)) == NULL)
    {
        printf("Erreur d'allocation mémoire !");
        exit(EXIT_FAILURE);
    }
 
    for (a = 0; a < taille_str1; a++)
    {
        RESULT[a] = str1[i];
        i++;
    }
 
    for (a = 0; a < taille_str2; a++)
    {
        RESULT[(taille_str1)+a] = str2[j];
        j++;
    }
    RESULT[(taille_str1+taille_str2)] = '\0';
    return(RESULT);
}
 
/* Fonction : RECHERCHER_CH
 * But : Rechercher une sous-chaîne de caractères dans une autre chaîne de caractères plus grande.
 * Argument : str1[] -> chaîne de caractères dans laquelle s'effectuera la recherche.
              str2[] -> chaîne de caractères à rechercher.
 * Return : Renvoie 1 si la recherche aboutie, 0 le cas échéant.
 *-------------------------------------------------------------------------------------*/
 
int RECHERCHER_CH(char str1[], char str2[])
{
    int a;
    int i = 0;
    int j = 0;
    int taille_str1 = COMPTER_CH(str1);
    int taille_str2 = COMPTER_CH(str2);
 
    for (a = 0; a < taille_str1; a++)
    {
        if (str1[i] == str2[0])
        {
            do
            {
            }
            while (str1[i++] == str2[j++] && j < taille_str2);
 
            if (str1[i-1] == str2[j-1])
            {
                if (j == taille_str2)
                {
                    return(1);
                }
            }
        }
        else
        {
            i++;
            j = 0;
        }
    }
    return(0);
}
 
/* Fonction : COPIER_CH
 * But : Copier une chaîne de caractères dans une autre chaîne.
 * Argument : str[] -> chaîne de caractères à recopier.
 * Return : COPIE -> pointeur sur le premier élément de la chaîne copiée.
 *-------------------------------------------------------------------------------------*/
 
char *COPIER_CH(char str[])
{
    char *RESULT = NULL;
 
    int i = 0;
    int j = 0;
    int a = 0;
 
    if ((RESULT = (char *)malloc((COMPTER_CH(str))+1)) != NULL)
    {
        while (a < COMPTER_CH(str))
        {
            RESULT[j] = str[i];
            a++;
            i++;
            j++;
        }
        RESULT[j] = '\0';
    }
    else
    {
        printf("Erreur d'allocation de mémoire !");
        exit(EXIT_FAILURE);
    }
    return(RESULT);
}
 
/* Fonction : COMPTER_CH
 * But : Mesure le nombre de caractères d'une chaîne donnée, caractère '\0' <null> NON compris.
         Exemple : si la fonction renvoie taille = 6, cela singifie qu'il a 7 caractères dans la chaîne : 0-1-2-3-4-5-6, 6 représentant le caractère '\0'.
 * Argument : str[] -> chaîne de caractères à mesurer.
 * Return : x -> nombre de caractère dans la chaîne, caractère null NON compris !
 *-------------------------------------------------------------------------------------*/
 
int COMPTER_CH(char str[])
{
    int x = 0;
 
    while (str[x] != '\0')
    {
        x++;
    }
    return(x);
}
 
/* Fonction : COMPARE_CH
 * But : Comparer deux chaînes de caractères.
 * Argument : str1[] -> chaîne de caractères une.
 *            str2[] -> chaîne de caractères deux.
 * Return : Renvoie 1 si les deux chaînes sont identiques, 0 le cas échéant.
 *-------------------------------------------------------------------------------------*/
 
int COMPARE_CH(char str1[], char str2[])
{
    int i = 0;
    int j = 0;
 
    do
    {
        if (str1[i] != str2[j])
        {
            return(0);
        }
        i++;
        j++;
    }  while (str1[i] != '\0' || str2[j] != '\0');
 
    return(1);
}
 
int main ()
{
    char *CONCATENE = NULL;
    char *COPIE = NULL;
    int s = EXIT_SUCCESS;
 
    char str1[] = "Bonjour !";
    char str2[] = "Bonjour !";
    char str3[] = "Mon ami, ";
    char str4[] = "comment vas-tu  ";
    char str5[] = "Ma foi je vais bien,";
    char str6[] = "et toi ???";
    char str7[] = "i je v";
    char str8[] = "Hello  ???";
    char str9[] = "Hello  ???";
    char str10[] = "jour";
 
/* COMPTER */
 
    printf("Taille de %s = %d\n", str1, COMPTER_CH(str1));
    printf("Taille de %s = %d\n", str2, COMPTER_CH(str2));
    printf("Taille de %s = %d\n", str3, COMPTER_CH(str3));
    printf("Taille de %s = %d\n", str4, COMPTER_CH(str4));
    printf("Taille de %s = %d\n", str5, COMPTER_CH(str5));
    printf("Taille de %s = %d\n", str6, COMPTER_CH(str6));
    printf("Taille de %s = %d\n", str7, COMPTER_CH(str7));
    printf("Taille de %s = %d\n", str8, COMPTER_CH(str8));
    printf("Taille de %s = %d\n", str9, COMPTER_CH(str9));
    printf("Taille de %s = %d\n", str10, COMPTER_CH(str10));
 
/* COMPARER */
 
    if ((COMPARE_CH(str1, str2)) == 1)
    {
        printf("Les deux chaînes sont identiques !\n");
    }
    else
    {
        printf("Les deux chaînes sont différentes !\n");
    }
    if ((COMPARE_CH(str2, str3)) == 1)
    {
        printf("Les deux chaînes sont identiques !\n");
    }
    else
    {
        printf("Les deux chaînes sont différentes !\n");
    }
    if ((COMPARE_CH(str8, str9)) == 1)
    {
        printf("Les deux chaînes sont identiques !\n");
    }
    else
    {
        printf("Les deux chaînes sont différentes !\n");
    }
 
/* COPIER */
 
    if ((COPIE = COPIER_CH(str1)) != NULL )
    {
        printf("Chaîne copiée : %s\n", COPIE);
    }
    else
    {
        s = EXIT_FAILURE ;
    }
    if ((COPIE = COPIER_CH(str2)) != NULL )
    {
        printf("Chaîne copiée : %s\n", COPIE);
    }
    else
    {
        s = EXIT_FAILURE ;
    }
    if ((COPIE = COPIER_CH(str3)) != NULL )
    {
        printf("Chaîne copiée : %s\n", COPIE);
    }
    else
    {
        s = EXIT_FAILURE ;
    }
    if ((COPIE = COPIER_CH(str4)) != NULL )
    {
        printf("Chaîne copiée : %s\n", COPIE);
    }
    else
    {
        s = EXIT_FAILURE ;
    }
    if ((COPIE = COPIER_CH(str5)) != NULL )
    {
        printf("Chaîne copiée : %s\n", COPIE);
    }
    else
    {
        s = EXIT_FAILURE ;
    }
    if ((COPIE = COPIER_CH(str6)) != NULL )
    {
        printf("Chaîne copiée : %s\n", COPIE);
    }
    else
    {
        s = EXIT_FAILURE ;
    }
 
/* RECHERCHER */
 
    if ((RECHERCHER_CH(str5, str7)) == 1)
    {
        printf("Chaîne %s trouvée !\n", str7);
    }
    else
    {
        printf("Chaîne %s non trouvée !\n", str7);
    }
    if ((RECHERCHER_CH(str1, str10)) == 1)
    {
        printf("Chaîne %s trouvée !\n", str10);
    }
    else
    {
        printf("Chaîne %s non trouvée !\n", str10);
    }
    if ((RECHERCHER_CH(str3, str7)) == 1)
    {
        printf("Chaîne %s trouvée !\n", str7);
    }
    else
    {
        printf("Chaîne %s non trouvée !\n", str7);
    }
    if ((RECHERCHER_CH(str8, str2)) == 1)
    {
        printf("Chaîne %s trouvée !\n", str2);
    }
    else
    {
        printf("Chaîne %s non trouvée !\n", str2);
    }
 
/* CONCATENER */
 
    if ((CONCATENE = CONCATENER_CH(str3, str4)) != NULL )
    {
        printf("Chaîne concaténée : %s\n", CONCATENE);
    }
    else
    {
        s = EXIT_FAILURE ;
    }
    if ((CONCATENE = CONCATENER_CH(str1, str5)) != NULL )
    {
        printf("Chaîne concaténée : %s\n", CONCATENE);
    }
    else
    {
        s = EXIT_FAILURE ;
    }
    if ((CONCATENE = CONCATENER_CH(str4, str6)) != NULL )
    {
        printf("Chaîne concaténée : %s\n", CONCATENE);
    }
    else
    {
        s = EXIT_FAILURE ;
    }
 
 
 
 
    return(s);
}

:ccool:

Ne faites pas attention aux répétitions dans la fonction main, c'est juste pour tester le résultat des fonctions_CH.

Plus une seule variable globale :mouarf:

MERCI :D