Vos commentaires sur :
Les chaînes de caractères

long longueurChaine(const char* chaine) // strlen
{
     long nombreDeCaracteres = 0;
     char caractereActuel = 0;
     
     do
     {
          caractereActuel = chaine[nombreDeCaracteres];
          nombreDeCaracteres++;                         
     }
     while(caractereActuel != '\0'); //La boucle se répète tant qu'on n'est pas arrivé à la fin du tableau.
     
     nombreDeCaracteres--; //On enlève 1 caractère pour ne pas compter le '\0'
     
     return nombreDeCaracteres;
}

char* copieChaine(char* copieDeLaChaine, const char* chaineACopier)
{
      long i, taille = 0;
     
      /* Il faut d'abord connaître la longueur de la chaîne à copier.
      Pour ça, on envoie la chaîne à copier à la fonction longueurChaine déjà réalisée,
      et on ajoute 1 car cette dernière ne compte pas le '\0' or nous devons le compter car
      nous devons l'ajouter à la fin de copieDeLaChaine.
      */
      taille = longueurChaine(chaineACopier) + 1;
           
      for(i = 0 ; i < taille ; i++) // La boucle se répète tant que i < taille
      {
           copieDeLaChaine[i] = chaineACopier[i]; // copieDeLaChaine se remplie au fur et à mesure.
      }
}

char* concatChaines(char* chaine1, const char* chaine2)
{
      long i = 0, j = 0, difference, taille1 = 0, taille2 = 0, taille = 0;
     
      taille1 = longueurChaine(chaine1); // Taille de la chaine 1
      taille2 = longueurChaine(chaine2); // Taille de la chaine 2
      taille = taille1 + taille2; // Taille des deux chaines
     
      for(i = taille1 ; i < taille ; i++) // on initialise i = taille de la chaine initiale.
      {
            /*
            Au début, le '\0' sera remplacé par le premier caractère de la chaine2
            et ainsi de suite jusqu'à ce que i < taille c'est à dire le '\0' de chaine2 sera
            le dernier caractère.
            */
            chaine1[i] = chaine2[j];
            j++;
      }
}

int compareChaines(const char* chaine1, const char* chaine2)
{
    long taille1 = 0, taille2 = 0, i = 0, caractere1 = 0, caractere2 = 0, resultat = 0;
   
    taille1 = longueurChaine(chaine1);
    taille2 = longueurChaine(chaine2);
   
    if (taille1 == taille2) // Si les deux chaines sont égales, donc deuxième test, elles sont identiques ou non ?
    {
               do
               {
                   caractere1 = chaine1[i];
                   caractere2 = chaine2[i];
                   i++;
               }
               while(caractere1 == caractere2 && i < taille1); // boucle se répète tant que les deux caractères sont identiques ET i inférieur à la taille de la chaine pour ne pas compter le '\0'
               
               if(i == taille1) // si i est égale à la taille de la chaine, les deux sont identiques.
               {
                    resultat = 0;
               }
               else // sinon, elles sont différentes.
               {
                    resultat = 1;
               }
    }
   
    else // sinon, les deux chaines ne sont pas égales, elles ne sont pas identiques, logique...
    {
               resultat = 1;
    }
   
    return resultat;
}

char* chercheCaractere(char* chaine, int caractereARechercher)
{     
    if(!chaine)
    {
               return NULL;
    }
   
    while(*chaine != '\0') // tant que le caractère n'est pas '\0', boucle se répète
    {
        if(*chaine == caractereARechercher) // caractère trouvé
        {
                   return chaine; // on renvoie l'adresse du caractère
        }
        chaine++;
    }
      return NULL;
}

char* chercheLettres(char* chaine, const char* lettresARechercher)
{     
      long adresse = 0;
     
      if(!chaine)
      {
                 return NULL;
      }
     
      adresse = chaine; // On enregistre l'adresse de chaine pour qu'on puisse l'initialiser.
     
      while(*lettresARechercher != '\0')
      {             
                 for(chaine = adresse ; *chaine != '\0' ; chaine++) // on redonne à chaque fois la valeur initiale de chaine
                 {             
                               if(*chaine == *lettresARechercher)
                               {
                                          return chaine;
                               }
                 }
                 lettresARechercher++; // on passe au deuxième caractère et on refait le test dès le début avec chaine initialisée avec adresse.
      }
     
      return NULL;
}

char* chercheChaine(char* chaine, const char* chaineARechercher)
{
      long longueur = 0, compteur = 0, adresse = 0;
     
      if(!chaine)
      {
                 return NULL;
      }
     
      longueur = longueurChaine(chaineARechercher);
     
      while(*chaine != '\0')
      {
                    while(*chaine == *chaineARechercher) // tant qu'on a trouvé deux caractères identiques
                    {
                               compteur++;   // le compteur s'incrémente à chaque fois                         
                               if(compteur == longueur) // Si les caractères consécutifs sont identiques
                               {
                                           
                                           return chaine - longueur + 1; // on retourne l'adresse de la chaine et on soustrait la longueur mais on ajoute 1
                               }
                               else // sinon, y a d'autres caractères à rechercher
                               {
                               chaine++;
                               chaineARechercher++;
                               }
                    }
                    chaine++;
      }
     
      return NULL;
}