HOWTO · C++

Convertir une chaîne de caractères en Hex en C++

Cet article présente comment convertir une chaîne de caractères en valeur hexadécimale en C++

Sur cette page

Convertir un std::string en hexadécimal en C++ consiste à produire une représentation textuelle des octets de la chaîne : chaque char devient une valeur en base 16 sur deux chiffres, ainsi "Hello" devient 48656c6c6f. Cette opération est utile pour déboguer des données binaires, produire des sommes de contrôle ou des empreintes, et alimenter des protocoles qui attendent des charges utiles encodées en hexadécimal.

Cet article montre comment afficher directement une sortie hexadécimale, comment construire un std::string hexadécimal réutilisable, comment conserver deux chiffres pour chaque octet et comment le résultat se rapporte à l’encodage du texte, puis compare les approches pour vous aider à choisir la bonne.

Convertir une chaîne en octets hexadécimaux

L’approche la plus directe parcourt l’entrée un octet à la fois et écrit chaque valeur dans std::cout en base 16. Le manipulateur de flux std::hex fait passer la sortie des entiers en hexadécimal, et std::setw(2) associé à std::setfill('0') maintient chaque octet sur deux chiffres. Itérer avec unsigned char maintient chaque octet dans la plage 0 à 255, de sorte que les octets supérieurs à 0x7f se formatent correctement même sur les plateformes où le char simple est signé. Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <iomanip>
#include <iostream>
#include <string>

int main() {
    std::string input = "Hello";

    std::cout << std::hex << std::setfill('0');
    for (unsigned char c : input) {
        std::cout << std::setw(2) << static_cast<int>(c);
    }
    std::cout << '\n';
}
48656c6c6f

L’exemple conserve la chaîne anglaise "Hello" et sa sortie hexadécimale inchangée. std::hex reste actif jusqu’à ce que vous le changiez ; définissez-le donc une seule fois avant la boucle. std::setw(2) ne s’applique qu’à la prochaine valeur insérée, c’est pourquoi il figure dans la boucle, tandis que std::setfill('0') persiste. L’affichage sur std::cout convient bien pour une inspection rapide, mais le texte converti disparaît dès qu’il défile — la section suivante montre comment le conserver.

Construire et stocker une chaîne hexadécimale

Lorsque le texte converti est nécessaire plus tard — pour le renvoyer depuis une fonction, l’ajouter à un message de journal ou l’écrire dans un fichier — accumulez-le dans un std::stringstream au lieu de std::cout. Les mêmes manipulateurs de formatage s’appliquent, et str() produit un std::string qui contient le résultat :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>

std::string toHex(const std::string& input) {
    std::stringstream ss;
    ss << std::hex << std::setfill('0');
    for (unsigned char c : input) {
        ss << std::setw(2) << static_cast<int>(c);
    }
    return ss.str();
}

int main() {
    std::string text = "C++ Programming";
    std::string hexText = toHex(text);
    std::cout << "string: " << text << '\n';
    std::cout << "hexval: " << hexText << '\n';
}
string: C++ Programming
hexval: 432b2b2050726f6772616d6d696e67

La sortie conserve les libellés anglais string: et hexval:, qui identifient respectivement le texte d’entrée et sa valeur hexadécimale. Comme toHex renvoie un std::string, l’appelant décide de ce qu’il en fait : l’afficher, le stocker ou le transmettre à un flux de fichier. L’exemple se contente d’afficher la valeur — l’écriture dans un fichier est une étape distincte via std::ofstream, qui accepte le même texte hexadécimal.

Formater chaque octet avec deux chiffres hexadécimaux

Un octet contient une valeur de 0 à 255 — de 0x00 à 0xff — donc deux chiffres suffisent toujours. Sans remplissage, les valeurs inférieures à 0x10 s’affichent sur un seul chiffre, ce qui rend la sortie ambiguë : la paire d’octets 0x01, 0x0a et l’octet unique 0x1a produiraient tous deux 1a. std::setw(2) définit la largeur minimale du champ et std::setfill('0') fournit le caractère de remplissage :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <iomanip>
#include <iostream>
#include <string>

int main() {
    std::string input = "A\nB";

    std::cout << std::hex << std::setfill('0');
    for (unsigned char c : input) {
        std::cout << std::setw(2) << static_cast<int>(c);
    }
    std::cout << '\n';
}
410a42

L’octet du milieu est 0x0a et s’affiche toujours sur deux chiffres. Supprimez std::setw et std::setfill et la même entrée affiche 41a42, où vous ne pouvez plus savoir où un octet se termine et où le suivant commence. Gardez std::setw dans la boucle — il se réinitialise après chaque valeur formatée — tandis que std::setfill ne doit être défini qu’une seule fois.

Comprendre les valeurs d’octets et l’encodage du texte

Tous les exemples jusqu’ici convertissent des octets, pas des caractères. std::string stocke une séquence de char, et la boucle formate la valeur numérique de chacun. Pour une entrée ASCII, cette distinction est invisible — H est l’octet unique 0x48 — mais elle compte pour d’autres textes. En UTF-8, é (point de code U+00E9) est stocké sous la forme des deux octets 0xc3 0xa9, donc la même boucle produit c3a9 plutôt que e9 :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <iomanip>
#include <iostream>
#include <string>

int main() {
    std::string input = "\xc3\xa9";  // UTF-8 bytes for U+00E9

    std::cout << std::hex << std::setfill('0');
    for (unsigned char c : input) {
        std::cout << std::setw(2) << static_cast<int>(c);
    }
    std::cout << '\n';
}
c3a9

Le commentaire UTF-8 bytes for U+00E9 du code reste en anglais et désigne les octets UTF-8 de ce point de code. Les fonctions de cet article décrivent donc les octets encodés de ce que contient la chaîne. Si vous avez besoin des points de code en hexadécimal, décodez d’abord le texte puis formatez les valeurs décodées. La gestion des octets non signés est importante pour la même raison : là où le char simple est signé, un octet comme 0xc3 se convertit en une valeur inférieure à zéro et s’affiche sous la forme ffffffc3. Itérer avec unsigned char — ou effectuer une conversion via ce type avant static_cast<int> — maintient la valeur à 0xc3.

Choisir une approche de conversion

Utilisez la boucle directe sur std::cout lorsque vous n’avez besoin d’inspecter les données qu’une seule fois. Renvoyez un std::string construit avec std::stringstream lorsque le résultat doit survivre à l’appel — c’est l’option générale la plus lisible et elle conserve le formatage std::hex, std::setw et std::setfill au même endroit.

Une troisième option divise chaque octet en ses deux moitiés de 4 bits (quartets) et convertit chacune à l’aide d’une table de correspondance :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <iostream>
#include <string>

std::string toHexLookup(const std::string& input) {
    static const char digits[] = "0123456789abcdef";
    std::string result;
    result.reserve(input.size() * 2);
    for (unsigned char c : input) {
        result += digits[c >> 4];
        result += digits[c & 0x0f];
    }
    return result;
}

int main() {
    std::cout << toHexLookup("World") << '\n';
}
576f726c64

L’exemple conserve la chaîne anglaise "World" dans le code. La version avec table émet toujours exactement deux chiffres par octet et n’effectue aucun formatage de flux, ce que certaines bases de code préfèrent par souci de cohérence. Son éventuelle rapidité dépend de votre implémentation de la bibliothèque standard ; mesurez donc sur vos propres données si cela compte. Quelle que soit l’approche choisie, le résultat décrit des octets : pour du texte ASCII, il se lit comme une paire par caractère, et pour des données UTF-8 ou binaires, comme une paire par octet encodé.