for this code -
int main()
{
std::wstring wstr = L"é";
std::wstring_convert<std::codecvt_utf8<wchar_t>> myconv;
std::stringstream ss;
ss << std::hex << std::setfill('0');
for (auto c : myconv.to_bytes(wstr))
{
ss << std::setw(2) << static_cast<unsigned>(c);
}
string ssss = ss.str();
cout << "ssss = " << ssss << endl;
Why does this print ffffffc3ffffffa9
instead of c3a9?
Why does it append ffffff in beginning?
If you want to run it in ideone - https://ideone.com/qZtGom
c is of type char, which is signed on most systems.
Converting a char to an unsigned causes value to be sign-extended.
Examples:
char(0x23) aka 35 --> unsigned(0x00000023)
char(0x80) aka -128 --> unsigned(0xFFFFFF80)
char(0xC3) aka -61 --> unsigned(0xFFFFFFc3)
[edit: My first suggestion didn't work; removed]
You can cast it twice:
ss << std::setw(2) << static_cast<int>(static_cast<unsigned char>(c));
The first cast gives you an unsigned type with the same bit pattern, and since unsigned char is the same size as char, there is no sign extension.
But if you just output static_cast<unsigned char>(c), the stream will treat it as a character, and print .. something .. depending on your locale, etc.
The second cast gives you an int, which the stream will output correctly.
In this code:
// read bootrom
std::ifstream bootrom_file (bootrom_path, std::ios::binary | std::ios::ate);
const int bootrom_size = bootrom_file.tellg();
bootrom_file.seekg(0, std::ios_base::beg);
// allocate bootrom_size bytes for the bootrom vector
bootrom.resize(bootrom_size);
if(bootrom_size != 0x100)
{
std::cerr << "boot ROM is not 256 bytes!\n";
}
if(bootrom_file)
{
bootrom_file.read(reinterpret_cast<char*>(bootrom.data()), bootrom_size);
}
// prints 0xC3 0x31
printf("%#02x %#02x\n", rom[0], bootrom[0]);
// prints ? 1
std::cout << std::hex << rom[0] << " " << std::hex << bootrom[0] << "\n";
std::cout prints out ? 1, but printf prints out 0xC3 0x31 which is correct. What am I doing wrong here?
Note that rom and bootrom are both std::vector of uint8_t, and rom is set using the same code as bootrom.
Solution: I figured it out. Turns out that std::cout cannot print uint8_t by value since it is a typedef char, so it prints the ascii character instead.
I have been programming a while but I am fairly new to C++. I am writing a program that takes an .exe and gets its hex and stores it in and unsigned char array. I can take in the .exe and return its hex fine. My problem is I am having trouble storing the hex in the correct format in the char array.
When I print the array it outputs the hex but I need to add 0x to the front.
Sample output: 04 5F 4B F4 C5 A5
Needed output: 0x04 0x5F 0x4B 0xF4 0xC5 0xA5
I am trying to use hexcode[i] = ("0x%.2X", (unsigned char)c); to store it correctly and it still only seems to return the last two chars without the 0x.
I have also tried hexcode[i] = '0x' + (unsigned char)c; and looked into functions like sprintf.
Can anyone help me get my desired output? Is it even possible?
Full program -
#include <iostream>
unsigned char hexcode[99999] = { 0 };
//Takes exes hex and place it into unsigned char array
int hexcoder(std::string file) {
FILE *sf; //executable file
int i, c;
sf = fopen(file.c_str(), "rb");
if (sf == NULL) {
fprintf(stderr, "Could not open file.", file.c_str());
return 1;
}
for (i = 0;;i++) {
if ((c = fgetc(sf)) == EOF) break;
hexcode[i] = ("0x%.2X", (unsigned char)c);
//Print for debug
std::cout << std::hex << static_cast<int>(hexcode[i]) << ' ';
}
}
int main()
{
std::string file = "shuffle.exe"; // test exe to pass to get hex
hexcoder(file);
system("pause");
return 0;
}
I suppose you want to dump a file in hex format. So maybe it's something like the following code you are looking for.
Note that hexcode is changed to data type char instead of unsigned char such that it can be handled as a string containing printable characters.
int hexcoder(std::string file) {
FILE *sf; //executable file
int i, c;
sf = fopen(file.c_str(), "rb");
if (sf == NULL) {
fprintf(stderr, "Could not open file %s.", file.c_str());
return 1;
}
char hexcode[10000];
char* wptr = hexcode;
for (i = 0;;i++) {
if ((c = fgetc(sf)) == EOF) break;
wptr += sprintf(wptr,"0x%02X ", c);
}
*wptr = 0;
std::cout << hexcode;
return 0;
}
BTW: for printing out a value in hex format one could as well use...
printf("0x%2X ", c)
or
std::cout << "0x" << std::hex << std::setw(2) << std::setfill('0') << std::uppercase << c << " ";
Note that the latter requires #include <iomanip>.
But - in order to not change the semantics of your code too much - I kept the hexcode-string as target.
I have a problem I neither can solve on my own nor find answer anywhere. I have a file contains such a string:
01000000d08c9ddf0115d1118c7a00c04
I would like to read the file in the way, that I would do manually like that:
char fromFile[] =
"\x01\x00\x00\x00\xd0\x8c\x9d\xdf\x011\x5d\x11\x18\xc7\xa0\x0c\x04";
I would really appreciate any help.
I want to do it in C++ (the best would be vc++).
Thank You!
int t194(void)
{
// imagine you have n pair of char, for simplicity,
// here n is 3 (you should recognize them)
char pair1[] = "01"; // note:
char pair2[] = "8c"; // initialize with 3 char c-style strings
char pair3[] = "c7"; //
{
// let us put these into a ram based stream, with spaces
std::stringstream ss;
ss << pair1 << " " << pair2 << " " << pair3;
// each pair can now be extracted into
// pre-declared int vars
int i1 = 0;
int i2 = 0;
int i3 = 0;
// use formatted extractor to convert
ss >> i1 >> i2 >> i3;
// show what happened (for debug only)
std::cout << "Confirm1:" << std::endl;
std::cout << "i1: " << i1 << std::endl;
std::cout << "i2: " << i2 << std::endl;
std::cout << "i3: " << i3 << std::endl << std::endl;
// output is:
// Confirm1:
// i1: 1
// i2: 8
// i3: 0
// Shucks, not correct.
// We know the default radix is base 10
// I hope you can see that the input radix is wrong,
// because c is not a decimal digit,
// the i2 and i3 conversions stops before the 'c'
}
// pre-delcare
int i1 = 0;
int i2 = 0;
int i3 = 0;
{
// so we try again, with radix info added
std::stringstream ss;
ss << pair1 << " " << pair2 << " " << pair3;
// strings are already in hex, so we use them as is
ss >> std::hex // change radix to 16
>> i1 >> i2 >> i3;
// now show what happened
std::cout << "Confirm2:" << std::endl;
std::cout << "i1: " << i1 << std::endl;
std::cout << "i2: " << i2 << std::endl;
std::cout << "i3: " << i3 << std::endl << std::endl;
// output now:
// i1: 1
// i2: 140
// i3: 199
// not what you expected? Though correct,
// now we can see we have the wrong radix for output
// add output radix to cout stream
std::cout << std::hex // add radix info here!
<< "i1: " << i1 << std::endl
// Note: only need to do once for std::cout
<< "i2: " << i2 << std::endl
<< "i3: " << i3 << std::endl << std::endl
<< std::dec;
// output now looks correct, and easily comparable to input
// i1: 1
// i2: 8c
// i3: c7
// So: What next?
// read the entire string of hex input into a single string
// separate this into pairs of chars (perhaps using
// string::substr())
// put space separated pairs into stringstream ss
// extract hex values until ss.eof()
// probably should add error checks
// and, of course, figure out how to use a loop for these steps
//
// alternative to consider:
// read 1 char at a time, build a pairing, convert, repeat
}
//
// Eventually, you should get far enough to discover that the
// extracts I have done are integers, but you want to pack them
// into an array of binary bytes.
//
// You can go back, and recode to extract bytes (either
// unsigned char or uint8_t), which you might find interesting.
//
// Or ... because your input is hex, and the largest 2 char
// value will be 0xff, and this fits into a single byte, you
// can simply static_cast them (I use unsigned char)
unsigned char bin[] = {static_cast<unsigned char>(i1),
static_cast<unsigned char>(i2),
static_cast<unsigned char>(i3) };
// Now confirm by casting these back to ints to cout
std::cout << "Confirm4: "
<< std::hex << std::setw(2) << std::setfill('0')
<< static_cast<int>(bin[0]) << " "
<< static_cast<int>(bin[1]) << " "
<< static_cast<int>(bin[2]) << std::endl;
// you also might consider a vector (and i prefer uint8_t)
// because push_back operations does a lot of hidden work for you
std::vector<uint8_t> bytes;
bytes.push_back(static_cast<uint8_t>(i1));
bytes.push_back(static_cast<uint8_t>(i2));
bytes.push_back(static_cast<uint8_t>(i3));
// confirm
std::cout << "\nConfirm5: ";
for (size_t i=0; i<bytes.size(); ++i)
std::cout << std::hex << std::setw(2) << std::setfill(' ')
<< static_cast<int>(bytes[i]) << " ";
std::cout << std::endl;
Note: The cout (or ss) of bytes or char can be confusing, not always giving the result you might expect. My background is embedded software, and I have surprisingly small experience making stream i/o of bytes work. Just saying this tends to bias my work when dealing with stream i/o.
// other considerations:
//
// you might read 1 char at a time. this can simplify
// your loop, possibly easier to debug
// ... would you have to detect and remove eoln? i.e. '\n'
// ... how would you handle a bad input
// such as not hex char, odd char count in a line
//
// I would probably prefer to use getline(),
// it will read until eoln(), and discard the '\n'
// then in each string, loop char by char, creating char pairs, etc.
//
// Converting a vector<uint8_t> to char bytes[] can be an easier
// effort in some ways. A vector<> guarantees that all the values
// contained are 'packed' back-to-back, and contiguous in
// memory, just right for binary stream output
//
// vector.size() tells how many chars have been pushed
//
// NOTE: the formatted 'insert' operator ('<<') can not
// transfer binary data to a stream. You must use
// stream::write() for binary output.
//
std::stringstream ssOut;
// possible approach:
// 1 step reinterpret_cast
// - a binary block output requires "const char*"
const char* myBuff = reinterpret_cast<const char*>(&myBytes.front());
ssOut.write(myBuff, myBytes.size());
// block write puts binary info into stream
// confirm
std::cout << "\nConfirm6: ";
std::string s = ssOut.str(); // string with binary data
for (size_t i=0; i<s.size(); ++i)
{
// because binary data is _not_ signed data,
// we need to 'cancel' the sign bit
unsigned char ukar = static_cast<unsigned char>(s[i]);
// because formatted output would interpret some chars
// (like null, or \n), we cast to int
int intVal = static_cast<int>(ukar);
// cast does not generate code
// now the formatted 'insert' operator
// converts and displays what we want
std::cout << std::hex << std::setw(2) << std::setfill('0')
<< intVal << " ";
}
std::cout << std::endl;
//
//
return (0);
} // int t194(void)
The below snippet should be helpful!
std::ifstream input( "filePath", std::ios::binary );
std::vector<char> hex((
std::istreambuf_iterator<char>(input)),
(std::istreambuf_iterator<char>()));
std::vector<char> bytes;
for (unsigned int i = 0; i < hex.size(); i += 2) {
std::string byteString = hex.substr(i, 2);
char byte = (char) strtol(byteString.c_str(), NULL, 16);
bytes.push_back(byte);
}
char* byteArr = bytes.data()
The way I understand your question is that you want just the binary representation of the numbers, i.e. remove the ascii (or ebcdic) part. Your output array will be half the length of the input array.
Here is some crude pseudo code.
For each input char c:
if (isdigit(c)) c -= '0';
else if (isxdigit(c) c -= 'a' + 0xa; //Need to check for isupper or islower)
Then, depending on the index of c in your input array:
if (! index % 2) output[outputindex] = (c << 4) & 0xf0;
else output[outputindex++] = c & 0x0f;
Here is a function that takes a string as in your description, and outputs a string that has \x in front of each digit.
#include <iostream>
#include <algorithm>
#include <string>
std::string convertHex(const std::string& str)
{
std::string retVal;
std::string hexPrefix = "\\x";
if (!str.empty())
{
std::string::const_iterator it = str.begin();
do
{
if (std::distance(it, str.end()) == 1)
{
retVal += hexPrefix + "0";
retVal += *(it);
++it;
}
else
{
retVal += hexPrefix + std::string(it, it+2);
it += 2;
}
} while (it != str.end());
}
return retVal;
}
using namespace std;
int main()
{
cout << convertHex("01000000d08c9ddf0115d1118c7a00c04") << endl;
cout << convertHex("015d");
}
Output:
\x01\x00\x00\x00\xd0\x8c\x9d\xdf\x01\x15\xd1\x11\x8c\x7a\x00\xc0\x04
\x01\x5d
Basically it is nothing more than a do-while loop. A string is built from each pair of characters encountered. If the number of characters left is 1 (meaning that there is only one digit), a "0" is added to the front of the digit.
I think I'd use a proxy class for reading and writing the data. Unfortunately, the code for the manipulators involved is just a little on the verbose side (to put it mildly).
#include <vector>
#include <algorithm>
#include <iterator>
#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
struct byte {
unsigned char ch;
friend std::istream &operator>>(std::istream &is, byte &b) {
std::string temp;
if (is >> std::setw(2) >> std::setprecision(2) >> temp)
b.ch = std::stoi(temp, 0, 16);
return is;
}
friend std::ostream &operator<<(std::ostream &os, byte const &b) {
return os << "\\x" << std::setw(2) << std::setfill('0') << std::setprecision(2) << std::hex << (int)b.ch;
}
};
int main() {
std::istringstream input("01000000d08c9ddf115d1118c7a00c04");
std::ostringstream result;
std::istream_iterator<byte> in(input), end;
std::ostream_iterator<byte> out(result);
std::copy(in, end, out);
std::cout << result.str();
}
I do really dislike how verbose iomanipulators are, but other than that it seems pretty clean.
You can try a loop with fscanf
unsigned char b;
fscanf(pFile, "%2x", &b);
Edit:
#define MAX_LINE_SIZE 128
FILE* pFile = fopen(...);
char fromFile[MAX_LINE_SIZE] = {0};
char b = 0;
int currentIndex = 0;
while (fscanf (pFile, "%2x", &b) > 0 && i < MAX_LINE_SIZE)
fromFile[currentIndex++] = b;
Lets assume I have this very simple example:
vector<unsigned char> bytes {0xFF, 0xFF, 0xFD};
for (const char & v: bytes) {
cout << hex << setfill('0') << setw(2) << uppercase << static_cast<unsigned>(v) <<" ";
}
cout << endl;
This gives:
FFFFFFFF FFFFFFFF FFFFFFFD
However, I would like to have it short, like:
FF FF FD
So why do I get some many extra "FFFFF"?
for (const char & v: bytes)
You're implicitly converting each element in bytes to a char, which seems to be signed on your platform. Then when you cast to unsigned the char undergoes sign extension and you end up with large hex values.
Change the above to one of the following
for (const unsigned char & v: bytes)
for (auto const& v: bytes)
for (auto v: bytes) // since it's only a char copying might be better
Live demo
You get the desired result if you keep the char unsigned in the loop:
for (const unsigned char & v: bytes) {
// ^^^^^^^^
cout << hex << setfill('0') << setw(2) << uppercase << static_cast<unsigned>(v) <<" ";
}
auto or auto& would work as well, because vector elements are unsigned.
The reason you get FFs is that char on your system is signed, meaning that the values get sign-extended on conversion to integers.
Demo.
As other people said, this happens because you're casting the elements to a signed char. I prefer using a for loop in this way to prevent such mistakes:
vector<unsigned char> bytes{ 0xFF, 0xFF, 0xFD };
for (int i = 0; i < bytes.size(); i++) {
cout << hex << setfill('0') << setw(2) << uppercase << static_cast<unsigned>(bytes[i]) << " ";
}
Using iterators would also be a good idea.