Chaînes de caractères

Caractères¶

Un caractère est un symbole. Par exemple, a, E, 1 et ! sont des caractères.
Le type utilisé en C pour stocker un caractère est char :

In [1]:

char c = 'a';

char c = 'a';

'a' est une valeur, contrairement à c qui est ici une variable.
Remarque : Contrairement à Python qui utilise " et ' de manière interchangeable et qui ne fait pas de distinction entre caractère et chaine de caractères, en C les caractères doivent utiliser ' (et les chaînes de caractères doivent utiliser ").

Sur un ordinateur, il n'est possible de stocker que des 0 et des 1. Il est donc nécessaire de coder les caractères en binaire, par un codage.
Le codage utilisé par défaut en C est ASCII. Il code chaque caractère sur 7 bits. Comme la plus petite unité adressable de mémoire est 1 octet (8 bits), un char est en fait codé sur 8 bits avec un bit non utilisé :

In [2]:

sizeof(c) // un char prend 1 octet, soit 8 bits, en mémoire

sizeof(c) // un char prend 1 octet, soit 8 bits, en mémoire

Out[2]:

1

Comme il y a $2^7$ valeurs possibles sur $7$ bits, ASCII permet de stocker $2^7 = 128$ caractères. Les voici, avec leurs codages :

Par exemple, A est codé par 65, c'est-à-dire stocké avec $1000001_2$ en mémoire. On peut le vérifier en convertissant un char en unsigned :

In [13]:

(unsigned)'A'

(unsigned)'A'

Out[13]:

65

Exercice

Afficher les lettres de l'alphabet. On pourra utiliser un entier dans un for et le convertir en char.

ASCII est très limité. Il ne permet pas d'encoder les accents, par exemple :

In [4]:

char c = 'é'

char c = 'é'

input_line_13:2:11: error: character too large for enclosing character literal type
 char c = 'é'
          ^

Interpreter Error: 

Unicode et UTF-8 sont des normes d'encodages plus modernes et maintenant beaucoup plus utilisées que ASCII :

• Unicode est une table de caractères : à chaque caractère (144697 au total) est associé un entier
• UTF-8 est un encodage pour Unicode : il spécifie comment coder les entiers (correspondants aux caractères Unicode) comme suite de bits, en utilisant un ou plusieurs char.

Unicode et UTF-8 sont rétro-compatibles avec ASCII (les caractères ASCII garde le même codage).
Voici la proportion des tables de caractères les plus utilisées sur le Web :

En janvier 2021, le pourcentage de sites Web utilisant Unicode a atteint 96.1%.

La plupart des compilateurs C permettent d'utiliser UTF-8. Cependant, certaines fonctions de la librairie standard ne marchent plus avec l'UTF-8, étant donné qu'un caractère UTF-8 peut correspondre à plusieurs char :

In [23]:

char s[] = "é"; // chaîne de caractères Unicode
printf("%lu\n", sizeof(s)); // = 3
// é est codé sur 2 char en UTF-8 (donc 2 octets) et \0 sur un octet
strlen(s) // 2 au lieu de 1

char s[] = "é"; // chaîne de caractères Unicode printf("%lu\n", sizeof(s)); // = 3 // é est codé sur 2 char en UTF-8 (donc 2 octets) et \0 sur un octet strlen(s) // 2 au lieu de 1

3

Out[23]:

2

Chaîne de caractères¶

En C, il n'existe pas de type particulier correspondant à une chaîne de caractères. La convention est de définir une chaîne de caractères comme un tableau de char qui termine par \0 (caractère spécial qui sert à savoir quand la chaîne s'arrête). Exemple :

In [1]:

char ex[] = {'e', 'x', 'e', 'm', 'p', 'l', 'e', '\0'};
ex

char ex[] = {'e', 'x', 'e', 'm', 'p', 'l', 'e', '\0'}; ex

Out[1]:

"exemple"

De façon totalement équivalente, on peut aussi écrire :

In [9]:

char ex[] = "exemple"; // créé un tableau de caractères avec un '\0` final est automatiquement ajouté

char ex[] = "exemple"; // créé un tableau de caractères avec un '\0` final est automatiquement ajouté

Ou d'abord définir le tableau puis modifier ses éléments :

In [12]:

