La fonction c_strcat permet de concaténer la chaîne src à la fin de la chaîne dest donc à partir du zéro de fin de cette dernière.

Si la chaîne src est vide alors la chaîne dest ne sera pas changée.

La concaténation commençant à la fin de la chaîne dest, si celle-ci ne dispose pas d'un caractère de fin de chaîne, la fonction continue la recherche de ce dernier jusqu'à en trouver un. Ceci a pour conséquence un comportement indéterminé de votre programme car l'écriture de la chaîne src se fera alors dans une zone mémoire quelconque et donc écrasement de données en mémoire !

Il faut par conséquent s'assurer que les chaînes de caractères possèdent un zéro terminal et également que la chaîne dest soit assez grande pour stocker la chaîne src en plus de ses propres caractères et bien sûr le zéro de fin !

Voici un algorithme possible pour la fonction c_strcat:

algorithme
   fonction c_strcat (dest:chaîne, src:chaîne):chaîne
      debut
         i <- 0
         j <- longueur (dest)
 
         faire
            dest[j] <- src[i]
 
            j <- j + 1
            i <- i + 1
         tant que src[i] différent de '\0'
 
         retourne dest
      fin
 
lexique
   dest : chaîne : Chaine de destination, adresse renvoyée par la fonction.
   src  : chaîne : Chaine source.
   i    : entier : Variable d'incrémentation pour se déplacer dans la chaîne src.
   j    : entier : Variable d'incrémentation pour se déplacer dans la chaîne dest.

L'algorithme est assez basique... Nous commençons par déclarer deux variables pour le déplacement dans les chaînes dest et src. Ici i pour la chaîne src que nous initialisons à 0 et j pour la chaîne dest que nous initialisons à la longueur de la chaîne dest, on se positionne donc sur le caractère de fin de celle-ci.

Dans la boucle, nous copions simplement caractère par caractère de la chaîne src vers la chaîne dest puis nous incrémentons nos variables pour passer aux emplacements mémoire suivants.

On termine la fonction en retournant l'adresse de la chaîne dest.

char * c_strcat (char * dest, const char * src)
{
   const char * p1 = src;
   char * p2 = dest + c_strlen (dest);
 
   do
   {
      *p2++ = *p1;
   }
   while (*p1++);
 
   return dest;
}

L'implémentation ci-dessus change un petit peu par rapport à l'algorithme que nous venons de voir car nous utilisons des pointeurs et par conséquent, nous n'avons pas besoin de variables d'incrémentation, nous utilisons à la place et comme d'habitude l'arithmétique des pointeurs.

Nous déclarons pour commencer deux pointeurs qui nous servirons à nous déplacer dans les chaînes de caractères. Le premier p1, commence sur le premier caractère de la chaîne src et le second p2 commence lui à la fin de la chaîne dest.

Vient ensuite la boucle de copie. On peut remarquer que la fonction incrémente le pointeur p2 dans le corps de la boucle et le pointeur p1 dans la condition de la boucle. Ceci permet en effet de copier le zéro de fin de la chaîne pointée par p1 avant de sortir de la boucle, cela évite une instruction supplémentaire pour insérer un caractère de fin en dehors de la boucle !

Comme d'habitude, on quitte la fonction en retournant l'adresse de la chaîne dest.

#include "c_string.h"
#include <stdio.h>
 
 
int main (void)
{
   char str1 [30] = "Ma chaine ";
   const char str2 [] = "de caracteres !";
 
   c_strcat (str1, str2);
 
   printf ("str1 : %s\n", str1);
 
   return 0;
}

Dans ce programme de test, on concatène simplement la chaîne str2 à la suite de la chaîne str1 et on affiche le résultat !