Chaînes de caractères

Point de départ

// La mémoire : un tampon de 8 octets, puis une variable voisine.
function creerMemoire() {
  const m = new Array(16).fill(0);
  const TAMPON = 0, TAILLE = 8, VOISIN = 8;
  m[VOISIN] = 1234;
  return {
    tampon: TAMPON, taille: TAILLE,
    ecrire(i, code) { m[i] = code; },
    lire(i) { return m[i]; },
    voisin: () => m[VOISIN],
    vue() {
      return m.slice(0, 12).map((c, i) => {
        const s = c === 0 ? "\\0" : (i >= VOISIN ? String(c) : String.fromCharCode(c));
        return (i === VOISIN ? "| " : "") + s;
      }).join(" ");
    },
  };
}

// Pose une chaîne littérale dans le tampon, SANS aucun contrôle — comme strcpy.
function monStrcpy(m, depart, texte) {
  let i = 0;
  for (; i < texte.length; i++) m.ecrire(depart + i, texte.charCodeAt(i));
  // ← à écrire : et le marqueur de fin ? combien d'octets au total ?
  return i;
}

// Longueur : on compte jusqu'au marqueur. AUCUNE borne.
function monStrlen(m, depart, compteur = { n: 0 }) {
  let i = 0;
  while (m.lire(depart + i) !== 0) { compteur.n++; i++; if (i > 40) return -1; }
  return i;
}