char ex[8];
ex[0] = 'e';
ex[1] = 'x';
// etc
ex[6] = 'e';
ex[7] = '\0';

char ex[8]; ex[0] = 'e'; ex[1] = 'x'; // etc ex[6] = 'e'; ex[7] = '\0';

Tout ce qui a été vu sur le lien entre tableau et pointeur reste valable pour les chaînes de caractères. Ainsi :

1. Un char[] (tableau de char) est automatiquement converti en char* (pointeur sur le premier char du tableau) lors d'une affectation de variable ou de passage en argument d'une fonction.
2. Il n'est pas possible d'utiliser l'initialisation char ex[] = "exemple"; après avoir défini la variable :

In [7]:

char ex[] = "exemple"; // OK dans la définition de ex
ex = "test"; // PAS OK : il faudrait modifier les caractères un par un

char ex[] = "exemple"; // OK dans la définition de ex ex = "test"; // PAS OK : il faudrait modifier les caractères un par un

input_line_16:3:4: error: array type 'char [8]' is not assignable
ex = "test"; // PAS OK : il faudrait modifier les caractères un par un
~~ ^

Interpreter Error: 

Il est possible d'afficher une chaîne de caractère avec %s dans printf :

In [1]:

char ex[] = "exemple";
printf("ex vaut %s", ex);

char ex[] = "exemple"; printf("ex vaut %s", ex);

  File "<ipython-input-1-21e5b4aef7e2>", line 1
    char ex[] = "exemple";
         ^
SyntaxError: invalid syntax

Passage de chaîne de caractères en argument¶

Comme dit précédemment, un char[] est converti en char* lors d'un passage à une fonction. Par exemple, la fonction suivante calcule la taille d'une chaîne de caractères (strlen dans glibc):

In [7]:

int size(const char* s) {
    int i = 0;
    while(s[i] != '\0')
        i++;
    return i;
}

size("mp2i")

int size(const char* s) { int i = 0; while(s[i] != '\0') i++; return i; } size("mp2i")

Out[7]:

4

Remarques :

• const char* signifie "pointeur vers une chaîne de caractères non modifiable (immutable)". Cela apporte une garantie à l'utilisateur : la chaîne de caractères passée en argument ne sera pas modifiée.
• Les litéraux de chaînes de caractères (comme "mp2i") sont de type char* en C et const char* en C++. Si size avait le prototype int size(char*) (sans const), il faudrait donc, en C++, une conversion de const char* vers char* (size((char*)"mp2i")).

Exercice

Écrire une fonction int count(const char*, char) calculant le nombre d'apparitions d'un caractère dans une chaîne de caractères.

Exercice

Un palindrome est une chaîne de caractères qui peut se lire de la même façon dans les deux sens. Écrire une fonction pour savoir si une chaîne de caractères est un palindrome.

Écrire une fonction copy de prototype void copy(char*, const char*) (cette fonction existe déjà sous le nom strcpy).

Malloc et chaînes de caractères¶

On peut utiliser malloc pour créer une chaîne de caractères sur le tas, comme pour tout tableau :

In [1]:

char* concat(const char* s1, const char* s2) {
    int n1 = strlen(s1);
    int n2 = strlen(s2);
    char* s = (char*)malloc(sizeof(char)*(n1 + n2));
    for(int i = 0; i < n1; i++)
        s[i] = s1[i];
    for(int i = 0; i < n2; i++)
        s[n1 + i] = s2[i];
    return s;
}

concat("hello", " world")

char* concat(const char* s1, const char* s2) { int n1 = strlen(s1); int n2 = strlen(s2); char* s = (char*)malloc(sizeof(char)*(n1 + n2)); for(int i = 0; i < n1; i++) s[i] = s1[i]; for(int i = 0; i < n2; i++) s[n1 + i] = s2[i]; return s; } concat("hello", " world")

Out[1]:

"hello world"

Exercice

Le codage de César consiste à chiffre une chaîne de caractère en décalant chaque caractère d'une clé k.

1. Écrire une fonction chiffre(char* s, int k) renvoyant un nouveau tableau contenant le codage de César de s avec la clé k.
2. Écrire une fonction dechiffre(char* s) renvoyant un nouveau tableau contenant le codage de César de s.