Langage C : Chaine de Caractères !
Langage C : my_putstr et les chaines de caractères !
Nous revoilà pour le JOUR : 3 de ce cours sur l'algorithmique en langage C !
Je vous rappel son but, se débarasser du printf pour comprendre son fonctionnement !
Je vous ai laissé sur le JOUR : 2 un petit exercice pour vous entrainer avec le my_putchar, il était facile non ?
Voici sa solution :
void my_putchar(char c)
{
write(1, &c, 1); // write écrit sur la entrée standard
}
int main(void)
{
char mon_caractere; // Je déclare la variable
mon_caractere = 'U'; // J'attribue la lettre z à la variable
my_putchar(mon_caractere); // J'appel la fonction avec la variable en param
my_putchar('\n'); // \n sert à retourner à la ligne !
return(0); // fin
}
Donc testez le, on a bien un retour à la ligne avec la lettre U :) !
------------------------------------------------------------------------------------------------------------------
Aujourd'hui nous allons apprendre à entrer une chaîne de caractère, c'est pas facile de travailler qu'avec le my_putchar pour faire de l'affichage !
Je vous propose d'abord d'étudier la forme d'une chaine de caractère !
Une chaine de caractères, est un tableau de char ! mettez bien cela dans votre tête, c'est extrêmement important.
D'ailleurs, savez vous pourquoi il nous faut un tableau de 6 cases pour écrire 5 caractères ? Non ? Oui ?
Une chaine de caractère contient TOUJOURS une valeur de fin.
Cette valeur de fin est notée : \0 .
Donc à la fin de votre tableau, pour indiquer la fin de votre chaine de caractères vous aurez une case contenant '\0', c'est un stop en gros.
Voyez un exemple illustré :
Notre chaine : Salut = tableau de 5 cases, + 1 case pour indiquer la fin = 6 cases
Imaginons que nous voulions déclarer ce tableau nous ferions :
int main(void) { char chaine[6]; // Déclaration d'un tableau de 6 cases chaine[0] = 'S'; chaine[1] = 'a'; chaine[2] = 'l'; chaine[3] = 'u'; chaine[4] = 't'; chaine[5] = '\0'; // Fin de la chaîne ! printf("%s", chaine); // Affichage de la chaine (en bonus :P) return (0); }
Bon nous avançons bien. Vous savez maintenant qu'une chaine de caractères c'est un tableau contenant des char, et qui comporte une case qui marque la fin de la chaine.
La question maintenant, c'est comment utilisé le my_putchar qui écrit un char qu'on lui envoie, pour afficher une chaine de caractères.
La fonction qui permet de le faire s'appellera my_putstr, et sera prototypée de la façon suivante : int my_putstr(char *str);
Elle est du type int, car elle nous renverra une chaine de caractère. my_putchar était du type void car elle ne renvoyait rien, elle se contentait d'écrire.
Vous pouvez apercevoir la dedans un pointeur. Elle utilise en paramètre un pointeur sur str, qui est la chaine de caractères.
Oublier ce pointeur pour le moment, je vous les expliquerai un autre jour si vous ne les connaissez pas encore. Sachez juste qu'il faut le mettre, et que la fonction retournera *str.
Bon maintenant réfléchissons, à son algorithme.
On sait déjà que my_putchar écrit un caractère.
On sait que une chaîne de caractères à une fin : \0
L'une des premières proposition que l'on pourrait faire pour débuter cette fonction est :
Tant que ( On est pas à la fin de la chaine ) { On écrit avec my_putchar }
Et sa tombe bien, parce que c'est un excellent début ! Rappelez vous, il nous faut faire un TABLEAU DE CHAR.
Nous pouvons donc prendre le *str qu'a la fonction en paramètre, et en faire un tableau de la façon suivante :
Tant que ( str[...] =! '\0' ) { my_putchar(str[...]); }
Cette boucle veut en français dire :
"Tant que la case du tableau str[...] est différente (!=) de la fin ('/0'), ALORS on écrit avec my_putchar ce que contient le tableau à la case [...]"
C'est un superb avancement jusqu'à là, mais comme vous vous en doutez, il faut se déplacer dans le tableau, parce que ' ... ', n'est pas une expression valide en C !
------------------------------------------------------------------------------------------------------------------
Il faut donc initialiser un entier qui est au début égal à 0, comme la première case de notre tableau qui est 0. Vous commencez à voir ? Regardez :
int my_putstr(char *str) // Ligne 1 { int i; // Ligne 3 i = 0; // Ligne 4 while( str[i] != '\0' ) // Ligne 6 { my_putchar(str[i]); i = i + 1; } // Ligne 10 return(0) // Ligne 11 }
Commentons donc ce code ligne par ligne :
Ligne 1 : Déclaration de la fonction type int, prenant en paramètre un char.
Ligne 3-4 : Initialisation d'un entier et affectation de 0 à cette variable.
Ligne 6-10 : Boucle while. Temps que str[i] est différent de '/0' (la fin de la chaine), alors on écrit avec my_putchar ce que contient le tableau à la case str[i]. Puis on incrémente i de 1 (donc une case de plus).
Ligne 11 : On retourne 0, preuve que la fonctin se termine bien. Rien besoin de renvoyer d'autre !
MAGNIFIIIIIQUE NOTRE MY_PUTSTR EST PRÊT !!!!!!! Testons le !
void my_putchar(char c) { write(1, &c, 1); } int my_putstr(char *str) { int i; i = 0; while( str[i] != '\0') { my_putchar(str[i]); i = i + 1; } return(0); } int main() { my_putstr("Hello World !"); // Mettez bien des " " ("abcd") // ' ' = 1 seul caractere ('a') return(0); }
Et bien voilà pour ce cour, relisez le bien, entrainez vous à afficher plusieurs choses à l'écran !
J'ai même un exercice pour vous si vous voulez !
L'exercice
Le but : Afficher dans la console un carré tel que celui-ci dessous.
Consignes : La fonction du carré sera prototypée de la manière suivante :
void carre(int taille, char coin, char dessin);
INT TAILLE = Taille d'un coté du carré (coin comprit)
CHAR COIN = Le caractère qui sera dans le coin (un X sur la photo)
CHAR DESSIN = Le caractère qui représentera les ligne (un . sur la photo)
Indice : my_putchar et my_putstr sont les deux seuls fonctions pour écrire, besoins de rien d'autres à par vos fonctions qui dessineront le carré.
Ma fonction carré, appelle en elle les fonction qui s'occupe de l'affichage de chaque coté.
Un retour à la ligne = \n
La fin d'une chaine = \0
Faire un espace avec my_putchar = my_putchar(' ');
BON CODAGE !
Ici on a la fonction : carre(10, 'X', '.');
