Comment convertir un Tableau d'Octets en hexadécimal chaîne dans visual c++?

Déclaration d'une méthode sont les suivants:

//some.h
void TDES_Decryption(BYTE *Data, BYTE *Key, BYTE *InitalVector, int Length);

Je suis à l'appel de cette méthode dans le code suivant:

//some.c
extern "C" __declspec(dllexport) bool _cdecl OnDecryption(LPCTSTR stringKSN, LPCTSTR BDK){
    TDES_Decryption(m_Track1Buffer, m_cryptoKey, init_vector, len);
    return m_Track1Buffer;
}

Où que le type de données de m_Track1Buffer est BYTE m_Track1Buffer[1000];
Maintenant, je veux faire quelques changements dans la méthode ci-dessus, c'est à dire vouloir retourner le String in hex au lieu de Byte. Comment dois-je convertir ce m_Track1buffer à Hex string

Qu'est-ce que hexagonal chaîne? Vouliez-vous dire hex chaîne ici? Merci d'éditer et de les clarifier. Aussi, il est toujours utile de donner des exemples de l'entrée et la sortie attendue.
oui, c'est la chaîne hexadécimale

OriginalL'auteur Amit Pal | 2012-12-27

  1. 10

    Ce code permet de convertir en tableau d'octets de taille fixe 100 en chaîne hexadécimale:

    BYTE array[100];
char hexstr[201];
int i;
for (i=0; i<ARRAY_SIZE(array); i++) {
    sprintf(hexstr+i*2, "%02x", array[i]);
}
hexstr[i*2] = 0;
    Merci pour la réponse mais comment dois-je le retourner. ce variable devrais-je revenir ici ?
    retour quelque chose comme std::string(hexstr)

    OriginalL'auteur mvp

  2. 10

    Comme vous l'avez mentionné, c++, ici, est une réponse. Iomanip est utilisé pour stocker des entiers en format hexadecimal en stringstream.

    #include <sstream>
#include <iomanip>

std::string hexStr(BYTE *data, int len)
{
    std::stringstream ss;
    ss<<std::hex;
    for(int i(0);i<len;++i)
        ss<<(int)data[i];
    return ss.str();
}
    Vous avez besoin de remplir avec le '0' caractère à l'aide de setfill('0').
    J'avais aussi ajouter std::setw avoir il fonctionne à la sortie correctement à 2 chiffres pour chaque numéro. Alors maintenant, il ressemble à ss << std::hex << std:.setfill ('0'); et ss<<std::setw(2)<<static_cast<int>(data[i]);
    Cette réponse serait parfait si les commentaires ont été mises en œuvre.

    OriginalL'auteur 2r2w

  3. 8

    Ici est un peu plus souple version (Utiliser des caractères en majuscules? Insérer des espaces entre les octets?) qui peut être utilisé à la plaine des tableaux et des différents types de conteneurs:

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

template<typename TInputIter>
std::string make_hex_string(TInputIter first, TInputIter last, bool use_uppercase = true, bool insert_spaces = false)
{
    std::ostringstream ss;
    ss << std::hex << std::setfill('0');
    if (use_uppercase)
        ss << std::uppercase;
    while (first != last)
    {
        ss << std::setw(2) << static_cast<int>(*first++);
        if (insert_spaces && first != last)
            ss << " ";
    }
    return ss.str();
}

    Exemple d'utilisation (simple tableau):

    uint8_t byte_array[] = { 0xDE, 0xAD, 0xC0, 0xDE, 0x00, 0xFF };
auto from_array = make_hex_string(std::begin(byte_array), std::end(byte_array), true, true);
assert(from_array == "DE AD C0 DE 00 FF");

    Exemple d'utilisation (std::vector):

    //fill with values from the array above
std::vector<uint8_t> byte_vector(std::begin(byte_array), std::end(byte_array));
auto from_vector = make_hex_string(byte_vector.begin(), byte_vector.end(), false);
assert(from_vector == "deadc0de00ff");

    OriginalL'auteur Max Truxa

  4. 0

    comment sur l'utilisation de la bibliothèque boost comme ceci (extrait de http://theboostcpplibraries.com/boost.algorithm ):

    #include <boost/algorithm/hex.hpp>
#include <vector>
#include <string>
#include <iterator>
#include <iostream>

using namespace boost::algorithm;

int main()
{
  std::vector<char> v{'C', '+', '+'};
  hex(v, std::ostream_iterator<char>{std::cout, ""});
  std::cout << '\n';

  std::string s = "C++";
  std::cout << hex(s) << '\n';

  std::vector<char> w{'4', '3', '2', 'b', '2', 'b'};
  unhex(w, std::ostream_iterator<char>{std::cout, ""});
  std::cout << '\n';

  std::string t = "432b2b";
  std::cout << unhex(t) << '\n';
}
    S'il vous plaît commentaire lorsque vous votez, de sorte que je puisse m'améliorer
    Je ne sais pas si vous avez downvoted en raison de coup de pouce, mais je pense que votre réponse est acceptable et ne devrait pas avoir un score négatif.

    OriginalL'auteur serup

  5. 0

    À l'aide de stringstream, sprintf et d'autres fonctions dans la boucle n'est tout simplement pas le C++. C'est horrible pour les performances et ce genre de fonctions habituellement appelés un lot (à moins que vous êtes en train d'écrire des choses dans le journal).

    Voici une façon de le faire.
    Écrit directement dans le std::string's de la mémoire tampon est découragé parce spécifiques std::string mise en œuvre peuvent se comporter différemment et cela ne marchera pas, mais nous sommes en évitant une copie de l'ensemble de la mémoire tampon de cette façon:

    #include <iostream>
#include <string>
#include <vector>

std::string bytes_to_hex_string(const std::vector<uint8_t> &input)
{
  static const char characters[] = "0123456789ABCDEF";

  //Zeroes out the buffer unnecessarily, can't be avoided for std::string.
  std::string ret(input.size() * 2, 0);

  //Hack... Against the rules but avoids copying the whole buffer.
  char *buf = const_cast<char *>(ret.data());

  for (const auto &oneInputByte : input)
  {
    *buf++ = characters[oneInputByte >> 4];
    *buf++ = characters[oneInputByte & 0x0F];
  }
  return ret;
}

int main()
{
  std::vector<uint8_t> bytes = { 34, 123, 252, 0, 11, 52 };
  std::cout << "Bytes to hex string: " << bytes_to_hex_string(bytes) << std::endl;
}

    OriginalL'auteur BJovke