#include <iostream>
#include <bitset>
using namespace std;
int main(){
int x=178;
//<?>中的参数是指定输出多少位
cout<<bitset<sizeof(x)*8>(x)<<endl;//int占4字节，一个字节8位，最终输出的是32个0或1
return 0;
C输出二进制
C语言printf 打印十六进制数字0x01
%x输出显示为：0x1，而不是0x01，改为：%02x即可。
代码段如：
printf("\r\n 本机的标准ID号STDId：0x%02x",CAN_stdID);
printf("\r\n 目标主机的标准ID号STDId0：0x%02x",CAN_stdID0);
输出内容为：
本机的标准ID号STDId：0x14
目标主机的标准ID号STDId0：0x01
原文：https://blog.csdn.net/tcjy1000/article/details/41243557
打印十六进制注意：
当我这样做时，printf(" 0x%1x ", pixel_data[0] )我期待着看到0xf5。
但我觉得0xfffffff5我打印出一个4字节的整数而不是1字节。
您可能正在获得一种良性形式的未定义行为，因为%x修饰符需要一个unsigned int参数，并且char通常会int在传递给varargs函数时将其提升为。
您应该显式地将char转换为a unsigned int以获得可预测的结果：
printf(" 0x%1x ", (unsigned)pixel_data[0] );
请注意，字段宽度为1不是很有用。它仅指定要显示的最小位数，并且在任何情况下都至少需要一位数。
如果char您的平台上已签名，则此转换会将负值转换char为较大的unsigned int值（例如fffffff5）。如果你要正确对待字节值都是无符号数，只是零扩展时转换为unsigned int你应该使用unsigned char的pixel_data，或通过浇铸unsigned char或升级后使用屏蔽操作。
printf(" 0x%x ", (unsigned)(unsigned char)pixel_data[0] );
printf(" 0x%x ", (unsigned)pixel_data[0] & 0xffU );
printf, g_message这些函数中，使用 %lld 就可以打印一个unsigned long long了，glib中的guint64就是unsigned long long。这是GNU编译器支持的。在微软的编译器中，使用%lld, %I64都可以。
C语言中如何printf一个unsigned long
用：%lu
main()
{
unsigned long a = 3200000000;/*32亿，超出long int的范围*/
printf("%ld\n%lu\n", a, a);
}
sprintf函数详细解释（转载）
sprintf() 格式化输出函数（图形）
功能： 函数sprintf()用来作格式化的输出。
用法： 此函数调用方式为int sprintf(char *string,char *format,arg_list);
说明： 函数sprintf()的用法和printf()函数一样，只是sprintf()函数给出第一个参数string(一般为字符数组），然后再调用outtextxy()函数将串里的字符显示在屏幕上。arg_list为参数表，可有不定个数。通常在绘图方式下输出数字时可调用sprintf()函数将所要输出的格式送到第一个参数，然后显示输出。
函数名: sprintf
功 能: 送格式化输出到字符串中
用 法: int sprintf(char *string, char *farmat [,argument,...]);
程序例:
#include
#include
int main(void)
{
char buffer[80];
sprintf(buffer, "An approximation of Pi is %f\n", M_PI);
puts(buffer);
return 0;
}
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
% 是告知 sprintf function 在 % 之後的辦視字是要接收參數用的
%s 是接收字串
%d 是接收整數
d 是接收整數，不滿二位的則補0
%3.2f 是接收浮點數，
%% 印出百分比符号，不转换。
%c 整数转成对应的 ASCII 字元(0->0x00,5->0x05, 7->0x07,12->0x0C,255->0xFF)
%d 整数转成十进位。
%f 倍精确度数字转成浮点数。
%o 整数转成八进位。
%s 整数转成字串。
%x 整数转成小写十六进位。
%X 整数转成大写十六进位。
$money = 123.1
$formatted = sprintf (".2f", $money); // 此时变数
$ formatted 值为 "123.10"
$formatted = sprintf (".2f", $money); // 此时变数
$ formatted 值为 "00123.10"
$formatted = sprintf ("%-08.2f", $money); // 此时变数
$ formatted 值为 "123.1000"
$formatted = sprintf ("%.2f%%", 0.95 * 100); // 格式化为百分比
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
$formatted = sprintf ("%-08.2f", $money); // 此时变数
0是 "填空字元" 表示,如果长度不足时就用0来填满。
8格式化后总长度
2f小数位长度，即2位
￠第3行值为"00123.10" 解释:
因为2f是(2位)+小数点符号(1)+前面123(3位)=6位，总长度为8位,故前面用[填空字元]0表示，即00123.10
￠第4行值为"123.1000" 解释:
-号为反向操作，然后填空字元0添加在最后面了
/********************************************************
sprintf的作用是将一个格式化的字符串输出到一个目的字符串中，
printf是将一个格式化的字符串输出到屏
sprintf的第一个参数应该是目的字符串，如果不指定这个参数，执行过程中出现 "该程序产生非法操作,即将被关闭...."的提示。
因为C语言在进行字符串操作时不检查字符串的空间是否够大，所以可能会出现数组越界而导致程序崩溃的问题。
即使碰巧，程序没有出错，也不要这么用，因为早晚会出错。所以一定要在调用sprintf之前分配足够大的空间给buf。
由于sprintf 跟printf 在用法上几乎一样，只是打印的目的地不同而已，前者打印到字符串中，
后者则直接在命令行上输出。
sprintf 是个变参函数，定义如下：
int sprintf( char *buffer, const char *format [, argument] ... );
除了前两个参数类型固定外，后面可以接任意多个参数。而它的精华，显然就在第二个参数：
格式化字符串上。
printf 和sprintf 都使用格式化字符串来指定串的格式，在格式串内部使用一些以“%”开头的
格式说明符（format specifications）来占据一个位置，在后边的变参列表中提供相应的变量，最终
函数就会用相应位置的变量来替代那个说明符，产生一个调用者想要的字符串。
格
式化数字字符串
sprintf 最常见的应用之一莫过于把整数打印到字符串中，所以，spritnf 在大多数场合可以替代
itoa。如：
//把整数123 打印成一个字符串保存在s 中。
sprintf(s, "%d", 123); //产生"123"
可以指定宽度，不足的左边补空格：
sprintf(s, "��", 123, 4567); //产生：" 123 4567"
当然也可以左对齐：
sprintf(s, "%-8d�", 123, 4567); //产生："123 4567"
也可以按照16 进制打印：
sprintf(s, "%8x", 4567); //小写16 进制，宽度占8 个位置，右对齐
sprintf(s, "%-8X", 4568); //大写16 进制，宽度占8 个位置，左对齐
这样，一个整数的16 进制字符串就很容易得到，但我们在打印16 进制内容时，通常想要一
种左边补0 的等宽格式，那该怎么做呢？很简单，在表示宽度的数字前面加个0 就可以了。
sprintf(s, "X", 4567); //产生："000011D7"
上面以”%d”进行的10 进制打印同样也可以使用这种左边补0 的方式。
这里要注意一个符号扩展的问题：比如，假如我们想打印短整数（short）-1 的内存16 进制表
示形式，在Win32 平台上，一个short 型占2 个字节，所以我们自然希望用4 个16 进制数字来打
印它：
short si = -1;
sprintf(s, "X", si);
产生“FFFFFFFF”，怎么回事？因为spritnf 是个变参函数，除了前面两个参数之外，后面的
参数都不是类型安全的，函数更没有办法仅仅通过一个“%X”就能得知当初函数调用前参数压栈
时被压进来的到底是个4 字节的整数还是个2 字节的短整数，所以采取了统一4 字节的处理方式，
导致参数压栈时做了符号扩展，扩展成了32 位的整数-1，打印时4 个位置不够了，就把32 位整数
-1 的8 位16 进制都打印出来了。如果你想看si 的本来面目，那么就应该让编译器做0 扩展而不是
符号扩展（扩展时二进制左边补0 而不是补符号位）：
sprintf(s, "X", (unsigned short)si);
就可以了。或者：
unsigned short si = -1;
sprintf(s, "X", si);
sprintf 和printf 还可以按8 进制打印整数字符串，使用”%o”。注意8 进制和16 进制都不会打
印出负数，都是无符号的，实际上也就是变量的内部编码的直接的16 进制或8 进制表示。
控制浮点数打印格式
浮点数的打印和格式控制是sprintf 的又一大常用功能，浮点数使用格式符”%f”控制，默认保
留小数点后6 位数字，比如：
sprintf(s, "%f", 3.1415926); //产生"3.141593"
但有时我们希望自己控制打印的宽度和小数位数，这时就应该使用：”%m.nf”格式，其中m 表
示打印的宽度，n 表示小数点后的位数。比如：
sprintf(s, ".3f", 3.1415626); //产生：" 3.142"
sprintf(s, "%-10.3f", 3.1415626); //产生："3.142 "
sprintf(s, "%.3f", 3.1415626); //不指定总宽度，产生："3.142"
注意一个问题，你猜
int i = 100;
sprintf(s, "%.2f", i);
会打出什么东东来？“100.00”？对吗？自己试试就知道了，同时也试试下面这个：
sprintf(s, "%.2f", (double)i);
第一个打出来的肯定不是正确结果，原因跟前面提到的一样，参数压栈时调用者并不知道跟i
相对应的格式控制符是个”%f”。而函数执行时函数本身则并不知道当年被压入栈里的是个整数，
于是可怜的保存整数i 的那4 个字节就被不由分说地强行作为浮点数格式来解释了，整个乱套了。
不过，如果有人有兴趣使用手工编码一个浮点数，那么倒可以使用这种方法来检验一下你手
工编排的结果是否正确。?
字符/Ascii 码对照
我们知道，在C/C++语言中，char 也是一种普通的scalable 类型，除了字长之外，它与short，
int，long 这些类型没有本质区别，只不过被大家习惯用来表示字符和字符串而已。（或许当年该把
这个类型叫做“byte”，然后现在就可以根据实际情况，使用byte 或short 来把char 通过typedef 定
义出来，这样更合适些）
于是，使用”%d”或者”%x”打印一个字符，便能得出它的10 进制或16 进制的ASCII 码；反过
来，使用”%c”打印一个整数，便可以看到它所对应的ASCII 字符。以下程序段把所有可见字符的
ASCII 码对照表打印到屏幕上（这里采用printf，注意”#”与”%X”合用时自动为16 进制数增加”0X”
前缀）：
for(int i = 32; i < 127; i++) {
printf("[ %c ]: = 0x%#04X\n", i, i, i);
}
连接字符串
sprintf 的格式控制串中既然可以插入各种东西，并最终把它们“连成一串”，自然也就能够连
接字符串，从而在许多场合可以替代strcat，但sprintf 能够一次连接多个字符串（自然也可以同时
在它们中间插入别的内容，总之非常灵活）。
比如：
char* who = "I";
char* whom = "CSDN";
sprintf(s, "%s love %s.", who, whom); //产生："I love CSDN. "
gprs_establish_connection("UDP","222.197.174.76","2020")
void gprs_establish_connection(char* mode, char* ip, char* port)
{
sprintf(link,"AT+CIPSTART=\"%s\",\"%s\",\"%s\"\r\n",mode,ip,port);
}
link="AT+CIPSTART="UDP\",\"222.197.174.76\",\"2020\"\r\n";
strcat 只能连接字符串（一段以’\0’结尾的字符数组或叫做字符缓冲，null-terminated-string），
但有时我们有两段字符缓冲区，他们并不是以’\0’结尾。比如许多从第三方库函数中返回的字符数
组，从硬件或者网络传输中读进来的字符流，它们未必每一段字符序列后面都有个相应的’\0’来结
尾。
如果直接连接，不管是sprintf 还是strcat 肯定会导致非法内存操作，而strncat 也至少要求第
一个参数是个null-terminated-string，那该怎么办呢？我们自然会想起前面介绍打印整数和浮点数
时可以指定宽度，字符串也一样的。比如：
char a1[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
char a2[] = {'H', 'I', 'J', 'K', 'L', 'M', 'N'};
如果：
sprintf(s, "%s%s", a1, a2); //Don't do that!
十有八九要出问题了。是否可以改成：
sprintf(s, "%7s%7s", a1, a2);
也没好到哪儿去，正确的应该是：
sprintf(s, "%.7s%.7s", a1, a2);//产生："ABCDEFGHIJKLMN"
这可以类比打印浮点数的”%m.nf”，在”%m.ns”中，m 表示占用宽度（字符串长度不足时补空
格，超出了则按照实际宽度打印），n 才表示从相应的字符串中最多取用的字符数。通常在打印字
符串时m 没什么大用，还是点号后面的n 用的多。自然，也可以前后都只取部分字符：
sprintf(s, "%.6s%.5s", a1, a2);//产生："ABCDEFHIJKL"
在许多时候，我们或许还希望这些格式控制符中用以指定长度信息的数字是动态的，而不是
静态指定的，因为许多时候，程序要到运行时才会清楚到底需要取字符数组中的几个字符，这种
动态的宽度/精度设置功能在sprintf 的实现中也被考虑到了，sprintf 采用”*”来占用一个本来需要一
个指定宽度或精度的常数数字的位置，同样，而实际的宽度或精度就可以和其它被打印的变量一
样被提供出来，于是，上面的例子可以变成：
sprintf(s, "%.*s%.*s", 7, a1, 7, a2);
或者：
sprintf(s, "%.*s%.*s", sizeof(a1), a1, sizeof(a2), a2);
实际上，前面介绍的打印字符、整数、浮点数等都可以动态指定那些常量值，比如：
sprintf(s, "%-*d", 4, 'A'); //产生"65 "
sprintf(s, "%#0*X", 8, 128); //产生"0X000080"，"#"产生0X
sprintf(s, "%*.*f", 10, 2, 3.1415926); //产生" 3.14"
打印地址信息
有时调试程序时，我们可能想查看某些变量或者成员的地址，由于地址或者指针也不过是个32 位的数，你完全可以使用打印无符号整数的”%u”把他们打印出来：
sprintf(s, "%u", &i);
不过通常人们还是喜欢使用16 进制而不是10 进制来显示一个地址：
sprintf(s, "X", &i);
然而，这些都是间接的方法，对于地址打印，sprintf 提供了专门的”%p”：
sprintf(s, "%p", &i);
我觉得它实际上就相当于：
sprintf(s, "%0*x", 2 * sizeof(void *), &i);
利用sprintf 的返回值
较少有人注意printf/sprintf 函数的返回值，但有时它却是有用的，spritnf 返回了本次函数调用
最终打印到字符缓冲区中的字符数目。也就是说每当一次sprinf 调用结束以后，你无须再调用一次
strlen 便已经知道了结果字符串的长度。如：
int len = sprintf(s, "%d", i);
对于正整数来说，len 便等于整数i 的10 进制位数。
下面的是个完整的例子，产生10 个[0, 100)之间的随机数，并将他们打印到一个字符数组s 中，
以逗号分隔开。
#include
#include
#include
int main() {
srand(time(0));
char s[64];
int offset = 0;
for(int i = 0; i < 10; i++) {
offset += sprintf(s + offset, "%d,", rand() % 100);
}
s[offset - 1] = '\n';//将最后一个逗号换成换行符。
printf(s);
return 0;
}
设想当你从数据库中取出一条记录，然后希望把他们的各个字段按照某种规则连接成一个字
符串时，就可以使用这种方法，从理论上讲，他应该比不断的strcat 效率高，因为strcat 每次调用
都需要先找到最后的那个’\0’的位置，而在上面给出的例子中，我们每次都利用sprintf 返回值把这
个位置直接记下来了。
使用sprintf 的常见问题
sprintf 是个变参函数，使用时经常出问题，而且只要出问题通常就是能导致程序崩溃的内存访
问错误，但好在由sprintf 误用导致的问题虽然严重，却很容易找出，无非就是那么几种情况，通
常用眼睛再把出错的代码多看几眼就看出来了。
?? 缓冲区溢出
第一个参数的长度太短了，没的说，给个大点的地方吧。当然也可能是后面的参数的问
题，建议变参对应一定要细心，而打印字符串时，尽量使用”%.ns”的形式指定最大字符数。
?? 忘记了第一个参数
低级得不能再低级问题，用printf 用得太惯了。//偶就常犯。：。（
?? 变参对应出问题
通常是忘记了提供对应某个格式符的变参，导致以后的参数统统错位，检查检查吧。尤
其是对应”*”的那些参数，都提供了吗？不要把一个整数对应一个”%s”，编译器会觉得你
欺她太甚了（编译器是obj 和exe 的妈妈，应该是个女的，:P）。
strftime
sprnitf 还有个不错的表妹：strftime，专门用于格式化时间字符串的，用法跟她表哥很像，也
是一大堆格式控制符，只是毕竟小姑娘家心细，她还要调用者指定缓冲区的最大长度，可能是为
了在出现问题时可以推卸责任吧。这里举个例子：
time_t t = time(0);
//产生"YYYY-MM-DD hh:mm:ss"格式的字符串。
char s[32];
strftime(s, sizeof(s), "%Y-%m-%d %H:%M:%S", localtime(&t));
sprintf 在MFC 中也能找到他的知音：CString::Format，strftime 在MFC 中自然也有她的同道：
CTime::Format，这一对由于从面向对象哪里得到了赞助，用以写出的代码更觉优雅。
后记
本文介绍的所有这些功能，在MSDN 中都可以很容易地查到，笔者只是根据自己的使用经验，
结合一些例子，把一些常用的，有用的，而可能为许多初学者所不知的用法介绍了一点，希望大
家不要笑话，也希望大家批评指正。
有人认为这种带变参的函数会引起各种问题，因而不提倡使用。但笔者本人每每还是抵挡不
了它们强大功能的诱惑，在实际工作中一直在使用。实际上，C#.NET 从开始就支持变参，刚发布
不久的Java5.0 也支持变参了。
感谢ericzhangali（另一个空间）仔细审阅了全稿，纠正了很多小错误，并提出了一些建议。
也感谢laomai（老迈）阅读了全稿并给出了增删一些内容的建议。
sprintf
百科名片
将字串格式化命令。sprintf 是个变参函数，使用时经常出问题，而且只要出问题通常就是能导致程序崩溃的内存访 问错误，但好在由sprintf 误用导致的问题虽然严重，却很容易找出，无非就是那么几种情况，通 常用眼睛再把出错的代码多看几眼就看出来了。
sprintf_百度百科
1、数值转成字符：sprintf个函数，如： sprintf(s, "%d", 123); //产生"123"2、字符串转成数值：while(*BandRate='\0') {num=num*10+(*BandRate-'0'); BandRate++; }char test_char[7]={0}; unsigned int cc=60000;...
format-- 这是字符串，包含了要被写入到标准输出 stdout 的文本。
它可以包含嵌入的 format 标签，format 标签可被随后的附加参数中指定的值替换，并按需求进行格式化。
format 标签属性是%[flags][width][.precision][length]specifier，...
在Stackoverflow看到的一个很好用的代码，在检查程序的时候可以很好的检查各种情况，分享给大家。
https://stackoverflow.com/questions/111928/is-there-a-printf-converter-to-print-in-binary-format
代码如下：
// Assumes little endian
void printBits(size_t const size, void const * const pt
printf用法之打印2进制，八进制，十进制，十六进制
printf是格式化输出函数，它可以直接打印十进制，八进制，十六进制，输出控制符分别为%d, %o, %x, 但是它不存在二进制，如果输出二进制，可以手写，但是也可以调用stdlib.h里面的itoa函数，他不是标准库里面的函数，但是大多数编译器里面都有这个函数，所以就介绍一下
itoa函数的原型为char* itoa(int value, char * string, int radix); int value 被转换的整数，char *string
C语言中，在需要用到16进制数据的时候，可以通过printf函数的%x格式打印数据的16进制形式。在某些位标记、位操作的场合，需要用到2进制格式的数据，但printf函数不能输出2进制格式，虽然可以通过使用itoa或_itoa的方法转为2进制的字符串打印，但显示的长度是不固定的，无法显示有效数位前面的0。
例如：现在需要打印数字258的2进制格式，且需要将32位全部显示出来，即想要得到结果00000000 00000000 00000001 00000010，而使用_itoa的方法和打印结果为：
在我们日常的编程中，有时候需要格式化输出一个整形数据的二进制，但是在我们C语言中只有输出十进制：%d；输出十六进制：%x；输出单个字符：%c；输出字符串：%s，输出变量所在的地址：%p。而并没有这种二进制对应的格式，所以需要我们手动来实现。
2.源码实现
本篇博客给大家介绍两种方法：
1.通过库函数itoa，需要包含头文件：#include <stdlib.h>；
2.通过十进制转成二进制的常用方法——短除法；
为方便大家使用，将两种方法都封装成了函数，源码如下：
#include &
printf("a=%ho, b=%o, c=%lo\n", a, b, c); //以八进制形似输出
printf("a=%hd, b=%d, c=%ld\n", a, b, c); //以十进制形式输出
1. 将要输出的数字转换为二进制形式。你可以使用位运算符和逻辑运算符来实现这个转换。
2. 使用printf函数的格式化字符串来指定输出的格式。在格式化字符串中，使用"%b"来表示输出的是二进制数。
以下是一个示例代码，展示了如何使用printf输出一个整数的二进制表示：
#include <stdio.h>
void printBinary(int num) {
if (num == 0) {
printf("0"); // 如果输入的数字是0，直接输出0
return;
int bits[32]; // 假设整数是32位的，可以根据需要调整数组大小
int i = 0;
while (num > 0) {
bits[i] = num % 2; // 取余数，得到最低位的二进制数
num = num / 2; // 除以2，相当于右移一位
for (int j = i - 1; j >= 0; j--) {
printf("%d", bits[j]); // 倒序输出二进制数
int main() {
int number = 10;
printf("Binary representation of %d: ", number);
printBinary(number);
printf("\n");
return 0;
运行上述代码将输出：Binary representation of 10: 1010
可能包含与特定主机相关的系统消息或管理消息，具体取决于测试配置和操作系统环境。
summary.html：
主要报告文件，Vdbench测试的总结信息，可能包括整体性能指标和统计数据。除第一个interval外的所有interval的加权平均值。这是获取测试统计平均数的关键文件，包含IOPS、MB/sec、平均响应时间等关键指标。
totals.html：
测试运行结束后的总体性能统计，包括所有interval的累积平均值。它是获取总体性能测试结果的有用资源。
swat_mon.txt 和 swat_mon_total.txt：
当vdbench与Sun StorageTek Workload Analysis Tool (Swat) 结合使用时，这些文件包含用于性能分析的轨迹文件信息。它们支持使用Swat Performance Monitor (SPM) 创建性能图表。
请注意，具体的文件内容和格式可能因vdbench的版本和测试配置而异。因此，在分析和解释这些文件时，请参考相应的vdbench文档和测试配置。
【ceph】vdbench使用教程--裸盘和文件系统测试vdbench
bandaoyu:
【存储】cosbench对象存储测试工具
bandaoyu:
1阶段说明，
2提交方式补充命令行提交
【DAOS】daos client和dfuse 是什么？
bandaoyu:
【DAOS】daos client和dfuse 是什么？
bandaoyu:
