Discussion :

[couturierclaire]

Bonjour,
mon enseignant m'a donné le corrigé de l'exercice ci-dessous, mon problème est que je ne comprends pas
Pourquoi cette ligne if((s1[i] == '\0') && (s2[i] == '\0')) a pour signification "s1 et s2 sont égales"?
Pourquoi utilise t-on \0 pour montrer qu'elles sont égales?
Pourquoi cette ligne: if(s1[i]=='\0') a pour signification "si s1 est plus petit"?
Pourquoi doit-on utiliser les * (les pointeurs) dans les paramètres de cette fonction: int compareStrings(char * s1, char * s2)?

Merci d'avance


Exercice :Comparaison de chaînes de caractères
On souhaite écrire une fonction compareStrings comparant deux chaînes de caractères. Cettefonction retournera -1 si la première chaîne est avant la seconde dans l'ordre lexicographique, 1 si elle est après, et 0 si elles sont égales.

Corrigé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
int compareStrings(char * s1, char * s2)
{
    int comp = 0;
    int i = 0;
 
    while((s1[i] != '\0') && (s2[i] != '\0') && (comp == 0))
    {
        comp = s1[i]-s2[i];
        i++;
    }
 
    if(comp == 0)
    {
        /** s1 et s2 �gales */
        if((s1[i] == '\0') && (s2[i] == '\0'))
            return comp;
         /** s1 plus petite */
        if(s1[i]=='\0')
             return -1;
        /** s2 plus petite */
        if(s2[i]=='\0')
             return 1;
    }
 
    /** s1 plus petite */
    if(comp < 0)
        return -1;
   /** s2 plus petite */
    return 1;
}

[foetus]

Réfléchis un peu ... mais prends un crayon et un papier (ou NotePad et ton clavier)

Le caractère '\0' indique une fin de chaîne.

L'algo ce résumé ainsi

Étape 1: On parcourt nos 2 chaînes de caractères avec une boucle while en faisant une soustraction entre le caractère de la chaîne 1 et celui de la chaîne 2 au même indice (*).
Tant qu'on n'arrive pas à la fin d'1 des 2 chaines et tant que on n'a pas de différence (la soustraction vaut zéro)

* -> Un caractère c'est juste un "nombre". Après pour des chaînes qui ne soient pas de l'ASCII pur je ne sais pas si cela fonctionne.


Étape 2: On fait les tests
Si on n'a pas eu de différence (**) (la soustraction vaut zéro), il faut tester la taille des 2 chaînes pour savoir si elles ont la même longueur (***), ou bien laquelle est plus courte/ longue que l'autre.

** -> Tu as omis ce test
*** -> Il faut qu'à l'indice sur lequel on s'est arrêté, ce soit le caractère '\0' pour les 2 chaînes

Sinon s'il y a une différence, on regarde laquelle est plus courte/ longue que l'autre.


Sinon pour les pointeurs, c'est toujours comme cela: s1 et s2 pointent sur le premier caractère de la chaîne.

[rafa90]

Dans les parametres,char*=char[] pour typer les tableaux s1 et s2 comme chaine de caractere de la bibiotheque "string"

A l'aide d'un papier et le crayon tu peux examiner ce code:


int comp = 0;
int i = 0;

while((s1[i] != '\0') && (s2[i] != '\0') && (comp == 0))
{
comp = s1[i]-s2[i];
i++;
}
//dans la boucle "while" le prof compare caractere par caractere:
Tant que le caractere s1[¡]!='\0'et s2[¡]!='\0' et comp=0 sont vrai,les caracteres s1[¡] et s2[¡] ont la meme valeur suivant l'ordre lexicographique.Des la fin de la boucle "while",la variable "comp" a la valeur de la derniere comparaison,ainsi que "i" qui indique la Derniere position des caracteres compares avant l'arret de la boucle.

if(comp == 0)
{
/** s1 et s2 �gales */
if((s1[i] == '\0') && (s2[i] == '\0'))
return comp;
/** s1 plus petite */
if(s1[i]=='\0')
return -1;
/** s2 plus petite */
if(s2[i]=='\0')
return 1;
} //Dans le cas ou comp=0:
-Si les derniers caracteres s1[¡] et s2[¡] sont tous 2 egale a '\0' alors s1=s2 car la boucle a parcouru chaque chaine entierement jusqu'au caractere '\0' .
-si (s1[¡]='\ 0') alors s1 est plus petite que s2.car le dernier caractere s2[¡] est different de '\0'.Example:
S1=R E V E \0
¦ ¦ ¦ ¦ ¦
S2=R E V E R \0
-si (s2[¡]='\0') alors s2 esst plus petite que s1

/** s1 plus petite */
if(comp < 0)
return -1;
// Dans le cas ou comp<0:
s1[¡]-s2[¡]<0 donc s1[¡]<s2[¡],par consequent s1 est plus petite que s2

/** s2 plus petite */
return 1;
// Dans le cas ou comp>0:
s1[¡]-s2[¡]>0 donc s1[¡]>s2[¡],par consequent s2 est plus petite que s1

}