不带缓存的I/O和标准(带缓存的)I/O

首先,先稍微了解系统调用的概念:
  系统调用,英文名system call,每个操作系统都在内核里有一些内建的函数库,这些函数可以用来完成一些系统系统调用把应用程序的请求传给内核,调用相应的的内核函数完成所需的处理,将处理结果返回给应用程序,如果没有系统调用和内核函数,用户将不能编写大型应用程序,及别的功能,这些函数集合起来就叫做程序接口或应用编程接口(Application Programming Interface,API),我们要在这个系统上编写各种应用程序,就是通过这个API接口来调用系统内核里面的函数。如果没有系统调用,那么应用程序就失去内核的支持。
————————————————————————————————————————————————
  现在,再聊不带缓存的I/O操作:
  linux对IO文件的操作分为不带缓存的IO操作和标准IO操作(即带缓存),刚开始,要明确以下几点:
  1.不带缓存,不是直接对磁盘文件进行读取操作,像read()和write()函数,它们都属于系统调用,只不过在用户层没有缓存,所以叫做无缓存IO,但对于内核来说,还是进行了缓存,只是用户层看不到罢了。如果这一点看不懂,请看第二点;
  2:带不带缓存是相对来说的,如果你要写入数据到文件上时(就是写入磁盘上),内核先将数据写入到内核中所设的缓冲储存器,假如这个缓冲储存器的长度是100个字节,你调用系统函数:

ssize_t write (int fd,const void * buf,size_t count);

  写操作时,设每次写入长度count=10个字节,那么你几要调用10次这个函数才能把这个缓冲区写满,此时数据还是在缓冲区,并没有写入到磁盘,缓冲区满时才进行实际上的IO操作,把数据写入到磁盘上,所以上面说的“不带缓存不是就没有缓存直写进磁盘”就是这个意思。
————————————————————————————————————————————————
  那么,既然不带缓存的操作实际在内核是有缓存器的,那带缓存的IO操作又是怎么回事呢?
  带缓存IO也叫标准IO,符合ANSI C 的标准IO处理,不依赖系统内核,所以移植性强,我们使用标准IO操作很多时候是为了减少对read()和write()的系统调用次数,带缓存IO其实就是在用户层再建立一个缓存区,这个缓存区的分配和优化长度等细节都是标准IO库代你处理好了,不用去操心,还是用上面那个例子说明这个操作过程:
  上面说要写数据到文件上,内核缓存(注意这个不是用户层缓存区)区长度是100字节,我们调用不带缓存的IO函数write()就要调用10次,这样系统效率低,现在我们在用户层建立另一个缓存区(用户层缓存区或者叫流缓存),假设流缓存的长度是50字节,我们用标准C库函数的fwrite()将数据写入到这个流缓存区里面,流缓存区满50字节后在进入内核缓存区,此时再调用系统函数write()将数据写入到文件(实质是磁盘)上,看到这里,你用该明白一点,标准IO操作fwrite()最后还是要掉用无缓存IO操作write,这里进行了两次调用fwrite()写100字节也就是进行两次系统调用write()。
  如果看到这里还没有一点眉目的话,那就比较麻烦了,希望下面两条总结能够帮上忙:
  无缓存IO操作数据流向路径:数据——内核缓存区——磁盘
  标准IO操作数据流向路径:数据——流缓存区——内核缓存区——磁盘

  这里为了说明标准I/O的工作原理,借用了glibc中标准I/O实现的细节,所以代码多是不可移植的.

