How to create a hex dump from binary data in C++

http://stahlworks.com/dev/index.php?tool=csc01

How to create a hex dump from binary data in C++ with a few lines of code:
free source code examples for instant use in any project, for windows and linux.

starting point: let's say we have a simple program like this:

#include <stdio.h>

int main(int argc, char *argv[])
{
char abStack[100];

printf("hello world, abStack == %p\n", abStack);
}

and we want to see the binary contents of abStack in a well-formatted hex dump.

solution 1: triple-column hex dump with ASCII representation

#include <stdio.h>
#include <ctype.h>

void hexdump(void *pAddressIn, long  lSize)
{
char szBuf[100];
long lIndent = 1;
long lOutLen, lIndex, lIndex2, lOutLen2;
long lRelPos;
struct { char *pData; unsigned long lSize; } buf;
unsigned char *pTmp,ucTmp;
unsigned char *pAddress = (unsigned char *)pAddressIn;

buf.pData   = (char *)pAddress;
buf.lSize   = lSize;

while (buf.lSize > 0)
{
pTmp     = (unsigned char *)buf.pData;
lOutLen  = (int)buf.lSize;
if (lOutLen > 16)
lOutLen = 16;

// create a 64-character formatted output line:
sprintf(szBuf, " >                            "
"                      "
"    %08lX", pTmp-pAddress);
lOutLen2 = lOutLen;

for(lIndex = 1+lIndent, lIndex2 = 53-15+lIndent, lRelPos = 0;
lOutLen2;
lOutLen2--, lIndex += 2, lIndex2++
)
{
ucTmp = *pTmp++;

sprintf(szBuf + lIndex, "%02X ", (unsigned short)ucTmp);
if(!isprint(ucTmp))  ucTmp = '.'; // nonprintable char
szBuf[lIndex2] = ucTmp;

if (!(++lRelPos & 3))     // extra blank after 4 bytes
{  lIndex++; szBuf[lIndex+2] = ' '; }
}

if (!(lRelPos & 3)) lIndex--;

szBuf[lIndex  ]   = '<';
szBuf[lIndex+1]   = ' ';

printf("%s\n", szBuf);

buf.pData   += lOutLen;
buf.lSize   -= lOutLen;
}
}

int main(int argc, char *argv[])
{
char abStack[100];

printf("hello world, dump of abStack follows:\n");
hexdump(abStack, 100);
}

example output:

hello world, dump of abStack follows:
>08080000 00000000 00003200 88000000< ..........2..... 00000000
>08080000 781B3200 00003200 8CFC1200< ....x.2...2..... 00000010
>90FC1200 B0FF1200 F088F977 94BEF477< ...........w...w 00000020
>9161E577 D0FE1200 B8FE1200 999E3600< .a.w..........6. 00000030
>00000000 E0FE1200 1B504000 D0FE1200< .........P@..... 00000040
>04904000 27B243B6 03000000 A6D26C36< ..@.'.C.......l6 00000050
>CA00C701<                            ....             00000060

the above hexdump() function provides

the raw binary data as hex values, in groups of 4 bytes, with 16 bytes per line

an ascii representation of the data, where printable

the hex offset of each record (line)

if you don't want the output on terminal but, for example, into a file-based tracing system like mtk, simply change the printf statement within hexdump().

the above example dumps only 16 data bytes per record. if you need
something more compact, try this:

solution 2: hex dump with 32 data bytes, 85 chars per output line

#include <stdio.h>
#include <ctype.h>

void hexdump(void *pAddressIn, long  lSize)
{
char szBuf[100];
long lIndent = 1;
long lOutLen, lIndex, lIndex2, lOutLen2;
long lRelPos;
struct { char *pData; unsigned long lSize; } buf;
unsigned char *pTmp,ucTmp;
unsigned char *pAddress = (unsigned char *)pAddressIn;

buf.pData   = (char *)pAddress;
buf.lSize   = lSize;

while (buf.lSize > 0)
{
pTmp     = (unsigned char *)buf.pData;
lOutLen  = (int)buf.lSize;
if (lOutLen > 32)
lOutLen = 32;

// create a 85-character formatted output line:
sprintf(szBuf, "                              "
"                              "
"              [%08lX]", pTmp-pAddress);
lOutLen2 = lOutLen;

for(lIndex = lIndent, lRelPos = 0;
lOutLen2;
lOutLen2--, lIndex += 2
)
{
ucTmp = *pTmp++;

sprintf(szBuf + lIndex, "%02X ", (unsigned short)ucTmp);

if (!(++lRelPos & 3))     // extra blank after 4 bytes
lIndex++;
}

if (!(lRelPos & 3)) lIndex--;

szBuf[lIndex+1] = ' ';

printf("%s\n", szBuf);

buf.pData   += lOutLen;
buf.lSize   -= lOutLen;
}
}

int main(int argc, char *argv[])
{
char abStack[100];

printf("hello world, dump of abStack follows:\n");
hexdump(abStack, 100);
}

example output follows (some bytes in the middle have been replaced by "(...)"):

hello world, dump of abStack follows:
08080000 00000000 00003200 (...) 781B3200 00003200 8CFC1200  [00000000]
90FC1200 B0FF1200 F088F977 (...) D0FE1200 B8FE1200 999E3600  [00000020]
00000000 E0FE1200 5B4D4000 (...) 852A9A06 05000000 8C3F15E2  [00000040]
CD00C701                   (...)                             [00000060]

the most compact solution uses only 76 characters per output line:

solution 3: hex dump with 32 data bytes, 76 chars per output line

#include <stdio.h>
#include <ctype.h>

void hexdump(void *pAddressIn, long  lSize)
{
char szBuf[100];
long lIndent = 0;
long lOutLen, lIndex, lIndex2, lOutLen2;
long lRelPos;
struct { char *pData; unsigned long lSize; } buf;
unsigned char *pTmp,ucTmp;
unsigned char *pAddress = (unsigned char *)pAddressIn;

buf.pData   = (char *)pAddress;
buf.lSize   = lSize;

while (buf.lSize > 0)
{
pTmp     = (unsigned char *)buf.pData;
lOutLen  = (int)buf.lSize;
if (lOutLen > 32)
lOutLen = 32;

// create a 76-character formatted output line:
sprintf(szBuf, "                              "
"                              "
"      [%08lX]", pTmp-pAddress);
lOutLen2 = lOutLen;

for(lIndex = lIndent, lRelPos = 0;
lOutLen2;
lOutLen2--, lIndex += 2
)
{
ucTmp = *pTmp++;
sprintf(szBuf + lIndex, "%02X ", (unsigned short)ucTmp);
}

szBuf[lIndex+1] = ' ';

printf("%s\n", szBuf);

buf.pData   += lOutLen;
buf.lSize   -= lOutLen;
}
}

int main(int argc, char *argv[])
{
char abStack[100];

printf("hello world, dump of abStack follows:\n");
hexdump(abStack, 100);
}

example output follows (some bytes in the middle have been replaced by "(...)"):

080800000000000000003200 (...) 781B3200000032008CFC1200  [00000000]
90FC1200B0FF1200F088F977 (...) D0FE1200B8FE1200999E3600  [00000020]
00000000E0FE12002B4D4000 (...) AE6E71210500000054B6122D  [00000040]
CE00C701                 (...)                           [00000060]