接口:
 
#include 
 
void setbuf(FILE *stream, char *buf);
 
void setbuffer(FILE *stream, char *buf, size_t size);
 
void setlinebuf(FILE *stream)
 
int setvbuf(FILE *stream, char *buf, int mode, size_t size);
 
描述：
 
系统中有三种可用的buffer类型，分别为无Buffer(Unbuffered)，块Buffer(Block Bufferd)和行Buffer(Line Buffered)。当一个流是Unbufferd的时候，往这个Stream中写入的信息会立刻写入目标文件。当Buffer类型是Block Buffered时，往该Stream中写入的信息会先暂存在Buffer中，每次实际的写入都是以块(Block)大小为单位写入目标文件。而当Buffer类型是Line Buffered时，往该Stream中输入的信息都会先暂存在Buffer中直到遇到新的一行，或是从一个终端设备读入例如stdin。fflush()可以强制将Buffer提前清空。
 
通常所有的文件和设备都是Block Buffered，如果任何一个流涉及到终端(例如stdin)那它将是Line Buffer类型。而标准错误流stderr的默认Buffer类型永远是Unbuffered类型。
 
setvbuf()函数或许可以使用在任何打开的Stream中用于改变它的Buffer类型。该函数的参数mode可以是一下三个宏(macros)之一：
 
_IONBF Unbuffered
 
_IOLBF Line Buffered
 
_IOFBF Fully Buffered
 
除了将mode设置成_IONBF,参数buf应当指定一个长度不小于size Byte的buffer。这个指定的buffer将用来代替当前的buffer。如果将buf设为NULL只有将mode设为_IONBF才有效。一个新的buffer应当在下一次读写操作之前分配好。setvbuf()函数可能只有在打开一个stream之后，在所有操作之前有效。
 
其他的三个函数与setvbuf()都比较相似，setbuf()函数实际上等价于下面的调用：
 
setvbuf(stream, buf, buf?_IOFBF:_IONBF,BUFSIZ);
 
serbuffer()函数也是一样，除了buffer的长度size是由参数传入的而不是使用默认的BUFSIZ。setlinebuf()实际上则等价于下面的调用：
 
setvbuf(stream, NULL, _IOLBF, 0);
 
setvbuf()函数返回0表示成功，非0值表示失败(mode是无效的或是请求不能被实现)。如果失败该函数将设置errno值。除了这个函数，其他的三个函数不返回任何值。

 
Routine
 
Use
 
.NET Framework equivalent
 
_memccpy
 
Copy characters from one buffer to another until
 
given character or given number of characters has been copied
 
System::Buffer::BlockCopy,System::String::Copy
 
memchr, wmemchr
 
Return pointer to first occurrence, within
 
specified number of characters, of given character in buffer
 
Not applicable. To call the standard C function,
 
usePInvoke. For more information, see Platform
 
Invoke Examples.
 
memcmp, wmemcmp
 
Compare specified number of characters from two
 
buffers
 
System::String::Compare,System::String::Equals
 
memcpy, wmemcpy,memcpy_s, wmemcpy_s
 
Copy specified number of characters from one buffer
 
to another
 
System::Buffer::BlockCopy,System::String::Copy
 
_memicmp, _memicmp_l
 
Compare specified number of characters from two
 
buffers without regard to case
 
System::String::Compare,System::String::Equals
 
memmove, wmemmove,memmove_s, wmemmove_s
 
Copy specified number of characters from one buffer
 
to another
 
System::Buffer::BlockCopy
 
memset, wmemset
 
Use given character to initialize specified number
 
of bytes in the buffer
 
System::Buffer::SetByte
 
_swab
 
Swap bytes of data and store them at specified
 
location
 
Not applicable. To call the standard C function,
 
usePInvoke. For more information, see Platform
 
Invoke Examples.

 
sprintf函数的用法
 
1、该函数包含在stdio.h的头文件中。
 