1.buffered I/O, 即标准I/O

  首先,要明确,unbuffered I/O只是相对于buffered I/O,即标准I/O来说的.而不是说unbuffered I/O读写磁盘时不用缓冲.实际上,内核是存在高速缓冲区来进行真正的磁盘读写的,不过这里要讨论的buffer跟内核中的缓冲区无关.

  buffered I/O的目的是什么呢?很简单,buffered I/O的目的就是为了提高效率.请明确一个关系,那就是:
  buffered I/O库函数(fread, fwrite等,用户空间) <—-call—> unbuffered I/O系统调用(read,write等,内核空间) <——-> 读写磁盘

  buffered I/O库函数都是调用相关的unbuffered I/O系统调用来实现的,他们并不直接读写磁盘.那么,效率的提高从何而来呢?注意到,buffered I/O中都是库函数,而unbuffered I/O中为系统调用,使用库函数的效率是高于使用系统调用的.buffered I/O就是通过尽可能的少使用系统调用来提高效率的.它的基本方法是,在用户进程空间维护一块缓冲区,第一次读(库函数)的时候用read(系统调用)多从内核读出一些数据,下次在要读(库函数)数据的时候,先从该缓冲区读,而不用进行再次read(系统调用)了.同样,写的时候,先将数据写入(库函数)一个缓冲区,多次以后,在集中进行一次write(系统调用),写入内核空间.

  buffered I/O中的fgets, puts, fread, fwrite等和unbufferedI/O中的read,write等就是调用和被调用的关系.

下面是一个利用buffered I/O读取数据的例子:

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main(void)
{char buf[5]; FILE *myfile = stdin;fgets(buf, 5, myfile);fputs(buf, myfile);return 0;
}

buffered I/O中的”buffer”到底是指什么呢?
这个buffer在什么地方呢?
FILE是什么呢?它的空间是怎么分配的呢?

  要弄清楚这些问题,就要看看FILE是如何定义和运作的了.(特别说明,在平时写程序时,不用也不要关心FILE是如何定义和运作的,最好不要直接操作它,这里使用它,只是为了说明buffered IO)下面的这个glibc给出的FILE的定义,它是实现相关的,别的平台定义方式不同.

struct _IO_FILE {
int _flags;
#define _IO_file_flags _flagschar* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
char* _IO_buf_base;
char* _IO_buf_end;char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;struct _IO_marker *_markers;struct _IO_FILE *_chain;int _fileno;
};

上面的定义中有三组重要的字段:
————————————————————————————————————————————————
char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
————————————————————————————————————————————————
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
————————————————————————————————————————————————
char* _IO_buf_base;
char* _IO_buf_end;

其中,
_IO_read_base 指向”读缓冲区”
_IO_read_end 指向”读缓冲区”的末尾
_IO_read_end - _IO_read_base “读缓冲区”的长度

_IO_write_base 指向”写缓冲区”
_IO_write_end 指向”写缓冲区”的末尾
_IO_write_end - _IO_write_base “写缓冲区”的长度

_IO_buf_base 指向”缓冲区”
_IO_buf_end 指向”缓冲区”的末尾
_IO_buf_end - _IO_buf_base “缓冲区”的长度

上面的定义貌似给出了3个缓冲区,实际上上面_IO_read_base, _IO_write_base, _IO_buf_base都指向了同一个缓冲区.这个缓冲区跟上面程序中的 char buf[5] 没有任何关系.他们在第一次buffered I/O操作时由库函数自动申请空间,最后由相应库函数负责释放.
(再次声明,这里只是glibc的实现,别的实现可能会不同,后面就不再强调了)

请看下面的程序(这里给的是stdin,行缓冲的例子):

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main(void)
{char buf[5];FILE *myfile =stdin;printf("before reading/n");printf("read buffer base %p/n", myfile->_IO_read_base);printf("read buffer length %d/n", myfile->_IO_read_end - myfile->_IO_read_base);printf("write buffer base %p/n", myfile->_IO_write_base);printf("write buffer length %d/n", myfile->_IO_write_end - myfile->_IO_write_base);printf("buf buffer base %p/n", myfile->_IO_buf_base);printf("buf buffer length %d/n", myfile->_IO_buf_end - myfile->_IO_buf_base);printf("/n");fgets(buf, 5, myfile);fputs(buf, myfile);printf("/n");printf("after reading/n");printf("read buffer base %p/n", myfile->_IO_read_base);printf("read buffer length %d/n", myfile->_IO_read_end - myfile->_IO_read_base);printf("write buffer base %p/n", myfile->_IO_write_base);printf("write buffer length %d/n", myfile->_IO_write_end - myfile->_IO_write_base);printf("buf buffer base %p/n", myfile->_IO_buf_base);printf("buf buffer length %d/n", myfile->_IO_buf_end - myfile->_IO_buf_base);return 0;
}

  可以看到,在读操作之前,myfile的缓冲区是没有被分配的,在一次读之后,myfile的缓冲区才被分配.这个缓冲区既不是内核中的缓冲区,也不是用户分配的缓冲区,而是有用户进程空间中的由buffered I/O系统负责维护的缓冲区.(当然,用户可以可以维护该缓冲区,这里不做讨论了)上面的例子只是说明了buffered I/O缓冲区的存在,下面从全缓冲,行缓冲和无缓冲3个方面看一下buffered I/O是如何工作的.

