输出内存数据的二进制和十六进制的字符串表示



场景:

1. 在读取文件或内存时，有时候需要输出那段内存的十六或二进制表示进行分析。

2. 标准的printf没有显示二进制的,而%x显示有最大上限，就是8字节，超过8字节就不行了。

test_binary_hex.cpp

[cpp] view plain copy print ?

1. #include <stdlib.h>  
2. #include <string.h>  
3. #include <stdio.h>  
4. #include <assert.h>  
5. #include <stdint.h>  
6. #include <iostream>  
7.   
8. std::string ToBinaryString(const uint8_t* buf,int len)  
9. {  
10.     int output_len = len*8;  
11.     std::string output;  
12.     const char* m[] = {"0","1"};  
13.   
14.     for(int i = output_len - 1,j = 0; i >=0 ; --i,++j)  
15.     {  
16.         output.append(m[((uint8_t)buf[j/8] >> (i % 8)) & 0x01],1);  
17.     }  
18.     return output;  
19. }  
20.   
21. std::string ToHexString(const uint8_t* buf,int len,std::string tok = "")  
22. {  
23.     std::string output;  
24.     char temp[8];  
25.     for (int i = 0; i < len; ++i)  
26.     {  
27.         sprintf(temp,"0x%.2x",(uint8_t)buf[i]);  
28.         output.append(temp,4);  
29.         output.append(tok);  
30.     }  
31.   
32.     return output;  
33. }  
34.   
35. int main(int argc, char const *argv[])  
36. {  
37.     printf("0x%.2x\n",1);  
38.   
39.     uint8_t buf[] = {0x80,0x0f,0x51,0xEE,0xA7};  
40.     std::string output = ToBinaryString(buf,2);  
41.     std::string output_hex = ToHexString(buf,2,":");  
42.     std::cout << output << std::endl;  
43.     std::cout << output_hex << std::endl;  
44.     assert(!strcmp(output.c_str(),"1000000000001111"));  
45.       
46.     output = ToBinaryString(buf,3);  
47.     std::cout << output << std::endl;  
48.     assert(!strcmp(output.c_str(),"100000000000111101010001"));  
49.       
50.   
51.     output = ToBinaryString(buf,4);  
52.     assert(!strcmp(output.c_str(),"10000000000011110101000111101110"));  
53.     std::cout << output << std::endl;  
54.   
55.     output = ToBinaryString(buf,5);  
56.     assert(!strcmp(output.c_str(),"1000000000001111010100011110111010100111"));  
57.     std::cout << output << std::endl;  
58.   
59.     return 0;  
60. }  

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <stdint.h>
#include <iostream>

std::string ToBinaryString(const uint8_t* buf,int len)
{
	int output_len = len*8;
	std::string output;
	const char* m[] = {"0","1"};

	for(int i = output_len - 1,j = 0; i >=0 ; --i,++j)
	{
		output.append(m[((uint8_t)buf[j/8] >> (i % 8)) & 0x01],1);
	}
	return output;
}

std::string ToHexString(const uint8_t* buf,int len,std::string tok = "")
{
	std::string output;
	char temp[8];
	for (int i = 0; i < len; ++i)
	{
		sprintf(temp,"0x%.2x",(uint8_t)buf[i]);
		output.append(temp,4);
		output.append(tok);
	}

	return output;
}

int main(int argc, char const *argv[])
{
	printf("0x%.2x\n",1);

	uint8_t buf[] = {0x80,0x0f,0x51,0xEE,0xA7};
	std::string output = ToBinaryString(buf,2);
	std::string output_hex = ToHexString(buf,2,":");
	std::cout << output << std::endl;
	std::cout << output_hex << std::endl;
	assert(!strcmp(output.c_str(),"1000000000001111"));
	
	output = ToBinaryString(buf,3);
	std::cout << output << std::endl;
	assert(!strcmp(output.c_str(),"100000000000111101010001"));
	

	output = ToBinaryString(buf,4);
	assert(!strcmp(output.c_str(),"10000000000011110101000111101110"));
	std::cout << output << std::endl;

	output = ToBinaryString(buf,5);
	assert(!strcmp(output.c_str(),"1000000000001111010100011110111010100111"));
	std::cout << output << std::endl;

	return 0;
}

输出:

[plain] view plain copy print ?

1. 0x01  
2. 1000000000001111  
3. 0x80:0x0f:  
4. 100000000000111101010001  
5. 10000000000011110101000111101110  
6. 1000000000001111010100011110111010100111