c++ hex set of strings to array of bytes not return vector

Question

So basically , I want to create a function that

takes this hex pattern:

"03 C6 8F E2 18 CA 8C E2 94 FD BC E5 03 C6 8F E2"

and returns this array of bytes:

BYTE pattern[] = { 0x03, 0xC6, 0x8F, 0xE2, 0x18, 0xCA, 0x8C, 0xE2, 0x94, 0xFD, 0xBC, 0xE5, 0x03, 0xC6, 0x8F, 0xE2 };

My main problem is what i need like each 0x03 in one byte cell, of the output array exactly as i described,

if i use this

   #include <windows.h>

    std::vector<BYTE> strPatternToByte(const char* pattern, std::vector<BYTE> bytes)
    {
        std::stringstream converter;
    
        std::istringstream ss( pattern );
        std::string word;
        while( ss >> word )
        {
            BYTE temp;
            converter << std::hex << "0x" + word;
            converter >> temp;
    
            bytes.push_back( temp );
        }
    
        return bytes;
    }
    
        int main()
        {
    
            const char* pattern = "03 C6 8F E2 18 CA 8C E2 D4 FD BC E5 03 C6 8F E2";
            std::vector<BYTE> bytes;
            bytes = strPatternToByte(pattern,bytes);
            BYTE somePtr[16];
            for ( int i=0 ; i < 16 ; i++)
            {
                somePtr[i] = bytes[i];
            }
    
    
            for(unsigned char i : somePtr)
            {
                std::cout << i << std::endl;
            }
            /*
             * output should be:
              0x03
              0xC6
              0x8F
             * etc
             * .
             * .
             */
    
            return 0;
    }

it doesn't actually do what i need because when i debug it , i look at the bytes vector and i see it puts 0 in a cell, x in a cell , 0 , in cell , 3 in cell , which is not what i want, is there anyway to solve this kind of problem ? the output aint like it should be, I added what the output should be there in the code something like this:

        /*
     * output should be:
      0x03
      0xC6
      0x8F
     * etc
     * .
     * .
     */

the somePtr array is my last output should be, with as i described up.

thanks.

Answer 1

template <typename T>
std::vector<uint8_t> bytesFromHex(std::basic_istream<T>& stream, size_t reserve = 0x100)
{
    std::vector<uint8_t> result;
    result.reserve(reserve);
    auto flags = stream.flags();
    stream.setf(std::ios_base::hex, std::ios_base::basefield);
    std::copy(std::istream_iterator<unsigned>{stream}, {}, std::back_inserter(result));
    stream.flags(flags);
    return result;
}

template <typename T>
std::vector<uint8_t> bytesFromHex(std::basic_string_view<T> s, size_t reserve = 0x100)
{
    std::basic_istringstream<T> stream{std::basic_string<T>{s}};
    return bytesFromHex(stream, reserve);
}

https://godbolt.org/z/aW915b

Answer 2

You have a number of minor errors.

By reusing your converter object it no longer works after the first conversion because it gets into an error state. Try this version that recreates the stringstream each time round the loop (you could also call converter.clear(); at the end of the loop).

while (ss >> word)
{
    int temp;
    std::stringstream converter;
    converter << std::hex << "0x" + word;
    converter >> temp;
    bytes.push_back(temp);
}

Also temp should be an int (you are reading integers after all).

The output loop is wrong, try this

 for (int i : somePtr)
 {
     std::cout << "0x" << std::hex << std::setfill('0') << std::setw(2) << i << std::endl;
 }

Again note that i is an int, and I've added formatting to get the effect you wanted. You will need to #include <iomanip>

Answer 3

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

typedef unsigned char BYTE; // Remove this line if you've included windows.h

std::vector<BYTE> strPatternToByte(std::string hex_chars) {
    std::istringstream hex_chars_stream(hex_chars);
    std::vector<BYTE> bytes;
    unsigned c;
    hex_chars_stream >> std::hex;
    while (hex_chars_stream >> c) bytes.push_back(c);
    return bytes;
}

int main() {
    std::string hex_chars = "03 C6 8F E2 18 CA 8C E2 D4 FD BC E5 03 C6 8F E2";
    auto bytes = strPatternToByte(hex_chars);
    std::cout << std::setfill('0') << std::hex << std::uppercase;
    for (unsigned i : bytes) std::cout << "0x" << std::setw(2) << i << '\n';
}

Output :

0x03
0xC6
0x8F
0xE2
0x18
0xCA
0x8C
0xE2
0xD4
0xFD
0xBC
0xE5
0x03
0xC6
0x8F
0xE2