1.1. 全缓冲

下面是APUE上的原话:
全缓冲”在填满标准I/O缓冲区后才进行实际的I/O操作.对于驻留在磁盘上的文件通常是由标准I/O库实施全缓冲的”书中这里”实际的I/O操作”实际上容易引起误导,这里并不是读写磁盘,而应该是进行read或write的系统调用.下面两个例子会说明这个问题:

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main(void)
{char buf[5];char *cur;FILE *myfile;myfile = fopen("bbb.txt", "r");printf("before reading, myfile->_IO_read_ptr: %d/n", myfile->_IO_read_ptr - myfile->_IO_read_base);fgets(buf, 5, myfile); //仅仅读4个字符cur = myfile->_IO_read_base;while (cur < myfile->_IO_read_end) //实际上读满了这个缓冲区{printf("%c",*cur);cur++;}printf("/nafter reading, myfile->_IO_read_ptr: %d/n", myfile->_IO_read_ptr - myfile->_IO_read_base);return 0;
}

上面提到的bbb.txt文件的内容是由很多行的”123456789”组成

  上例中, fgets(buf, 5, myfile); 仅仅读4个字符,但是,缓冲区已被写满,但是 _IO_read_ptr 却向前移动了5位,下次再次调用读操作时,只要要读的位数不超过 myfile->_IO_read_end - myfile->_IO_read_ptr 那么就不需要再次调用系统调用 read,只要将数据从 myfile 的缓冲区拷贝到 buf 即可(从 myfile->_IO_read_ptr 开始拷贝)

  全缓冲读的时候, _IO_read_base 始终指向缓冲区的开始 _IO_read_end 始终指向已从内核读入缓冲区的字符的下一个(对全缓冲来说, buffered I/O 读每次都试图都将缓冲区读满) _IO_read_ptr 始终指向缓冲区中已被用户读走的字符的下一个 _IO_read_end < (_IO_buf_base-_IO_buf_end)) && (_IO_read_ptr == _IO_read_end) 时则已经到达文件末尾,其中_IO_buf_base-_IO_buf_end是缓冲区的长度,一般大体的工作情景为:
