Tag: utility

It seems useful, although you could achieve something similar with a debugger, which in the end is much more powerful. See this post on how to make GDB give a similar output.

Because the code would be much cleaner if you could use std::format(). You can make it compatible with previous versions by detecting if there is compatibility with C ++ 20, otherwise resort to fmtlib.

I think it would be much cleaner if hd() It took a reference and has the default size for the type size:

template
hd(const T &buf, std::size_t bufsz = sizeof(T)): buffer{...}, bufsize{...} {}

And then you could use it as:

auto d1 = Dummy{};
std::cout << hd(d1) << 'n';

Of course, it becomes a bit more difficult to use if you want to dump arbitrary memory, but it is a trade off. I think it would benefit beginners, who may not know the size of the types, or can easily make mistakes like writing hd(some_pointer, sizeof(some_pointer)). You may have two different classes, or have a version that only takes a reference and does not have size, and one that takes an empty pointer and a size.

I think it's better if you throw unsigned char * as soon as possible (in hd& # 39; s builder), and stick with it. This avoids some releases in other parts of your code. The only time you want to issue it again is when you print the value of a pointer in print_ptr().

Even better, use std::byte *, and only converts a std::byte to char when you need to print it as a character directly.

The function hex_dump() It is a bit messy It would be better if it were divided into more functions, delegating more work to print_*() functions in particular have print_bytes() it takes a length to print a range of bytes at once. Add a print_ascii() which prints a range of bytes as printable ASCII characters.

You can move the handling of the area before and after the buffer to the print_*() functions, avoiding the special housing in hex_dump() itself. For example:

constexpr std::size_t linesize{16};
auto buf{buffer};
size_t pre = reinterpret_cast(buffer) % maxline; // Size of pre-buffer area
buf -= pre; // Align buf and bufsize to start of pre-buffer area
bufsize += pre;

while (bufsize) {
    // Calculate the length of the post-buffer area on this line
    size_t post = bufsize < linesize ? linesize - bufsize : 0;

    // Print the line
    print_ptr(os, buf);
    os << ": ";
    print_bytes(os, buf, linesize, pre, post);
    os << " | ";
    print_ascii(os, buf, linesize, pre, post);
    os << "n";

    buf += linesize;
    bufsize -= linesize - post; // Advance to next line, avoiding wrapping
    pre = 0;                    // No pre-buffer area after first line
}

I can think of use cases in which I would like to see pointers as decimal values, possibly even displacements from the beginning of the data instead of absolute values. Maybe this could be made configurable?