2、sprintf和平时我们常用的printf函数的功能很相似。sprintf函数打印到字符串中(要注意字符串的长度要足够容纳打印的内容，否则会出现内存溢出)，而printf函数打印输出到屏幕上。sprintf函数在我们完成其他数据类型转换成字符串类型的操作中应用广泛。
 
3、sprintf函数的格式：
 
int sprintf( char *buffer, const char *format [, argument,…] );
 
除了前两个参数固定外，可选参数可以是任意个。buffer是字符数组名；format是格式化字符串(像：”%3d%6.2f%#x%o”,%与#合用时，自动在十六进制数前面加上0x)。只要在printf中可以使用的格式化字符串，在sprintf都可以使用。其中的格式化字符串是此函数的精华。
 
printf 和sprintf都使用格式化字符串来指定串的格式，在格式串内部使用一些以”%”开头的格式说明符来占据一个位置，在后边的变参列表中提供相应的变量，最终函数就会用相应位置的变量来替代那个说明符，产生一个调用者想要的字符串。
 
4、可以控制精度
 
char str[20];
 
double f=14.309948;
 
sprintf(str,”%6.2f”,f);
 
5、可以将多个数值数据连接起来
 
char str[20];
 
int a=20984,b=48090;
 
sprintf(str,”%3d%6d”,a,b);
 
str[]=”20984 48090”
 
6、可以将多个字符串连接成字符串
 
char str[20];
 
char s1[5]={‘A’,’B’,’C’};
 
char s2[5]={‘T’,’Y’,’x’};
 
sprintf(str,”%.3s%.3s”,s1,s2);
 
%m.n在字符串的输出中，m表示宽度，字符串共占的列数；n表示实际的字符数。%m.n在浮点数中，m也表示宽度；n表示小数的位数。
 
7、可以动态指定，需要截取的字符数
 
char str[20];
 
char s1[5]={‘A’,’B’,’C’};
 
char s2[5]={‘T’,’Y’,’x’};
 
sprintf(str,”%.*s%.*s”,2,s1,3,s2);
 
sprintf(str, “%*.*f”, 10, 2, 3.1415926);
 
8、可以打印出i的地址
 
char str[20];
 
int i;
 
sprintf(str, “%p”, &i);
 
上面的语句相当于
 
sprintf(str, “%0*x”, 2 * sizeof(void *), &i);
 
9、sprintf的返回值是字符数组中字符的个数，即字符串的长度，不用在调用strlen(str)求字符串的长度。
 
10、使用字符指针指向的字符串来接收打印的内容
 
例子：
 
int main()
 
{
 
int ddd=666;
 
char *buffer=NULL;
 
if((buffer = (char *)malloc(80*sizeof(char)))==NULL)
 
{
 
printf("malloc error\n");
 
}
 
sprintf(buffer, "The value of ddd = %d", ddd);//The value of ddd = 666
 
printf("%s\n",buffer);
 
free(buffer);
 
buffer=NULL;
 
return 0;
 
}
 
指针刚开始定义的时候，并不指向所处，可以指向一个变量，然后可以用，如果要单纯用这个指针，那么要给这个指针malloc分配一片内存，加了malloc就要加stdlib.h
 
11、设想当你从数据库中取出一条记录，然后希望把他们的各个字段按照某种规则连接成一个字符串时，就可以使用这种方法，从理论上讲，他应该比strcat 效率高，因为strcat 每次调用都需要先找到最后的那个字符串结束字符’\0的位置，而在上面给出的例子中，我们每次都利用sprintf 返回值把这个位置直接记下来了。
 
例子：
 
void main(void)
 
{
 
char buffer[200], s[] = "computer", c = "l";
 
int i = 35, j;
 
float fp = 1.7320534f; //
 
j = sprintf( buffer, " String: %s\n", s ); //
 
j += sprintf( buffer + j, " Character: %c\n", c ); //
 
j += sprintf( buffer + j, " Integer: %d\n", i ); //
 
j += sprintf( buffer + j, " Real: %f\n", fp );//
 
printf( "Output:\n%s\ncharacter count = %d\n", buffer, j );
 
}
 
该例子是将所有定义的数据和格式控制块中的字符连接在一起，最后打印出来buffer的内容和字符串中字符的个数。
 
结果如图所示：
 

 
12、 格式化数字字符串
 
sprintf最常见的应用之一莫过于把整数打印到字符串中。如：
 
(1)把整数123打印成一个字符串保存在s中。
 
sprintf(s, “%d”, 123); //产生“123″
 
(2)可以指定宽度，不足的左边补空格：
 
sprintf(s, “%8d%8d”, 123, 4567); //产生：“ 123 4567″
 
当然也可以左对齐：
 
sprintf(s, “%-8d%8d”, 123, 4567); //产生：“123 4567″
 
(3)也可以按照16进制打印：
 
sprintf(s, “%8x”, 4567); //小写16进制，宽度占8个位置，右对齐
 
sprintf(s, “%-8X”, 4568); //大写16进制，宽度占8个位置，左对齐
 
这样，一个整数的16进制字符串就很容易得到，但我们在打印16进制内容时，通常想要一种左边补0的等宽格式，那该怎么做呢？很简单，在表示宽度的数字前面加个0就可以了。
 
sprintf(s, “%08X”, 4567); //产生：“000011D7″
 
上面以”%d”进行的10进制打印同样也可以使用这种左边补0的方式。
 
这里要注意一个符号扩展的问题：比如，假如我们想打印短整数
 
(4)(short)-1的内存16进制表示形式，在Win32平台上，一个 short型占2个字节，所以我们自然希望用4个16进制数字来打印它：
 
short si = -1;
 
sprintf(s, “%04X”, si);
 
产生“FFFFFFFF，怎么回事？因为 sprintf是个变参函数，除了前面两个参数之外，后面的参数都不是类型安全的，函数更没有办法仅仅通过一个“%X”就能得知当初函数调用前参数压栈时 被压进来的到底是个4字节的整数还是个2字节的短整数，所以采取了统一4字节的处理方式，导致参数压栈时做了符号扩展，扩展成了32位的整数-1，打印时 4个位置不够了，就把32位整数-1的8位16进制都打印出来了。如果你想看si的本来面目，那么就应该让编译器做0扩展而不是符号扩展(扩展时二进制左边补0而不是补符号位)：
 
sprintf(s, “%04X”, (unsigned short)si);
 
就可以了。或者：
 
unsigned short si = -1;
 
sprintf(s, “%04X”, si);
 
sprintf和printf还可以按8进制打印整数字符串，使用”%o”。注意8进制和16进制都不会打印出负数，都是无符号的，实际上也就是变量的内部编码的直接用16进制或8进制表示。
 
参考：http://blog.csdn.net/cos_sin_tan/article/details/7548632
 
http://nnssll.blog.51cto.com/902724/198237/
 
http://blog.csdn.net/s202090414/article/details/8690518
 
http://blog.csdn.net/peng___peng/article/details/51510685

 
一、 ringBuffer 介绍
 
ringBuffer 称作环形缓冲，也有叫 circleBuffer 的。就是取内存中一块连续的区域用作环形缓冲区的数据存储区。这块连续的存储会被反复使用，向 ringBuffer 写入数据总是从写指针的位置开始，如写到实际存储区的末尾还没有写完，则将剩余的数据从存储区的头开始写；从该 ringBuffer 读出数据也是从读指针的位置开始，如读到实际存储区的末尾还没有读完，则从存储区的头开始读剩下的数据。
 
为了保证写入的数据不会覆盖 ringBuffer 里还没有被读出的数据，以及读出的数据不是已经读出过的旧数据，需要使用一个变量 btoRead 表示该 ringBuffer 中有效的数据。使用变量 length 表示该环形缓冲区中真实的缓冲大小。使用指针 source 指向实际的缓存地址。
 
使用 ringBuffer 读写数据，要确保读写数据的速率和实际缓冲区大小的匹配。如果不匹配，可能会导致溢出，比如读数据太慢，而写数据很快，实际的缓存区又太小，导致整个缓冲区都是还没有被读出的数据，此时新的数据就无法写入。正确使用 ringBuffer 可以保证数据的连续，降低读模块和写模块之间的耦合性。更多关于生产者-消费者模型的知识可以看这篇博客。
 
二、代码
 
ringBuffer 的结构体
 
typedef struct {
 
uint8_t *source;
 
uint32_t br;
 
uint32_t bw;
 
uint32_t btoRead;
 
uint32_t length;
 
}ringbuffer_t;
 
创建 ringBuffer 函数
 
void create_ringBuffer(ringbuffer_t *ringBuf, uint8_t *buf, uint32_t buf_len)
 
{
 
ringBuf->br = 0;
 
ringBuf->bw = 0;
 
ringBuf->btoRead = 0;
 
ringBuf->source = buf;
 
ringBuf->length = buf_len;
 
printf("create ringBuffer->length = %d\n", ringBuf->length);
 
}
 
清空 ringBuffer 函数
 
void clear_ringBuffer(ringbuffer_t *ringBuf)
 
{
 
ringBuf->br = 0;
 
ringBuf->bw = 0;
 
ringBuf->btoRead = 0;
 
//no need do this casue r_ptr and w_prt has change
 
// memset((uint8_t *)ringBuf->source, 0, ringBuf->length);
 
}
 
读数据函数
 
uint32_t write_ringBuffer(uint8_t *buffer, uint32_t size, ringbuffer_t *ringBuf)
 
{
 
uint32_t len = 0;
 
uint32_t ringBuf_bw = ringBuf->bw;
 
uint32_t ringBuf_len = ringBuf->length;
 
uint8_t *ringBuf_source = ringBuf->source;
 
if( (ringBuf_bw + size) <= ringBuf_len )
 
{
 
memcpy(ringBuf_source + ringBuf_bw, bufff, size);
 
}
 
else
 
{
 
len = ringBuf_len - ringBuf_bw;
 
memcpy(ringBuf_source + ringBuf_bw, buffer, len);
 
memcpy(ringBuf_source, buffer + ringBuf_bw, size - len);
 
}
 
ringBuf->bw = (ringBuf->bw + size) % ringBuf_len;
 
ringBuf->btoRead += size;
 
return size;
 
}
 
写数据函数
 
uint32_t read_ringBuffer(uint8_t *buffer, uint32_t size, ringbuffer_t *ringBuf)
 
{
 
uint32_t len = 0;
 
uint32_t ringBuf_br = ringBuf->br;
 
uint32_t ringBuf_len = ringBuf->length;
 
uint8_t *ringBuf_source = ringBug->source;
 
if( (ringBuf_br + size ) <= ringBuf_len )
 
{
 
memcpy(buffer, ringBuf_source + ringBuf_br, size);
 
}
 
else
 
{
 
len = ringBuf_len - ringBuf_br;
 
memcpy(bufff, ringBuf_source + ringBuf_br, len);
 
memcpy(buffer + len, ringBuf_source, size - len);
 
}
 
ringBuf->br = (ringBuf->br + size) % ringBuf_len;
 
ringBuf->btoRead -= size;
 
return size;
 
}
 
获取 ringBuffer 中的有效数据
 
uint32_t get_ringBuffer_btoRead(ringbuffer_t *ringBuf)
 
{
 
return ringBuf->btoRead;
 
}
 
获取 ringBuffer 的长度
 
uint32_t get_ringBuffer_length(ringbuffer_t *ringBuf)
 
{
 
return ringBuf->length;
 
}
 
三、使用方法
 
对 ringBuffer 的使用，首先需要又一块真实并且连续的数据存储区。可以使用 malloc 从堆区分配，也可以使用一个数组。
 
在写数据之前，需要对此时 ringBuffer 的剩余空间和要写入数据的大小进行比较。剩余空间使用长度 length 减去待读出数据量 btoRead 得到。
 
在读出数据之前，则需要对此时 ringBuffer 可读出的有效数据 btoRead 进行判断。
 
读出的数据不够，或者没有足够的空间写如数据，可以在调用读写函数之前进行判断，假如情况不满足，就不调用相应的读写函数。