function monStrcmp(m, a, b) {
  return 0;   // ← à écrire : 0 si égales, sinon le signe de la différence
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Faites copier le marqueur par monStrcpy, puis copiez « Alice » dans le
//    tampon de 8 : combien d'octets ? Et « personnage » ?
// 2. Écrasez le marqueur et relancez monStrlen : que lit-elle ?
// 3. Comptez les caractères examinés avec strlen DANS la condition d'une
//    boucle, puis calculée une seule fois avant.

const m = creerMemoire();
monStrcpy(m, 0, "chat");
console.log("mémoire :", m.vue());
console.log("longueur :", monStrlen(m, 0), "| voisin :", m.voisin());

Solution

function creerMemoire() {
  const m = new Array(16).fill(0);
  const TAMPON = 0, TAILLE = 8, VOISIN = 8;
  m[VOISIN] = 1234;
  return {
    tampon: TAMPON, taille: TAILLE,
    ecrire(i, code) { m[i] = code; },
    lire(i) { return m[i]; },
    voisin: () => m[VOISIN],
    vue() {
      return m.slice(0, 12).map((c, i) => {
        const s = c === 0 ? "\\0" : (i >= VOISIN ? String(c) : String.fromCharCode(c));
        return (i === VOISIN ? "| " : "") + s;
      }).join(" ");
    },
  };
}

function monStrcpy(m, depart, texte) {
  let i = 0;
  for (; i < texte.length; i++) m.ecrire(depart + i, texte.charCodeAt(i));
  // Le marqueur FAIT PARTIE de la chaîne : strcpy le copie aussi, d'où
  // texte.length + 1 octets écrits. C'est le « + 1 » qu'on oublie.
  m.ecrire(depart + i, 0);
  return i + 1;
}

function monStrcpyBorne(m, depart, texte, taille) {
  // Ce que strncpy aurait dû être : on réserve la dernière case au marqueur.
  const n = Math.min(texte.length, taille - 1);
  for (let i = 0; i < n; i++) m.ecrire(depart + i, texte.charCodeAt(i));
  m.ecrire(depart + n, 0);
  return { ecrits: n + 1, tronque: n < texte.length };
}

function monStrlen(m, depart, compteur = { n: 0 }) {
  let i = 0;
  while (m.lire(depart + i) !== 0) { compteur.n++; i++; if (i > 40) return -1; }
  return i;
}

function monStrcmp(m, a, b) {
  let i = 0;
  while (m.lire(a + i) !== 0 && m.lire(a + i) === m.lire(b + i)) i++;
  // On compare les octets À LA PREMIÈRE DIFFÉRENCE, marqueurs compris : c'est
  // ce qui fait que 0 signifie « égales », d'où le piège du if (strcmp(...)).
  return m.lire(a + i) - m.lire(b + i);
}

console.log("— 1. le « + 1 » —");
for (const texte of ["chat", "Alice", "personnage"]) {
  const m = creerMemoire();
  const ecrits = monStrcpy(m, 0, texte);
  const debord = ecrits > m.taille;
  console.log("   « " + texte.padEnd(11) + " » : " + ecrits + " octets dans un tampon de " +
    m.taille + (debord ? "   << DÉBORDEMENT, voisin = " + m.voisin() : "   ok"));
}
console.log("   « Alice » fait 5 lettres et 6 octets : le marqueur déborde d'exactement");
console.log("   une case, ce qui passe la plupart des tests.");

console.log("");
console.log("— version bornée —");
const b = creerMemoire();
const r = monStrcpyBorne(b, 0, "personnage", b.taille);
console.log("   " + b.vue() + "   tronquée : " + r.tronque + ", voisin intact : " + b.voisin());

console.log("");
console.log("— 2. le marqueur perdu —");
const p = creerMemoire();
monStrcpy(p, 0, "chat");
console.log("   longueur normale : " + monStrlen(p, 0));
p.ecrire(4, 88);                  // on écrase le '\0' par un 'X'
console.log("   marqueur écrasé  : " + monStrlen(p, 0) +
            "   (lecture au-delà du tampon, jusqu'à un zéro fortuit ou la garde)");

console.log("");
console.log("— 3. strlen dans la condition —");
const q = creerMemoire();
for (let i = 0; i < 100; i++) q.ecrire(i, 65 + (i % 26));
q.ecrire(100, 0);
let dans = { n: 0 }, dehors = { n: 0 };
for (let i = 0; i < monStrlen(q, 0, dans); i++) { /* corps vide */ }
const n = monStrlen(q, 0, dehors);
for (let i = 0; i < n; i++) { /* corps vide */ }
console.log("   strlen DANS la condition : " + dans.n + " caractères examinés");
console.log("   strlen calculée une fois : " + dehors.n + " caractères examinés");
console.log("   rapport : " + Math.round(dans.n / dehors.n) + " fois plus, et il croît avec n.");

Avant de commencer

• Le TP 5 : tableaux et débordements
• Le TP 2 d'Architecture, sur UTF-8

Énoncé

1. Compter les octets — Déclarez une chaîne littérale et affichez sa longueur par strlen et sa taille par sizeof. Expliquez la différence d'exactement un.
2. Perdre le zéro — Remplissez un tableau de dix caractères avec dix lettres, sans terminateur, puis affichez-le avec %s. Recommencez plusieurs fois et notez la variabilité.
3. Le débordement classique — Copiez une chaîne de vingt caractères dans un tampon de dix avec strcpy. Exécutez, puis recompilez avec le détecteur d'adresses.
4. La fausse correction — Remplacez par strncpy avec la taille du tampon. Affichez le résultat et cherchez le nouveau problème. Écrivez ensuite la version réellement correcte. Indice : strncpy ne garantit PAS d'écrire le terminateur.
5. Comparer — Comparez deux chaînes de contenu identique avec l'opérateur d'égalité, puis avec strcmp. Expliquez pourquoi la première forme est parfois vraie.
6. Découper une ligne — Écrivez une fonction qui découpe une ligne en champs sur un séparateur, sans utiliser strtok. Testez avec des champs vides et des séparateurs consécutifs.
7. Au fil rouge — Branchez ce découpage dans journal : extraire l'adresse, la date, le code de réponse de chaque ligne. Testez sur une ligne tronquée et sur une ligne vide.
8. Les accents — Comptez les caractères d'une chaîne accentuée avec strlen, puis à la main. Écrivez une fonction qui compte les vrais caractères UTF-8.

C'est réussi quand

• ✓ Vous expliquez pourquoi sizeof vaut strlen plus un sur un littéral
• ✓ Votre version de la copie est sûre ET termine toujours la chaîne
• ✓ Votre découpage gère un champ vide entre deux séparateurs
• ✓ Votre compteur UTF-8 donne 8 pour « éléphant »

Correction

char s[] = "abc";
strlen(s)  → 3      (compte jusqu'au zéro, exclu)
sizeof s   → 4      (a, b, c, et le '\0')

en mémoire : 'a' 'b' 'c' '\0'

char t[10];
for (int i = 0; i < 10; i++) t[i] = 'A' + i;
printf("%s\n", t);

→ ABCDEFGHIJ suivi de déchets, jusqu'au premier octet nul
 rencontré par hasard — longueur variable d'une exécution à l'autre

char buf[10];

strcpy(buf, "chaîne bien trop longue");    /* DÉBORDEMENT */

strncpy(buf, source, sizeof buf);           /* pas de débordement,
                                             mais PAS DE '\0' si
                                             source fait 10 ou plus */

/* la version correcte */
strncpy(buf, source, sizeof buf - 1);
buf[sizeof buf - 1] = '\0';

/* ou, plus lisible, en vérifiant la troncature */
int n = snprintf(buf, sizeof buf, "%s", source);
if (n >= (int)sizeof buf) { /* tronqué : c'est une ERREUR, pas un détail */ }

char *a = "bonjour", *b = "bonjour";
a == b        → parfois VRAI : le compilateur a fusionné les littéraux
strcmp(a, b)  → 0 : contenus identiques

char c[] = "bonjour", d[] = "bonjour";
c == d        → FAUX : deux tableaux distincts

int decouper(char *ligne, char sep, char *champs[], int max) {
  int n = 0;
  char *debut = ligne;
  for (char *p = ligne; ; p++) {
      if (*p == sep || *p == '\0') {
          if (n >= max) return -1;
          char fin = *p;
          *p = '\0';              /* on coupe SUR PLACE */
          champs[n++] = debut;
          debut = p + 1;
          if (fin == '\0') break;
      }
  }
  return n;
}

strlen("éléphant") → 10 octets, pour 8 caractères

int caracteres_utf8(const char *s) {
  int n = 0;
  for (; *s; s++)
      if ((*s & 0xC0) != 0x80) n++;   /* on ignore les octets 10xxxxxx */
  return n;
}