第一次fgets(或其他的)时,标准I/O会调用 read 将缓冲区充满,下一次 fgets 不调用 read 而是直接从该缓冲区中拷贝数据,直到缓冲区的中剩余的数据不够时,再次调用 read.在这个过程中, _IO_read_ptr 就是用来记录缓冲区中哪些数据是已读的,哪些数据是未读的.

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main(void)
{char buf[2048]={0};int i;FILE *myfile;myfile = fopen("aaa.txt", "r+");i= 0;while (i<2048){fwrite(buf+i, 1, 512, myfile);i +=512;//注释掉这句则可以写入aaa.txtmyfile->_IO_write_ptr = myfile->_IO_write_base;printf("%p write buffer base/n", myfile->_IO_write_base);printf("%p buf buffer base /n", myfile->_IO_buf_base);printf("%p read buffer base /n", myfile->_IO_read_base);printf("%p write buffer ptr /n", myfile->_IO_write_ptr);printf("/n");}return 0;
}

上面这个是关于全缓冲写的例子.
  全缓冲时,只有当标准I/O自动flush(比如当缓冲区已满时)或者手工调用fflush时,标准I/O才会调用一次write系统调用.例子中,fwrite(buf+i, 1, 512, myfile);这一句只是将 buf+i 接下来的512个字节写入缓冲区,由于缓冲区未满,标准I/O并未调用 write.此时, myfile->_IO_write_ptr = myfile->_IO_write_base;会导致标准I/O认为没有数据写入缓冲区,所以永远不会调用write,这样aaa.txt文件得不到写入.注释掉 myfile->_IO_write_ptr = myfile->_IO_write_base;前后,看看效果.

全缓冲写的时候:
_IO_write_base 始终指向缓冲区的开始
_IO_write_end 全缓冲的时候,始终指向缓冲区的最后一个字符的下一个(对全缓冲来说,buffered I/O写总是试图在缓冲区写满之后,再系统调用 write)
_IO_write_ptr 始终指向缓冲区中已被用户写入的字符的下一个
flush的时候,将 _IO_write_base 和 _IO_write_ptr 之间的字符通过系统调用write写入内核

1.2. 行缓冲

下面是APUE上的原话:
行缓冲”当输入输出中遇到换行符时,标准I/O库执行I/O操作.”书中这里”执行I/O操作”也容易引起误导,这里不是读写磁盘,而应该是进行read或write的系统调用.

下面两个例子会说明这个问题

第一个例子可以用来说明下面这篇帖子的问题
http://bbs.chinaunix.net/viewthread.php?tid=954547

#include <stdlib.h>
#include <stdio.h>int main(void)
{char buf[5];char buf2[10];fgets(buf, 5, stdin); //第一次输入时,超过5个字符puts(stdin->_IO_read_ptr);//本句说明整行会被一次全部读入缓冲区,//而非仅仅上面需要的个字符stdin->_IO_read_ptr = stdin->_IO_read_end; //标准I/O会认为缓冲区已空,再次调用read//注释掉,再看看效果printf("/n");puts(buf);fgets(buf2, 10, stdin);puts(buf2);return 0;
}

上例中, fgets(buf, 5, stdin); 仅仅需要4个字符,但是,输入行中的其他数据也被写入缓冲区,但是_ IO_read_ptr 向前移动了5位,下次再次调用fgets操作时,就不需要再次调用系统调用 read,只要将数据从stdin的缓冲区拷贝到 buf2 即可(从 stdin->_IO_read_ptr 开始拷贝).stdin->_IO_read_ptr = stdin->_IO_read_end;会导致标准I/O会认为缓冲区已空,再次 fgets 则需要再次调用 read.比较一下将该句注释掉前后的效果

行缓冲读的时候,
_IO_read_base 始终指向缓冲区的开始
_IO_read_end 始终指向已从内核读入缓冲区的字符的下一个
_IO_read_ptr 始终指向缓冲区中已被用户读走的字符的下一个
(_IO_read_end < (_IO_buf_base-_IO_buf_end)) && (_IO_read_ptr == _IO_read_end) 时则已经到达文件末尾
其中_IO_buf_base-_IO_buf_end是缓冲区的长度

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>char buf[5]={'1','2', '3', '4', '5'}; //最后一个不要是/n,是/n的话,标准I/O会自动flush的//这是行缓冲跟全缓冲的重要区别void writeLog(FILE *ftmp)
{fprintf(ftmp, "%p write buffer base/n", stdout->_IO_write_base);fprintf(ftmp, "%p buf buffer base /n", stdout->_IO_buf_base);fprintf(ftmp, "%p read buffer base /n", stdout->_IO_read_base);fprintf(ftmp, "%p write buffer ptr /n", stdout->_IO_write_ptr);fprintf(ftmp, "/n");
}int main(void)
{int i; FILE *ftmp;ftmp = fopen("ccc.txt", "w");i= 0;while (i<4){fwrite(buf, 1, 5, stdout);i++;*stdout->_IO_write_ptr++ = '/n';//可以单独把这句打开,看看效果//getchar();//getchar()会标准I/O将缓冲区输出//打开下面的注释,你就会发现屏幕上什么输出也没有//stdout->_IO_write_ptr = stdout->_IO_write_base;writeLog(ftmp); //这个只是为了查看缓冲区指针的变化  }return 0;
}

这个例子将将FILE结构中指针的变化写入的文件ccc.txt 运行后可以有兴趣的话,可以看看.

上面这个是关于行缓冲写的例子.
stdout->_IO_write_ptr = stdout->_IO_write_base;会使得标准I/O认为缓冲区是空的,从而没有任何输出.可以将上面程序中的注释分别去掉,看看运行结果

行缓冲时,下面3个条件之一会导致缓冲区立即被flush
1. 缓冲区已满
2. 遇到一个换行符;比如将上面例子中buf[4]改为 ‘/n’时
3. 再次要求从内核中得到数据时;比如上面的程序加上getchar()会导致马上输出

行缓冲写的时候:
_IO_write_base始终指向缓冲区的开始
_IO_write_end始终指向缓冲区的开始
_IO_write_ptr始终指向缓冲区中已被用户写入的字符的下一个

flush的时候,将 _IO_write_base 和 _IO_write_ptr 之间的字符通过系统调用write写入内核

1.3. 无缓冲

无缓冲时,标准I/O不对字符进行缓冲存储.典型代表是stderr
这里的无缓冲,并不是指缓冲区大小为0,其实,还是有缓冲的,大小为1

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main(void)
{fputs("stderr", stderr);printf("%d/n", stderr->_IO_buf_end - stderr->_IO_buf_base);return 0;
}

对无缓冲的流的每次读写操作都会引起系统调用

1.4 feof的问题

CU上已经有无数的帖子在探讨feof了,这里从缓冲区的角度去考察一下.对于一个空文件,为什么要先读一下,才能用feof判断出该文件到了结尾了呢?

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>int main(void)
{char buf[5];char buf2[10];fgets(buf, sizeof(buf), stdin);//输入要于4个,少于13个字符才能看出效果puts(buf);//交替注释下面两行//stdin->_IO_read_end = stdin->_IO_read_ptr+1;stdin->_IO_read_end = stdin->_IO_read_ptr + sizeof(buf2)-1;fgets(buf2, sizeof(buf2), stdin);puts(buf2);if (feof(stdin))printf("input end/n");return 0;
}

  运行上面的程序,输入多于4个,少于13个字符,并且以连按两次ctrl+d为结束(不要按回车)从上面的例子,可以看出,每当满足 (_IO_read_end < (_IO_buf_base-_IO_buf_end)) && (_IO_read_ptr == _IO_read_end)时,标准I/O则认为已经到达文件末尾,feof(stdin) 才会被设置其中 _IO_buf_base-_IO_buf_end 是缓冲区的长度.也就是说,标准I/O是通过它的缓冲区来判断流是否要结束了的.这就解释了为什么即使是一个空文件,标准I/O也需要读一次,才能使用feof判断释放为空

1.5. 其他说明
  很多新手有一个误解,就是 fgets, fputs 代表行缓冲, fread, fwrite 代表全缓冲,fgetc, fputc代表无缓冲等等.其实不是这样的,是什么样的缓冲跟使用那个函数没有关系,而跟你读写什么类型的文件有关系.上面的例子中多次在全缓冲中使用fgets, fputs,而在行缓冲中使用fread, fwrite

下面的是引至APUE的
实际上
ISO C要求:
1.当且仅当标准输入和标准输出并不涉及交互式设备时,他们才是全缓冲的
2.标准输出决不是全缓冲的.

很多系统默认使用下列类型的标准:
1.标准输出是不带缓冲的.
2.如若是涉及终端设备的其他流,则他们是行缓冲的;否则是全缓冲的.

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/403433.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

uni.$emit和uni.$on用法;uni-app微信小程序页面通讯;微信小程序页面通讯

uni-app的官方api uni.$on 场景&#xff1a; 微信小程序两个页面甚至多个页面之间&#xff0c;可能共用一个参数或者需要相互传递使用参数。例如页面A点击按钮&#xff0c;需要把A页面的item数据&#xff0c;赋值给页面B的formData&#xff0c;但是页面A只是传递数据给B&#x…

转:探索 AIX 6:在 AIX 6 上配置 iSCSI Target

引言iSCSI&#xff08;Internet Small Computer System Interface&#xff09;被业界认为是非常廉价的 SAN 解决方案&#xff0c;一直在中低端应用领域被市场所看好。 iSCSI 客户端和服务端都既可以通过硬件方式实现&#xff0c;也能通过软件方式的&#xff0c;其优劣区别就是在…

利用python生成一个导出数据库的bat脚本文件

# 环境: python3.xdef getExportDbSql(db, index): # 获取导出一个数据库实例的sql语句sql mysqldump -u%s -p%s -h%s -P%d --default-character-setutf8 --databases mu_ins_s%s > %s.s%d.mu_ins_%d.sql %(db[user], db[pwd], db[host], db[port], index, db[server],…

iOS开发极光推送显示 开发证书没有通过验证 是否重新上传证书?解决方法

1.证书密码错误 2证书环境不匹 3导证书时因手误把私钥导出来了&#xff0c;而不是证书 1.当前上传的p12证书密码输入有误&#xff1b; 2. 证书导出的时候展开了证书&#xff0c;把个人私钥导了出来&#xff0c;导证书的时候请不要展开证书&#xff1b; 3.当前上传的证书环境不对…

微信小程序禁止页面上下滑动;uni-app微信小程序禁止页面上下滑动;uni-app小程序上下滑动;

阻止小程序某个页面上下滑动&#xff0c;最简单有效方法&#xff1b;直接对小程序当前页的最外层标签盒子&#xff0c;设置固定定位即可&#xff01; 设置固定定位后&#xff0c;页面的最大盒子宽度可能不是自动撑满的&#xff0c;那就自己在calc计算下宽度即可 .box {// 加这…

安装 groovy eclipse 插件

原文出处&#xff1a;http://blog.chenlb.com/2008/12/install-groovy-eclipse-plugin.html 写代码最好还是要个ide&#xff0c;最过学习 groovy。平时用 eclipse 开发 java 程序&#xff0c;写 groovy 还是用 eclipse 吧&#xff08;虽然目前 groovy 的 eclipse 插件不是最好。…

Linux 统计文件行数,字节数。

语法&#xff1a;wc [选项] 文件… 说明&#xff1a;该命令统计给定文件中的字节数、字数、行数。如果没有给出文件名&#xff0c;则从标准输入读取。wc同时也给出所有指定文件的总统计数。字是由空格字符区分开的最大字符串。 该命令各选项含义如下&#xff1a; - c 统计字节…

PHP JSON数组与对象的理解

在PHP后端和客户端数据交互的过程中&#xff0c;JSON数据中有时格式不定&#xff0c;一会儿是数组&#xff0c;一会儿是对象&#xff0c;弄得客户端开发人员要崩溃的感觉。 因此&#xff0c;前后端相关人员先对PHP的json_encode函数原理有必要的了解是最重要的一个环节。 PHP中…

[bash] 打包某目录(可以是绝对路径)下的指定扩展名的文件

#!/bin/bash# 该脚本用于打包某目录(可以是绝对路径)下的指定扩展名的文件if [ $# -lt 1 ] || [ "$1" "." ] || [ "$1" "./" ]; thenDIRpwdelseDIR$1if [ ! -e $DIR ]; thenecho "Directory-[$DIR] not exist, exit now!"…

uni-app微信小程序生成自定义参数二维码,跳转小程序指定页面,获取参数;uni-app微信小程序获取二维码自定义参数;微信小程序生成动态参数二维码;uni-app微信小程序获取动态参数二维码;

一、场景需求&#xff1a; 在小程序个人名片页面A页面&#xff0c;生成用户的个人名片二维码&#xff08;该二维码携带用户的唯一标识id&#xff09;&#xff1b;微信扫一扫或长按图片识别这个二维码&#xff0c;可以跳转到小程序的B页面&#xff0c;并且在B页面拿到二维码上的…

【view桌面虚拟化系列】1-vSphere搭建

本系列一共三章&#xff0c;具体如下&#xff1a; 【view桌面虚拟化系列】1-vSphere搭建 【view桌面虚拟化系列】2-View搭建 【view桌面虚拟化系列】3-VDI实现 实验的目的:测试vsphere5.1a、view5.1测试整体运行状况。 首先介绍下环境&#xff08;所使用域名&#xff1a;vmc.co…

Linux 等待进程结束 wait() 和 waitpid()

若子进程先于父进程结束时&#xff0c;父进程调用wait()函数和不调用wait()函数会产生两种不同的结果&#xff1a; --> 如果父进程没有调用wait()和waitpid()函数&#xff0c;子进程就会进入僵死状态。 --> 如果父进程调用了wait()和waitpid()函数&#xff0c;就不会使子…

printf格式化输出类型

%d 十进制有符号整数 %u 十进制无符号整数 %f 浮点数 %s 字符串 %c 单个字符 %p 指针的值 %e 指数形式的浮点数 %x, %X 无符号以十六进制表示的整数 %0 无符号以八进制表示的整数 %g 自动选择合适的表示法 可以在”%”和字母之间加小写字母l, 表示输出的是长型数。 …

uni-app微信小程序保存页面到相册;canvas保存小程序页面;微信小程序保存二维码活动页面到相册;微信小程序canvas 生成海报保存到相册;canvas绘制小程序页面保存及分享;

文末代码可以直接复制运行&#xff08;只需要将中间的二维码图片、底部的微信和相册图片和微信头像配置白名单 改成你项目内的img图片即可成功运行&#xff09; 一、场景&#xff1a;在微信小程序 个人名片页面 含有微信头像和个人信息二维码&#xff08;识别可跳转小程序指定页…

面试经验谈架构

##################################################### #本文内容来自《老男孩linux运维实战培训》学生—郑东旭 #如有转载&#xff0c;请务必保留本文链接及本版权信息。 #欢迎广大运维同仁一起交流linux/unix网站运维技术! #QQ:919953500#E-mail:weilandeshanhuhai126.com …

lucene api

设置重新打开索引目录&#xff08;清空&#xff09; IndexWriterConfig conf new IndexWriterConfig(new WhitespaceAnalyzer());conf.setOpenMode(OpenMode.CREATE);转载于:https://www.cnblogs.com/ydxblog/p/5688415.html

Linux计算求取文件长度

在文件IO的编程过程中&#xff0c;经常会遇到如何求取文件长度的问题&#xff0c;这里将工积累的一些常用方法写出来与大家分享。 第一类&#xff1a;lseek/fseek 1、lseek int GetFileSize&#xff08;char *_pName) {int iFd -1;int iLen 0;if (_pName NULL){return -…

[linux-svn] linux下svn常用指令

From: http://www.cnblogs.com/aLittleBitCool/archive/2011/07/09/2101602.html windows下的TortoiseSVN是资源管理器的一个插件&#xff0c;以覆盖图标表示文件状态&#xff0c;几乎所以命令都有图形界面支持&#xff0c;比较好用&#xff0c;这里就不多说。主要说说linux下…

微信小程序uni.switchTab传参获取不到;小程序跳转到tabBar页并传参;uni-app微信小程序获取tabBar页面参数失败;uni-app微信小程序tabBar页面onLoad不执行

需求场景&#xff1a;从非tabBar页面B跳转到tabBar页面A&#xff0c;并想要携带参数。 如果使用uni.switchTab传参&#xff0c;会导致tabBAE页面获取不到参数&#xff1b; 原因&#xff1a; 官方文档有说&#xff0c;uni.switchTab路径后不能带参数&#xff1b; uni.navigateT…

UIView的旋转iOS开发

更多阅读请访问http://www.hopean.com 有关UIView坐标变换的&#xff0c;但是经常不能得到自己想要的效果&#xff0c;今天就把它仔细研究了下。记下来等以后忘记的时候再复习 重写shouldAutorateToInterfaceOrientation:&#xff0c;限制某个方向会改变原点的位置&#xff0c;…