Qt——管道FIFO的创建与使用【未完成】

心已赠人 2023-06-23 13:11 7阅读 0赞

### 目录大纲 ###

*  前提
 *  FIFO
 *   *  使用到的函数基本认识
     *   *  字节相关的换算
         *  声明与定义
         *  字符串末尾为什么加'\\0' 或 为什么初始化字符串时用'\\0'
         *   *  '\\0'
         *  文件权限
         *  文件描述符
         *   *  已知的文件描述符
             *  其他
         *  sizeof(...)
         *   *  strlen(...)
             *  其他
             *  区别
             *   *  操作符与运算符的区别
         *  perror()
         *   *  strerror()
             *  ferror()
             *  feof()
             *  errno
             *  区别
         *  read(...,...,...)
         *   *  与fgets(...,...,...)的区别
             *   *  fgets(...,...,...)
                 *   *  gets(...,)
                     *  getchar()
                     *  区别
                 *  区别
         *  write(...,...,...)
         *  open(...,...,...)
         *   *  阻塞与非阻塞
         *  close(...,...,...)
         *  access(...,...)
         *  mkfifo(...,...,...)
         *   *  Linux文件访问权限
             *  \#include 《sys/stat.h》作用
         *  QString与char等类型的转换
         *   *  char \*\* 与char \*
         *  memset(...,...,...)
         *  strcpy(...,...)
         *   *  与memcpy(...,...,...)的区别
             *   *  memcpy(...)
                 *  区别
         *  strncmp(...,...,...)
         *   *  与strcmp(...,...,...)的区别
             *   *  strcmp(...,...,...)
                 *  区别
         *  puts(...,...,...)
         *   *  与printf(...,...,...),qDebug(),fputs(...,...,...),scanf(...,...,...)的区别
             *   *  printf(...,...,...)
                 *  qDebug()
                 *  fputs(...,...,...)
                 *  scanf(...,...,...)
                 *  区别
         *  union
         *   *  struct
             *   *  与struct的区别
     *  实例
     *   *  FIFO例子
         *   *  实现方式
         *  与pipe区别\[^53\]
     *  顺手了解
     *   *  I2C（IIC）
     *  论坛
 *  总结

# 前提 #

运行环境：Qt5.8.0+Linux虚拟机+Desktop Qt 5.8.0 GCC 64bit

# [FIFO][] #

它是一种文件类型，在文件系统中可以看到。程序中可以查看文件stat结构中st\_mode成员的值来判断文件是否是FIFO文件。创建一个FIFO文件类似于创建文件，FIFO文件就像普通文件一样。  
FIFO的通信方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清除数据。  
在文件系统中作为一个特殊的设备文件而存在的。

## 使用到的函数基本认识 ##

### 字节相关的换算 ###

*  字节相关的换算1

1M=1048576字节，换算过来1字节＝1/1048576M约为0.000001M。  
MB：全称兆字节（MByte）是计算机存储容量单位，一般用字节(Byte)、千字节(KB)、兆字节(MB)、吉字节(GB)、太字节(TB)、拍字节(PB)、艾字节(EB)、泽它字节(ZB，又称皆字节)、尧它字节(YB)表示。  
位：数据存储的最小单位。每个二进制数字0或者1就是1个位。  
计算机容量单位的换算关系是：  
1Byte字节=8bit位  
1KB=1024B  
1MB=1024KB  
1GB=1024MB  
1TB=1024GB  
1PB=1024TB  
1EB=1024PB  
1ZB=1024EB  
1YB=1024ZB

### 声明与定义 ###

*  声明与定义2

*  变量：
    
     *  声明（declaration）用于向程序表明变量的类型和名字。
     *  变量的定义（definition）用于为变量分配存储空间，还可以为变量指定初始值。**在程序中，变量有且仅有一个定义。** 不定义变量的声明包括对象名、对象类型和对象类型前的关键字extern。
     *  定义也是声明：当定义变量的时候我们声明了它的类型和名字。
     *  PS：extern是声明不是定义，也它不分配存储空间。事实上它只是说明变量定义在程序的其他地方【即 在没有赋值的情况下，变量前加上关键字extern一定为声明】。程序中变量可以声明多次，但只能定义一次。
     *  如果声明有初始化式，就被当作定义，即使前面加了extern。但是只有当extern声明位于函数外部时，才可以被初始化。

extern int i; //声明，不是定义，因为extern提示i这个变量在别的地方定义过了
           int i2; //声明，也是定义, 不初始化
           int i3 = 10; //声明且定义, 同时进行初始化
           得出：有类型、变量名为声明，给予默认值【系统赋予】/初始值【自定义】为定义

*  函数：
    
     *  带有\{ \}的函数就是定义。
     *  不带有\{ \}的函数就是声明。

extern double max(double d1, double d2);  //声明
           double max(double d1, double d2)//定义
           { 
              return d1>d2?d1:d2;       
           }

### 字符串末尾为什么加’\\0’ 或 为什么初始化字符串时用’\\0’ ###

*  字符串末尾为什么加’\\0’ 或 为什么初始化字符串时用’\\0’3

*  '\\0’就是8位的00000000，因为字符类型中并没有对应的这个字符，所以这么写。在数值类型里就代表数字0。
 *  '\\0’是转译字符，意思是告诉程序，这不是字符0，我要的是数字0的2进制直接放进来，因为acsii码的0可不是00000000，若0为字符，十进制为48，若0为十进制，字符为NUL(null)【解释为空字符】。
 *  '\\0’就是 字符串结束标志。若不人为加上，C编译系统也会自动加上的。所以一般在用字符串赋初值时无须指定数组的长度， 而由系统自行处理。
 *  0与’\\0’是等价的。

#### ‘\\0’ ####

*  ‘\\0’ 4

*  c++中字符串以字符‘\\0’结尾，所以每个字符串都有额外一个字符的开销。  
    如：`char str[10]; strcpy(str,"0123456789")`；  
    分析：因为“0123456789”有十个字符，但是末尾自动加一个’\\0’字符，因此它的实际长度是11个字节。所以，如果要复制该字符串，至少需要一个长度为11个字节的数组。
 *  strlen()计算长度时不考虑末尾的’\\0’，所以容易引发“内存溢出”，解决：strlen(数组长度-1)才是真正存字符的长度，总之留一个空位出来就对了！

char s[] = "10";
        printf("%s\n", s);
        printf("s[1]:%d\n", s[1]);
        printf("s[2]:%d\n", s[2]);
        printf("s[1]:%c\n", s[1]);
        printf("s[2]:%c\n", s[2]);
    
        char u[] = {"hello"};
        cout << sizeof(u) / sizeof(*u) << endl;
        char v[] = "hello";
        cout << sizeof(v) / sizeof(*v) << endl;

![打印结果][20191222112839725.png]

### 文件权限 ###

*  文件权限5

const S_IRUSR = %0100000000;//用户读权限
    const S_IWUSR = %0010000000;//用户写权限
    const S_IXUSR = %0001000000;

*  其中：const S\_IRWXU = S\_IRUSR or S\_IWUSR or S\_IXUSR

int fd = open(dev_name, O_RDWR,S_IRWXU);

### [文件描述符][Link 1] ###

*  文件描述符6

内核（kernel）利用文件描述符（file descriptor）来访问文件。文件描述符是非负整数。打开现存文件或新建文件时，内核会返回一个文件描述符。读写文件也需要使用文件描述符来指定待读写的文件。  
每一个文件描述符会与一个打开文件相对应，同时，不同的文件描述符也会指向同一个文件。相同的文件可以被不同的进程打开也可以在同一个进程中被多次打开。系统为每一个进程维护了一个文件描述符表，该表的值都是从0开始的，所以在不同的进程中你会看到相同的文件描述符，这种情况下相同文件描述符有可能指向同一个文件，也有可能指向不同的文件。  
在linux系统中打开文件就会获得文件描述符，它是个很小的正整数。每个进程在PCB（Process Control Block）中保存着一份文件描述符表，文件描述符就是这个表的索引，每个表项都有一个指向已打开文件的指针。  
举例:

int f1,f2 ;
    f1 = open(“test1”,O_RDONLY,0) ；
    close(f1) ;
    f2 = open(“test2”,O_RDONLY,0) ；
    printf(“f2=%d\n”,f2) ;
    最后打印结果为 3

分析:  
f1,f2代表的是文件描述符，Unix进程从生命周期开始时，打开的描述符赋给stdin(描述符0),stdout(描述符1),stderr(描述符2)。open函数总是返回最低的未打开的描述符，所以第一次调用open会返回描述符3。调用close函数则会释放描述符3。如果再调用open函数则文件描述符又会是3。若为释放之前的文件描述符3，则再打开一个文件时，文件描述符就变为4。以此类推……

#### 已知的文件描述符 ####

Linux的文件描述符：

<table> 
 <thead> 
  <tr> 
   <th>文件描述符</th> 
   <th>通道名</th> 
   <th>描述</th> 
   <th>默认连接</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>0</td> 
   <td>stdin</td> 
   <td>标准输入</td> 
   <td>键盘</td> 
   <td>read only</td> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>stdout</td> 
   <td>标准输出</td> 
   <td>终端</td> 
   <td>write only</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>stderr</td> 
   <td>标准错误</td> 
   <td>终端</td> 
   <td>write only</td> 
  </tr> 
  <tr> 
   <td>3以上</td> 
   <td>filename</td> 
   <td>其他文件</td> 
   <td>none</td> 
   <td>read and/or write</td> 
  </tr> 
 </tbody> 
</table>

补充：标准输入输出说明:  
stdin，标准输入，默认设备是键盘，文件编号为0  
stdout，标准输出，默认设备是显示器，文件编号为1，也可以重定向到文件  
stderr，标准错误，默认设备是显示器，文件编号为2，也可以重定向到文件

#### 其他 ####

### [sizeof(…)][sizeof] ###

*  sizeof(…)7

1.  指针与静态数组的sizeof操作  
    指针均可看为变量类型的一种，所有指针变量的sizeof操作结果均为4 。【在32位计算机中，一个指针变量的返回值必定是4（注意结果是以字节为单位），在64位系统中指针变量的sizeof结果为8。】
2.  使用sizeof时string的注意事项  
    string s=“hello”;  
    sizeof(s)等于string类的大小，sizeof(s.c\_str())得到的是与字符串长度。  
    总体上遵循两个原则：  
    (1)整体空间是 占用空间最大的成员（的类型）所占字节数的整倍数  
    (2)数据对齐原则----内存按结构成员的先后顺序排列，当排到该成员变量时，其前面已摆放的空间大小必须是该成员类型大小的整倍数，如果不够则补齐，以此向后类推。。。。。
3.  注意：数组按照单个变量一个一个的摆放，而不是看成整体。如果成员中有自定义的类、结构体，也要注意数组问题。

![证明sizeof不是函数,他只是操作符或运算符][sizeof 1]

#### [strlen(…)][strlen] ####

*  strlen(…) 8

所作的仅仅是一个计数器的工作，它从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结束符’\\0’为止，然后返回计数器值。

*  原型:extern unsigned int 或 size\_t strlen(char \*str );
 *  举例:

char str[50];
      int len; 
      strcpy(str, "This is yiibai.com"); 
      len = strlen(str);
      printf("Length of %s is %d", str, len);
      
    打印结果: Length of This is yiibai.com is 26

*  功能:参数str 是字符串；计算字符串str的长度，但不包括终止空字符’\\0’。
 *  返回值:这个函数返回字符串的长度。

#### 其他 ####

size()与length()均为string类的成员函数，其中length()沿用C的风格，size则是引入STL后，作为STL容器的属性存在的，二者返回的结果一致。  
如：`string a="hellow";调用结果：a.length()=6;a.size()=6;`

#### 区别 ####

*  strlen计算字符数组的字符数，以“\\0"为结束符，不计算“\\0"为数组元素，只求字符串的长度。
 *  sizeof()计算数据（数组、变量、类型、结构体等）所占空间，用字节数表示。【sizeof实际上是获取了数据在内存中所占用的存储空间，以字节为单位来计数。C语言会自动在在双引号"“括起来的内容的末尾补上”\\0"代表结束，ASCII中的0号位也占用一个字符。】
 *  sizeof可以用类型做参数，strlen只能用char\*做参数，且必须是以”\\0”结尾的。sizeof还可以用函数做参数,如:`short f();printf("%d\n", sizeof(f()));`，输出的结果是返回值的类型的大小, 即sizeof(short)=2。
 *  数组做sizeof的参数不退化，传递给strlen就退化为指针了。
 *  sizeof是取字节运算符(C++ 关键字)，strlen是函数。

![sizeof与strlen的区别][sizeof_strlen]

##### 操作符与运算符的区别 #####

*  操作符与运算符的区别9

操作符和运算符在英文里都叫operator，

1.  操作符是嵌在每一条指令中的，换句话说，指令系统的每一条指令都有一个操作符。我理解是计算机系统中的术语。如: =（赋值），==（判断相当）等等。
2.  运算符是数学中的术语。主要是指数之间的运算方式。如 + - \* / %，但不包括 = （赋值）这样的操作符。

### [perror()][perror] ###

*  perror() 10

*  原型:void perror(const char \*str);——把一个描述性错误消息输出到标准错误 stderr，首先输出字符串 str，后跟一个冒号，然后是一个空格，接着是对应于errno值的出错信息，最后是一个换行符。【\#include<stdio.h>】
 *  举例:perror(“perror”);——结果如下图
 *  功能:str – 这是 C 字符串，包含了一个自定义消息，将显示在原本的错误消息之前。
 *  返回值:该函数不返回任何值。

#### strerror() ####

*  原型:char \*strerror(int errnum);——将errnum（它通常就说errno值）映射为一个出错信息字符串，并返回此字符串的指针。【\#include <string.h>】
 *  举例:printf(“fork error:%s\\n”,strerror(errno));——结果如下图
 *  功能:只是将errno对应的错误消息字符串返回，要怎样处理完全由你自己决定。  
    ![两函数的使用的区别][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDQyNTk1_size_16_color_FFFFFF_t_70]

#### ferror() ####

#### feof() ####

#### errno ####

*  errno 11

*  表示:是error number的缩写，是一个全局变量。errno宏定义为一个int型态的左值, 包含任何函式使用errno功能所产生的上一个错误码。
 *  意义:Linux系统对各种常见的错误做了个编号，当函数执行错误时，函数会返回一个特定的errno编号（int 类型）来告诉我们这个函数哪里错了。
 *  使用:Linux系统提供了一个函数perror(print errot)，perror函数内部会读取errno并且将这个数字转成对应的错误字符串，然后打印出来。【perror是将errno对应的错误消息的字符串打印到标准错误输出上】  
    ![errno的使用原理][errno]

#### 区别 ####

### read(…,…,…) ###

*  read(…,…,…)12

*  原型:ssize\_t read( int filedes, void \*buf, size\_t nbytes);——从buf中读取nbytes长度给filedes【\#include<unistd.h>】
 *  举例:char buf\[10\];int fd= open("/dev/tty", O\_RDONLY | O\_NONBLOCK);int n = read(fd, buf, 10);——只读且非阻塞的模式来open这个路径的dev文件夹下的指定文件tty，表示当前打开的终端设备
 *  功能:读入指定长度的数据。从 filedes 中读取数据到 buf 中，nbytes 是要求读到的字节数。当从终端设备读时，通常一次最多读一行。ssize\_t 提供带符号的返回值，size\_t不带符号。
 *  返回值:  
    　　> 0: 实际读到的字节数  
    　　= 0: 读完数据(读文件, 管道, socket末尾–>对端关闭, 对端未关闭会一直等待)  
    　　-1: 异常:  
    　　　　errno == EINTR被信号中断, 重启或者退出  
    　　　　errno == EAGAIN或者EWOULDBLOCK以非阻塞方式读, 并且没有数据  
    　　　　其他值: 出现错误perror eixt

#### 与fgets(…,…,…)的区别 ####

##### fgets(…,…,…) #####

*  fgets(…,…,…)13

*  原型:char \*fgets(char \*s, int n, FILE \*stream);——读取n个长度的文件数据到数组s
 *  举例:fgets(str, sizeof(str), stdin);——str为数组首地址，sizeof(str)为数组大小，stdin表示我们从键盘输入数据。
 *  功能:从文件指针stream中读取字符，存到以s为起始地址的空间里，知道读完N-1个字符，或者读完一行。
 *  注意:调用fgets函数时，最多只能读入n-1个字符。读入结束后，系统将自动在最后加’\\0’，并以str作为函数值返回。

###### gets(…,) ######

*  原型:char \*gets(char \*buffer);——读取字符到数组
 *  举例:gets(str);——str为数组名。
 *  功能:从键盘上输入字符，直至接受到换行符或EOF14时停止，并将读取的结果存放在buffer指针所指向的字符数组中。读取的换行符被转换为null值，做为字符数组的最后一个字符，来结束字符串。
 *  注意:gets函数由于没有指定输入字符大小，所以会无限读取，一旦输入的字符大于数组长度，就会发生内存越界，从而造成程序崩溃或其他数据的错误。

###### getchar() ######

###### 区别 ######

*  区别 15

*  gets函数没有限制读入的个数，这很可能会导致程序向未知的内存空间写入数据，而导致程序出错。
 *  fgets函数中第二个参数限制了读取的个数，这也解决了gets函数存在的问题，但要注意fgets函数只会读取n-1个字符（如果遇到换行符会更少），并在最后添加字符串结束标志，而且，fgets也会将换行符读入。
 *  read与fget:

int stdin=0;
    	char buffer[BUFFER_SIZE];
    	 /*从标准输入中读取输入的内容,两种函数实现效果一样*/
    	fgets(buffer, sizeof(buffer), stdin);
    	read(0,buffer,sizeof(buffer));//读串口信息,在终端中输入字符,开发板上运行了的程序可以读取并进行指定的处理

##### 区别 #####

### write(…,…,…) ###

*  write(…,…,…)16

*  原型:ssize\_t write(int fildes, const void \*buf, size\_t nbyte);.——从buf内写入nbyte字节给fildes【\#include<unistd.h>】
 *  举例:
 *  功能:从 buf 中写数据到 filedes 中，nbytes 是相求写入的字节数。
 *  返回值: 返回实际写出的字节数, 0表示什么也没有写

### open(…,…,…) ###

*  open(…,…,…)17

*  原型:int open(const char *pathname, int oflag, … /* mode\_t mode \*/);——【\#include <fcntl.h>】
 *  举例: 阻塞方式打开：int fd = open("/dev/tty", O\_RDWR|O\_NONBLOCK); 非阻塞方式打开：int fd = open("/dev/tty", O\_RDWR);
 *  功能:函数第一个参数是指向文件名的指针（一般填写路径名），第二个参数是文件的打开模式标记，第三个参数（…）仅当创建新文件时才使用，用于指定文件的访问权限位（access permission bits）。  
    oflag 用于指定文件的打开/创建模式，这个参数可由以下常量（定义于 fcntl.h）通过逻辑或构成。

<table> 
 <thead> 
  <tr> 
   <th>模式</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>O_RDONLY</td> 
   <td>只读模式</td> 
  </tr> 
  <tr> 
   <td>O_WRONLY</td> 
   <td>只写模式</td> 
  </tr> 
  <tr> 
   <td>O_RDWR</td> 
   <td>读写模式</td> 
  </tr> 
 </tbody> 
</table>

打开/创建文件时，至少得使用上述三个常量中的一个。以下常量是选用的：

<table> 
 <thead> 
  <tr> 
   <th>模式</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>O_APPEND</td> 
   <td>每次写操作都写入文件的末尾</td> 
  </tr> 
  <tr> 
   <td>O_CREAT</td> 
   <td>如果指定文件不存在，则创建这个文件</td> 
  </tr> 
  <tr> 
   <td>O_EXCL</td> 
   <td>如果要创建的文件已存在，则返回 -1，并且修改 errno 的值</td> 
  </tr> 
  <tr> 
   <td>O_TRUNC</td> 
   <td>如果文件存在，并且以只写/读写方式打开，则清空文件全部内容</td> 
  </tr> 
  <tr> 
   <td>O_NOCTTY</td> 
   <td>如果路径名指向终端设备，不要把这个设备用作控制终端。</td> 
  </tr> 
  <tr> 
   <td>O_NONBLOCK</td> 
   <td>如果路径名指向 FIFO/块文件/字符文件，则把文件的打开和后继 I/O设置为非阻塞模式（nonblocking mode）</td> 
  </tr> 
 </tbody> 
</table>

*  返回值：成功则返回文件描述符，否则返回 -1
 *  [**因调用open()出现call to ‘\_\_open\_missing\_mode’ declared with attribute error。。解决方案**][open_call to _open_missing_mode_ declared with attribute error]

#### 阻塞与非阻塞 ####

*  阻塞与非阻塞18

*  非阻塞
    
     *  O\_NONBLOCK和O\_NDELAY所产生的结果都是使I/O变成非阻塞模式(non-blocking)，在读取不到数据或是写入缓冲区已满会马上return，而不会阻塞等待。
     *  它们的差别在于：在读操作时，如果读不到数据，O\_NDELAY会使I/O函数马上返回0，但这又衍生出一个问题，因为读取到文件末尾(EOF7)时返回的也是0，这样无法区分是哪种情况。因此，O\_NONBLOCK就产生出来，它在读取不到数据时会回传-1，并且设置errno为EAGAIN。
     *  一般使用O\_NONBLOCK。

### close(…,…,…) ###

### access(…,…) ###

### mkfifo(…,…,…) ###

*  mkfifo(…,…,…)19

*  原型:int mkfifo(const char \* pathname,mode\_t mode);——【\#include<sys/types.h> \#include<sys/stat.h>】
 *  举例:int ret=mkfifo("/media/my\_write\_read\_fifo",O\_CREAT|O\_EXCL|660);或mkfifo("/media/my\_write\_read\_fifo",0666|S\_IFIFO);
 *  功能:依参数pathname建立特殊的FIFO文件，该文件必须不存在，而参数mode为该文件的权限（mode%~umask），因此 **umask**20值也会影响到FIFO文件的权限。Mkfifo()建立的FIFO文件其他进程都可以用读写一般文件的方式存取。

#### Linux文件访问权限 ####

*  Linux文件访问权限 21

#### \#include 《sys/stat.h》作用 ####

*  \#include 《sys/stat.h》作用 22

*  是unix/linux系统定义文件状态所在的伪标准头文件。
 *  一般头文件在/usr/include下面，这里是标准C程序头文件，如果你的头文件前加了 <sys/\*>,那说明这是系统调用函数头文件，其在/usr/include/sys下面。
 *  函数都是获取文件（普通文件，目录，管道，socket，字符，块）的属性。
 *  位置:我的头文件位置在usr/include/sys/下面；若找不到，可能在：/usr/include/x86\_64-linux-gnu/sys/下面  
    ![stat.h的位置][stat.h]
 *  PS:(因为编辑器问题,将一对尖括号改成了一对书名号来显示)

### QString与char等类型的转换 ###

*  QString与char等类型的转换23

1.  QString 转换成 char \* 24：

明智做法：【QString转换为QByteArray  与  QByteArray 与 char* 的转换】
          QString Qstr = "Test";
          char *chStr = NULL;
          QByteArray ba = str.toLatin1();或者str.toAscii();
       	  chStr = (char *)malloc(ba.length() + 1);
          memset(chStr, 0, ba.length());//将数组初始化
          memcpy(chStr, ba.data(), ba.length());
          chStr[ba.length()] = '\0';
     直接做法：
          QString str="abc";
          char *ch; 
          QByteArray ba = str.toLatin1();
          ch = ba.data();

1.  char \* 转换成 QString：

char *c_str = "123456789";
         QString string = QString(QLatin1String(c_str));

1.  QString 转换成 char \[\] 或 char \[\] 转换成 QString25：

char path[50];
       QString str = "D:\\搜狗\\weka-3jre-x64.exe";
       QByteArray ba = str.toLocal8Bit();
       memcpy(path,ba.data(),ba.size()+1);//加1是为了最后的终结符，否则转换回来的时候不知道什么时候截止
       或者
       char path2[50];
       QString str2;
       str2 = QString::fromLocal8Bit(path2);
       【若用str2 = path2时，运行正常，反而用上一行，出异常了，可能环境不同导致】

1.  char \* 转换成 char \[\] 或 char \[\] 转换成 char \* 26：

char * b;
    	char buf[100];
        strcpy(buf,b);//一般用于char *  转换成 char []
        strcpy(b,buf);//虽然不报异常,但char [] 转换成 char   * 一般是下面这样的:
    
    	b=buf;//是不是很简单,b是字符指针,只需存buf变量的指针便可完成转换
    
    	也可以:
    	memcpy(buf,b,100);

1.  char 转换成 QString：

char a='b'; 
       QString str; 
       str=QString(a);

1.  QByteArray 转换成 char \*：

char *ch;//不要定义成ch[n]; 
       QByteArray byte;
       ch = byte.data();

1.  char \* 转换成 QByteArray：

char *ch; 
       QByteArray byte; 
       byte = QByteArray(ch);

1.  QString 转换成 QChar(一般要数组来存哦)：

QString str = "123cycy";
         QChar *b = new QChar[7];//b[0]~b[6]就能读取相对应的字符
         b = str.data();

1.  QChar 转换成 QString：

直接使用 QString(QChar ch)即可
        或者QString::append(QChar ch)也行

1.  QChar 转换成 char：

char ch；
        QChar Qch；
        ch = QCh.toLatin1();或QChar::toAscii ();

1.  char 转换成 QChar：

QChar(char ch) /QChar(uchar ch)

1.  QString 转换成 数字27：

QString::toXXX 系类函数
        如:
        QString a="120";
        int b; 
        b=a.toInt();

1.  数字 转换成 QString：

QString::number()
        setNum()
        如:
        int a=10; 
        QString b; 
        b=QString::number(a);

1.  [*QByteArray和十六进制的QString（char）相互转换*\*][QByteArray_QString_char]
2.  QString 转换成 QByteArray：

QByteArray byte; 
        QString string; 
        byte = string.toAscii();

1.  QByteArray 转换成 QString：

QByteArray byte; 
        QString string; 
        string = QString(byte);

1.  QString 转换成 string：

QString.toStdString(); 
        string --> QString QString::fromStdString(string);

1.  QDateTime 转换成 QString ：

QString strBuffer;   
         QDateTime time;    
         time = QDateTime::currentDateTime();    
         strBuffer = time.toString("yyyy-MM-dd hh:mm:ss");    
         // strBuffer = 2015-12-21 17:35:00

1.  QDateTime 转换成 QString ：

QString strBuffer;   
         QDateTime time;    
         strBuffer = "2010-07-02 17:35:00";   
         time = QDateTime::fromString(strBuffer, "yyyy-MM-dd hh:mm:ss");

1.  QStringList 转换成 QString

QStringList list;
    list << "111" << "222" << "333";//即list=("111","222","333")
    QString str = list.value(2);//指的是取list下标为2的值，也可以用at(int)函数，但是value(int)函数会更安全（在赋予的int值为越界元素情况下）

1.  QString 转换成 QStringList

QStringList list;
    QString imgPath = "/mnt/name.jpg";
    QString folderName = "/mnt";
    QString imgName = "name.jpg";
    list.append(imgPath);
    list.append(folderName);
    list << imgName;//添加到QStringList的两种方式
    qDebug() << list111 << "== list111";
    //打印结果：("/mnt/name.jpg", "/mnt", "name.jpg") == list111

\[---------------从这开始,是C++时的转换------------\]

1.  string 转换成 char \* 28：

std::string str="两袖清风";
         //Tips:c_str()函数是把string 转换为const char*类型
         const char* cStr = str.c_str();
         qDebug()<<cStr<<endl;

1.  char \* 转换成 string ：

char* cStr ="两袖清风";
         std::string str(cStr);
         qDebug()<<str.c_str()<<endl;

1.  unsigned char 转换成 char 29 ：

1.  char 转换成 unsigned char ：

1.  int 转换成 char \* ：

1.  char \* 转换成 int ：

1.  int 转换成 char\[\]：

//我使用了union

1.  char\[\] 转换成 int ：

1.  char 转换成 int30：

1.  int转换成 char：

#### char \*\* 与char \* ####

*  char \*\* 与char \*26

*  char \*a \[ \];
    
     *  解释:由于\[ \] 的优先级高于\* 所以a先和 \[ \]结合,但它还是个数组,数组中的元素才是char \*,即类型为char \*,表示保存地址的指针变量值。
    
     *  如:char \*a\[ \] = \{“China”,“French”,“America”,“German”\};sizeof(a) = 16;
     *  解释:字符串常量的本质是地址，a 数组中的元素为char \* 指针，指针变量占四个字节，那么四个元素就是16个字节了;另外元素保存的是不连续的内存地址。
 *  char \*\*s;
    
     *  char \*\*为二级指针， s保存一级指针 char \*的地址。
     *  二级指针保存的是一级指针的地址，它的类型是指针变量，而一级指针保存的是指向数据所在的内存的单元的地址，虽然都是地址，但是类型是不一样的。

### memset(…,…,…) ###

*  memset(…,…,…)27

*  原型:void memset(void \* s,int c,size\_t n);——s的n长度都为c值【\# include <string.h>】
 *  举例:char a\[100\];memset(a, '\\0’或0, sizeof(a));
 *  功能:是初始化函数（主要初始化某个内存空间），将指针变量 s 所指向的前 n 字节的内存单元用一个“整数” c 替换，注意 c 是 int 型。s 是 void\* 型的指针变量，所以它可以为任何类型的数据进行初始化。用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为‘ ’或‘\\0’。
 *  注意:一般使用“0”初始化内存单元，而且通常是给数组或结构体进行初始化。可以给字符串数组赋值为 ‘\\0’ 和 0 ，因为它俩是等价的，而且字符 ‘\\0’ 在内存中就是 0。但在 memset 中初始化为 0 也具有结束标志符 ‘\\0’ 的作用，所以通常我们就写“0”。

### strcpy(…,…) ###

*  strcpy(…,…)28

*  原型:char\* strcpy(char\* dest, const char\* src);——实现src到dest的字符串复制【\# include <string.h>】
 *  举例:char a\[100\],b\[50\];strcpy(a,b);——要注意a中的字符串长度（第一个‘\\0’之前）是否超过50位，如超过，则会造成b的内存地址溢出。
 *  功能:即string copy（字符串复制）的缩写；只用于字符串复制，并且它不仅复制字符串内容之外，还会复制字符串的结束符，它遇到’\\0’就结束拷贝。
 *  注意:str也可以用用个参数的strncpy(a,b,n)。

#### 与memcpy(…,…,…)的区别 ####

*  与memcpy(…,…,…)的区别31

##### memcpy(…) #####

*  原型:void \*memcpy( void \*dest, const void \*src, size\_t count );——将src复制count长度到dest【\# include <string.h>】
 *  举例:char a\[100\],b\[50\]; memcpy(b, a, sizeof(b));——注意如用sizeof(a)，会造成b的内存地址溢出。
 *  功能:是内存拷贝函数；提供了内存的复制（主要拷贝源空间的数据到目的空间中），对于需要复制的内容没有限制，因此用途更广，可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度。

##### 区别 #####

1.  复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。
2.  复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
3.  用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy。

### strncmp(…,…,…) ###

*  strncmp(…,…,…)32

*  原型:int strncmp(const char \*str1, const char \*str2, size\_t n);——比较n个长度的字符，str1比较str2，若大于，返回值是>0的，以此类推。【\#include <string.h>】
 *  举例:

char str1[15];
      char str2[15];
      int ret;
      strcpy(str1, "abcdef");
      strcpy(str2, "ABCDEF");
      ret = strncmp(str1, str2, 4);
      结果是:str2 小于 str1

*  功能:str1 – 要进行比较的第一个字符串。str2 – 要进行比较的第二个字符串。n – 要比较的最大字符数。
 *  注意:该函数区分大小写。
 *  返回值:  
    如果返回值 < 0，则表示 str1 小于 str2。  
    如果返回值 > 0，则表示 str2 小于 str1。  
    如果返回值 = 0，则表示 str1 等于 str2。

#### 与strcmp(…,…,…)的区别 ####

##### strcmp(…,…,…) #####

*  原型:strcmp(const char str1,const char str2);——str1比较str2，若大于，返回值是>0的，以此类推。【\#include <string.h>】
 *  举例:

strcmp(“abcd”,”abcd”)的返回值是 0； 
    strcmp(“abcd”,”dcba”)的返回值是 -1； 
    strcmp(“dcba”,”abcd”)的返回值是 1；

*  功能:可用于比较两个字符串常量，或比较数组和字符串常量，不能比较数字等其他形式的参数。
 *  返回值:  
    比较两个字符串  
    设这两个字符串为str1，str2，  
    若str1==str2，则返回零；  
    若str1 < str2，则返回负数；  
    若str1 > str2，则返回正数。

##### 区别 #####

*  strcmp与strncmp都是用来比较字符串的，区别在于能否比较指定长度字符串。

### puts(…,…,…) ###

#### 与printf(…,…,…),qDebug(),fputs(…,…,…),scanf(…,…,…)的区别 ####

##### printf(…,…,…) #####

*  C++时：除了打印字符串，还可以打印相应的值
    
     *  %p、 %s 、%d 、%u 33

##### qDebug() #####

##### fputs(…,…,…) #####

##### scanf(…,…,…) #####

##### 区别 #####

*  区别34

### union ###

*  [**【C/C++】联合union的用法和说明**][C_C_union]
 *  [**联合(union)的用法**][union]

#### struct ####

##### 与struct的区别 #####

*  [**C语言union关键字,union和struct区别**][C_union_union_struct]

## 实例 ##

### FIFO例子 ###

*  FIFO例子35

#### 实现方式 ####

*  实现方式36

### 与pipe区别37 ###

## 顺手了解 ##

*  [**Qt实现环形缓冲区的两种方法**][Qt]

### I2C（IIC） ###

*  [**I2C总线通讯协议**][I2C]
 *  [**linux 标准i2c接口（一）**][linux _i2c]
 *  [I2c通信读写接口调用][I2c]
 *  [**张高兴的 .NET Core IoT 入门指南：（三）使用 I2C 进行通信**][.NET Core IoT _ I2C]
 *  [**浅谈总线通信机制(通信基础+串口+I2C)**][I2C 1]
 *  [Linux I2C工具查看配置I2C设备][Linux I2C_I2C]

## 论坛 ##

*  [qt怎么读取管道中的数据 麻烦给讲解下 谢谢 ][qt_ _ _]
    
     *  [**QLocalSocket Class**][QLocalSocket Class]

# 总结 #

--------------------

1.  [**1字节=多少M**][1_M]、[**位（bit）、字节（byte）、字符、编码之间的关系**][bit_byte]、[**比特(位,bit),字节(Byte),字符的区别**][bit_Byte]、[**bit、byte、位、字节、汉字、字符之间的区别**][bit_byte 1]、[**字节、字、位、比特，这四者之间的关系是什么？**][Link 2] ↩︎
2.  [**C++中定义和声明的区别**][C]、[**c++中定义和声明的区别**][c]、[**C语言中变量的声明和定义**][C 1] ↩︎
3.  [**C语言中字符串结束符’\\0’**][C_0] Or [**C语言中字符串结束符’\\0’的讨论**][C_0 1]、[**字符串结尾‘0’和‘\\0’的区别**][0_0] ↩︎
4.  [**string字符串以’\\0’结尾**][string_0]、[**C字符串末尾的’\\0’问题**][C_0 2] ↩︎
5.  [**文件权限定义**][Link 3]、[**文件权限文档**][Link 4][**mode\_t 内核文件权限值 S\_IRUGO=S\_IRUSR | S\_IRGRP | S\_IROTH**][mode_t _ S_IRUGO_S_IRUSR _ S_IRGRP _ S_IROTH] ↩︎
6.  [**Linux的文件描述符**][Linux]、[**文件系统之文件描述符**][Link 5]、[**理解文件描述符**][Link 6]、[**Linux文件描述符**][Linux 1]、[**区别文件描述符(Linux)和文件指针(C语言)**][Linux_C]、[**C语言—文件描述符**][C 2] ↩︎
7.  [**C语言 sizeof函数详解**][C_ sizeof]、[**C语言基础——sizeof的用法总结**][C_sizeof]、[**sizeof（）函数用法汇总**][sizeof 2]、[**sizeof()的用法**][sizeof 3] Or [**c++中sizeof()的用法介绍**][c_sizeof]、[**strlen（）和 sizeof （）的区别**][strlen_ sizeof] Or [**strlen和sizeof的区别与总结**][strlen_sizeof]、[**Qt中sizeof**][Qt_sizeof]、[**C语言中sizeof（）和strlen（）的区别**][C_sizeof_strlen]、[**C语言中sizeof()与strlen()函数的使用入门及对比**][C_sizeof_strlen 1]、[**C++中sizeof()、size()、length()、strlen()以及vector容器中size()的区别**][C_sizeof_size_length_strlen_vector_size] Or [**c/c++中sizeof()、strlen()、length()、size()详解和区别**][c_c_sizeof_strlen_length_size] ↩︎ ↩︎
8.  [**C/C++中strlen的用法**][C_C_strlen] ↩︎
9.  [**【C语言】运算符与操作符的用法全面汇总(非常有用)**][C 3]、[**操作符和运算符的区别**][Link 7] ↩︎
10. [**C 库函数 - perror()**][C _ - perror]、[**perror strerror使用方法**][perror strerror] ↩︎
11. [**errno 和perror**][errno _perror]、[**perror与errno**][perror_errno]、[**linux中errno及perror的应用**][linux_errno_perror] ↩︎
12. [**read函数与write函数**][read_write]、[**read/write函数**][read_write 1]【还提到了“文件描述符”】、[**C++文件操作Read函数**][C_Read]、[**Qt二进制文件操作（读和写）详解**][Qt 1]、[**c/c++ 网络编程 read，write函数深入理解**][c_c_ _ read_write] ↩︎
13. [**gets和fgets函数的区别**][gets_fgets]、[**c语言gets()函数与它的替代者fgets()函数**][c_gets_fgets]、[**c语言中gets ，getschar 和fgets 的用法及三者之间的差别**][c_gets _getschar _fgets]、[**小朋友学C语言（42）：gets和fgets**][C_42_gets_fgets]、[**gets和fgets函数及其区别，C语言gets和fgets函数详解**][gets_fgets_C_gets_fgets]、[**fgets、gets和scanf的区别**][fgets_gets_scanf]、、 ↩︎
14. [**EOF宏，C语言EOF宏详解**][EOF_C_EOF]、[**C语言中EOF什么意思**][C_EOF]、 ↩︎
15. [**Linux下read和fgets的一些比较**][Linux_read_fgets]、[**关于linux下标准读入read和fgets和scanf的区别**][linux_read_fgets_scanf]、 ↩︎
16. [**write函数的详解与read函数的详解**][write_read]、[write的奥秘-linux系统调用如何实现？][write_-linux] ↩︎
17. [**Linux（C/C++）下的文件操作open、fopen与freopen**][Linux_C_C_open_fopen_freopen]、[**C++ open 打开文件（含打开模式一览表）**][C_ open]【C++中使用的，Qt里有自己的一套模式一览表】[**c/c++ 学习-open 函数**][c_c_ _-open]、[**C/C++ open函数的阻塞和非阻塞**][C_C_ open]、[**Linux系统函数open和close（02）—open函数的返回值**][Linux_open_close_02_open] ↩︎
18. [**Linux：非阻塞O\_NONBLOCK与O\_NDELAY的区别**][Linux_O_NONBLOCK_O_NDELAY] ↩︎
19. [**mkfifo函数使用**][mkfifo]、[**mkfifo函数**][mkfifo 1]、[**linux系统编程之管道（三）：命名管道FIFO和mkfifo函数**][linux_FIFO_mkfifo]、[**【linux】下的mkfifo 命令 和【C语言】中的mkfifo函数**][linux_mkfifo _ _C_mkfifo]、[**linux mkfifo命令基本用法**][linux mkfifo]、[**有名管道因路径权限，导致创建管道失败的问题分析**][Link 8]、[**有名管道mkfifo**][mkfifo 2]、、、 ↩︎
20. [**umask 怎样影响新建文件的权限？**][umask]、[**umask权限使用**][umask 1]、[**Linux umask限制导致php的mkdir 0777无效**][Linux umask_php_mkdir 0777]、[**Linux----centos下的umask详解（翻译）**][Linux----centos_umask] ↩︎
21. [**linux系统文件访问权限授予**][linux]、[**Linux使用：文件或目录的权限设置**][Linux 2]、[**Linux文件权限**][Linux 3] ↩︎
22. [**linux中\#include <sys/stat.h>的位置**][linux_include _sys_stat.h]、 [**\#include <sys/stat.h>的作用**][include _sys_stat.h] ↩︎
23. [**QString-char 之间的转化**][QString-char]、[**Qt中的对象类型转换（Qstring 转换char\*有三种方法）**][Qt_Qstring _char]、[**QT中 QString 、String与char\*三者之间相互转换**][QT_ QString _String_char]、[\**char\[\]，char ，string之间转换*][char_char _string] ↩︎
24. [Qt学习路程（四）QString转char \* 数组][Qt_QString_char _]、[**QT如何将QlineEdit里的QString字符串存储到unsigned char 数组中**][QT_QlineEdit_QString_unsigned char]、[VC中char\* 与 char\[\] 的区别][VC_char_ _ char_]、[Qt下 QString转char\*][Qt_ QString_char] ↩︎
25. [**【QT笔记】QString与char数组转换**][QT_QString_char] ↩︎
26. [**char \*\* 与char \* a\[ \] 区别**][char _ _char _ a_ _]、[*深入 理解char \* ,char \*\* ,char a\[ \] ,char a\[\] 的区别*][_char _ _char _ _char a_ _ _char a_]、[**char(**)与(char)的区别\*\*][char_char]、[*搬砖：char 和char\[\]的区别*\*][char _char]、[*char 和 char\[\]的区别*\*][char _ char] ↩︎ ↩︎
27. [**memset函数及其用法，C语言memset函数详解**][memset_C_memset] ↩︎ ↩︎
28. [**strcpy函数处理溢出的建议**][strcpy] ↩︎ ↩︎
29. [**深入了解计算机系统中：unsigned char和char的思考和实验**][unsigned char_char]、[**【14】unsigned char、char、int之间的转换**][14_unsigned char_char_int]、[**unsigned char与char 转换**][unsigned char_char 1]、[**字符串转化为整数/char和unsigned char**][char_unsigned char]、[**C语言 如何把一个变量值赋给一个数组。**][C_]、、、 ↩︎
30. [**int转换char的正确姿势**][int_char]、[**c++中int与char相互转换**][c_int_char]、[**char转int，int转char**][char_int_int_char]、、 ↩︎
31. [**深入理解strcpy与memcpy的区别**][strcpy_memcpy]、[**strcpy、memcpy和memset之间的区别**][strcpy_memcpy_memset]【主要是"strcpy与memcpy的区别"】、[**memset ,memcpy 和strcpy 的根本区别？**][memset _memcpy _strcpy]【也讲了memset()函数】 ↩︎
32. [**C 库函数 - strncmp()**][C _ - strncmp]、[**strcmp与strncmp的区别**][strcmp_strncmp]、[**strncmp–百度百科**][strncmp] ↩︎
33. [**C\_printf中的%p的实质**][C_printf_p]、[**C/C++ %s %d %u 基本概念与用法**][C_C_ _s _d _u] ↩︎
34. [**puts和printf更深层次的区别（同一参数，却得出了不同的结果）**][puts_printf]、[**scanf、printf、gets、puts的应用及区别**][scanf_printf_gets_puts]、[**C语言scanf（）和gets（）及printf（）和puts（）的区别**][C_scanf_gets_printf_puts]、、、、 ↩︎
35. [**命名管道FIFO**][FIFO 1]、[**使用FIFO来进行两个进程间的通信**][FIFO 2]、[**《Linux 进程间通信》命名管道：FIFO**][Linux _FIFO]、[**Linux下循环缓存区（fifo）的实现**][Linux_fifo]、[**linux有名管道fifo，进程间通信**][linux_fifo]、[**Linux-进程间通信（二）: FIFO**][Linux-_ FIFO]、[Linux系统编程——进程间通信：命名管道（FIFO）][Linux_FIFO]、、、、、、 ↩︎
36. [**FIFO的数组实现方式**][FIFO 3]、[**C语言循环数组做FIFO队列–一些认识**][C_FIFO]、、、 ↩︎
37. [**fifo与pipe总结**][fifo_pipe]、[**linux系统编程之管道（一）：匿名管道和pipe函数**][linux_pipe]、[**linux系统编程之管道（二）：管道读写规则和Pipe Capacity、PIPE\_BUF**][linux_Pipe Capacity_PIPE_BUF] ↩︎

[FIFO]: https://baike.baidu.com/item/FIFO%E7%AE%A1%E9%81%93/8466221?fr=aladdin
[20191222112839725.png]: https://img-blog.csdnimg.cn/20191222112839725.png
[Link 1]: https://baike.baidu.com/item/%E6%96%87%E4%BB%B6%E6%8F%8F%E8%BF%B0%E7%AC%A6/9809582?fr=aladdin
[sizeof]: https://baike.baidu.com/item/sizeof/6349467?fr=aladdin
[sizeof 1]: https://img-blog.csdnimg.cn/20191222124257474.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDQyNTk1,size_16,color_FFFFFF,t_70
[strlen]: https://baike.baidu.com/item/strlen/2737?fr=aladdin
[sizeof_strlen]: https://img-blog.csdnimg.cn/20191223110444901.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDQyNTk1,size_16,color_FFFFFF,t_70
[perror]: https://baike.baidu.com/item/perror/6828989?fr=aladdin
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDQyNTk1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191222120437696.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDQyNTk1,size_16,color_FFFFFF,t_70
[errno]: https://img-blog.csdnimg.cn/20191222121027476.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDQyNTk1,size_16,color_FFFFFF,t_70
[open_call to _open_missing_mode_ declared with attribute error]: https://blog.csdn.net/ok_4444/article/details/22393927
[stat.h]: https://img-blog.csdnimg.cn/20191222131332994.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDQyNTk1,size_16,color_FFFFFF,t_70
[QByteArray_QString_char]: https://www.cnblogs.com/ch122633/p/8393406.html
[C_C_union]: https://blog.csdn.net/jaken99/article/details/77586954?depth_1-utm_source=distribute.pc_relevant_right.none-task&utm_source=distribute.pc_relevant_right.none-task
[union]: https://blog.csdn.net/RuoQiQingCheDi/article/details/83965177
[C_union_union_struct]: https://www.cnblogs.com/timssd/p/4078334.html
[Qt]: https://blog.csdn.net/caoshangpa/article/details/52966954
[I2C]: https://www.cnblogs.com/microxiami/p/8527464.html
[linux _i2c]: https://www.cnblogs.com/xuyh/p/4959499.html
[I2c]: http://blog.sina.com.cn/s/blog_179b7335b0102zayf.html
[.NET Core IoT _ I2C]: https://cloud.tencent.com/developer/article/1430674
[I2C 1]: https://cloud.tencent.com/developer/article/1457058
[Linux I2C_I2C]: http://blog.chinaunix.net/uid-26895763-id-3478882.html
[qt_ _ _]: https://bbs.csdn.net/topics/390822768
[QLocalSocket Class]: https://doc.qt.io/archives/qt-4.8/qlocalsocket.html
[1_M]: https://zhidao.baidu.com/question/24177184.html
[bit_byte]: https://blog.csdn.net/prdslf001001/article/details/78615823
[bit_Byte]: https://blog.csdn.net/amqvje/article/details/43871461
[bit_byte 1]: https://blog.csdn.net/superman4933/article/details/50959270
[Link 2]: https://zhidao.baidu.com/question/82401103.html
[C]: https://blog.csdn.net/hanzhen7541/article/details/99115945
[c]: https://blog.csdn.net/m0_37962600/article/details/78334077
[C 1]: https://blog.csdn.net/skk18739788475/article/details/79643978
[C_0]: https://www.cnblogs.com/kaituorensheng/archive/2013/12/09/3464462.html
[C_0 1]: https://blog.csdn.net/YEYUANGEN/article/details/6792683
[0_0]: https://blog.csdn.net/u012212001/article/details/51612649
[string_0]: https://blog.csdn.net/N1neDing/article/details/81812168
[C_0 2]: https://www.cnblogs.com/zywscq/p/5361945.html
[Link 3]: https://blog.csdn.net/l09120204/article/details/52243388
[Link 4]: https://www.freepascal.org/docs-html/rtl/baseunix/index-8.html#SECTIONS
[mode_t _ S_IRUGO_S_IRUSR _ S_IRGRP _ S_IROTH]: https://blog.csdn.net/qq_38570571/article/details/81083279
[Linux]: https://www.cnblogs.com/diantong/p/10413079.html
[Link 5]: https://www.jianshu.com/p/5e29fea10f82
[Link 6]: https://www.jianshu.com/p/a2df1d402b4d
[Linux 1]: https://www.cnblogs.com/fasionchan/p/9445033.html
[Linux_C]: https://www.cnblogs.com/weizhixiang/articles/5755115.html
[C 2]: https://blog.csdn.net/qq_32792075/article/details/77984178
[C_ sizeof]: https://blog.csdn.net/heybeaman/article/details/80346832
[C_sizeof]: https://blog.csdn.net/u013812502/article/details/81198452
[sizeof 2]: https://blog.csdn.net/liuligui5200/article/details/79112964
[sizeof 3]: https://www.jianshu.com/p/0e0773d54fbb
[c_sizeof]: https://www.cnblogs.com/huolong-blog/p/7587711.html
[strlen_ sizeof]: https://blog.csdn.net/lee514/article/details/82940859
[strlen_sizeof]: https://blog.csdn.net/follow_blast/article/details/79084726
[Qt_sizeof]: https://www.cnblogs.com/lt47/p/5992014.html
[C_sizeof_strlen]: https://blog.csdn.net/qq_41112517/article/details/78942059
[C_sizeof_strlen 1]: https://www.jb51.net/article/75774.htm
[C_sizeof_size_length_strlen_vector_size]: http://blog.sina.com.cn/s/blog_a50192fb0102xhs1.html
[c_c_sizeof_strlen_length_size]: https://blog.csdn.net/z_qifa/article/details/77744482
[C_C_strlen]: https://blog.csdn.net/smf0504/article/details/51372351
[C 3]: https://blog.csdn.net/as480133937/article/details/88361848
[Link 7]: https://zhidao.baidu.com/question/297794878.html
[C _ - perror]: https://www.runoob.com/cprogramming/c-function-perror.html
[perror strerror]: https://www.cnblogs.com/Malphite/p/7821305.html
[errno _perror]: https://blog.csdn.net/chwzmx123/article/details/52833001
[perror_errno]: https://blog.csdn.net/zuoside__lord/article/details/82459472
[linux_errno_perror]: https://www.cnblogs.com/noxy/p/11188583.html
[read_write]: https://www.cnblogs.com/hesper/p/10739065.html
[read_write 1]: https://www.cnblogs.com/ly01/p/4598153.html
[C_Read]: https://blog.csdn.net/W614171629/article/details/81907790
[Qt 1]: http://c.biancheng.net/view/1879.html
[c_c_ _ read_write]: https://www.cnblogs.com/xiaoshiwang/p/10536026.html
[gets_fgets]: https://www.cnblogs.com/aexin/p/3908003.html
[c_gets_fgets]: https://www.cnblogs.com/qingergege/p/5925811.html
[c_gets _getschar _fgets]: https://zhidao.baidu.com/question/175517768520014244.html
[C_42_gets_fgets]: https://www.jianshu.com/p/13a9ca6ca354
[gets_fgets_C_gets_fgets]: http://c.biancheng.net/view/379.html
[fgets_gets_scanf]: http://blog.sina.com.cn/s/blog_7d7e9d0f0101nde1.html
[EOF_C_EOF]: http://c.biancheng.net/view/345.html
[C_EOF]: https://blog.csdn.net/xiachong27/article/details/88253830
[Linux_read_fgets]: https://blog.csdn.net/u010857719/article/details/78334657
[linux_read_fgets_scanf]: https://blog.csdn.net/caiyunl/article/details/7489564
[write_read]: https://blog.csdn.net/dangzhangjing97/article/details/79619894
[write_-linux]: https://blog.csdn.net/haozhao_blog/article/details/20855911
[Linux_C_C_open_fopen_freopen]: https://www.cnblogs.com/fnlingnzb-learner/p/7040726.html
[C_ open]: http://c.biancheng.net/view/294.html
[c_c_ _-open]: https://blog.csdn.net/jiahehao/article/details/1841776
[C_C_ open]: https://www.linuxidc.com/Linux/2019-04/158300.htm
[Linux_open_close_02_open]: https://blog.csdn.net/sinat_25457161/article/details/48545433
[Linux_O_NONBLOCK_O_NDELAY]: https://blog.csdn.net/q1449516487/article/details/90969055
[mkfifo]: https://blog.csdn.net/superywf/article/details/73438465
[mkfifo 1]: https://blog.csdn.net/hao95165/article/details/45313811
[linux_FIFO_mkfifo]: https://blog.csdn.net/jnu_simba/article/details/8953960
[linux_mkfifo _ _C_mkfifo]: https://www.cnblogs.com/xianghang123/archive/2012/03/31/2427731.html
[linux mkfifo]: https://www.cnblogs.com/old-path-white-cloud/p/11685558.html
[Link 8]: http://blog.chinaunix.net/uid-30256248-id-5189464.html
[mkfifo 2]: https://www.cnblogs.com/zhangxuan/p/6709844.html
[umask]: https://feichashao.com/umask/
[umask 1]: https://www.cnblogs.com/fanweisheng/p/11108710.html
[Linux umask_php_mkdir 0777]: https://www.iteye.com/blog/justcoding-2189005
[Linux----centos_umask]: https://www.jianshu.com/p/8018b53f64ec
[linux]: https://www.cnblogs.com/one-beginner/p/8780897.html
[Linux 2]: https://www.jianshu.com/p/c5f4b11853b4
[Linux 3]: https://www.cnblogs.com/TsengYuen/archive/2012/05/16/2504084.html
[linux_include _sys_stat.h]: https://cloud.tencent.com/developer/article/1353751
[include _sys_stat.h]: https://www.cnblogs.com/aboutblank/p/3617196.html
[QString-char]: http://blog.sina.com.cn/s/blog_9454bfec0102x87u.html
[Qt_Qstring _char]: https://www.e-learn.cn/content/qita/807892
[QT_ QString _String_char]: https://blog.csdn.net/annjeff/article/details/81327340
[char_char _string]: https://blog.csdn.net/qq_33375598/article/details/88757046
[Qt_QString_char _]: https://blog.csdn.net/MyFamily_IT/article/details/81407114
[QT_QlineEdit_QString_unsigned char]: https://blog.csdn.net/shirnyhelloworld/article/details/52024207
[VC_char_ _ char_]: https://www.xuebuyuan.com/3192399.html
[Qt_ QString_char]: https://www.cnblogs.com/Romi/archive/2012/03/12/2392478.html
[QT_QString_char]: https://blog.csdn.net/sinat_37269729/article/details/96855670
[char _ _char _ a_ _]: https://my.oschina.net/u/920274/blog/2877046
[_char _ _char _ _char a_ _ _char a_]: https://blog.csdn.net/daiyutage/article/details/8604720
[char_char]: https://zhidao.baidu.com/question/456999721.html
[char _char]: https://blog.csdn.net/hunter___/article/details/86629070
[char _ char]: https://blog.csdn.net/qq_32783703/article/details/87707766
[memset_C_memset]: http://c.biancheng.net/view/231.html
[strcpy]: https://blog.csdn.net/punk_lover/article/details/19824499
[unsigned char_char]: https://blog.csdn.net/weixin_41256413/article/details/79897033
[14_unsigned char_char_int]: https://blog.csdn.net/Murphy5222/article/details/82632738
[unsigned char_char 1]: https://blog.csdn.net/GitzLiu/article/details/54016484?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
[char_unsigned char]: http://blog.sina.com.cn/s/blog_15f71769f0102woee.html
[C_]: https://zhidao.baidu.com/question/97507531.html
[int_char]: https://www.cnblogs.com/godtrue/p/8641891.html
[c_int_char]: https://blog.csdn.net/qq_30534935/article/details/82683643
[char_int_int_char]: https://www.cnblogs.com/JimShi/p/11445216.html
[strcpy_memcpy]: https://www.jb51.net/article/37492.htm
[strcpy_memcpy_memset]: https://www.cnblogs.com/573177885qq/p/5302457.html
[memset _memcpy _strcpy]: http://www.cppblog.com/junfeng568/archive/2006/03/11/4022.html
[C _ - strncmp]: https://www.runoob.com/cprogramming/c-function-strncmp.html
[strcmp_strncmp]: https://blog.csdn.net/jianghong678/article/details/47152907
[strncmp]: https://baike.baidu.com/item/strncmp/5522625?fr=aladdin
[C_printf_p]: https://blog.csdn.net/qingzhuyuxian/article/details/80969818
[C_C_ _s _d _u]: https://blog.csdn.net/myyllove/article/details/79574582
[puts_printf]: http://bbs.bccn.net/thread-348957-1-1.html
[scanf_printf_gets_puts]: https://www.cnblogs.com/chensup/p/5798112.html
[C_scanf_gets_printf_puts]: https://blog.csdn.net/xingjiarong/article/details/47282817
[FIFO 1]: https://www.cnblogs.com/lihuidashen/p/3470254.html
[FIFO 2]: https://blog.csdn.net/an_tang/article/details/68951819
[Linux _FIFO]: https://www.cnblogs.com/zhuangquan/p/10132432.html
[Linux_fifo]: http://blog.chinaunix.net/uid-26707720-id-5778337.html
[linux_fifo]: https://www.cnblogs.com/qingergege/p/9489682.html
[Linux-_ FIFO]: https://www.cnblogs.com/wanpengcoder/p/5296467.html
[Linux_FIFO]: https://blog.csdn.net/tennysonsky/article/details/46326957
[FIFO 3]: https://blog.csdn.net/q1302182594/article/details/46929019
[C_FIFO]: https://blog.csdn.net/shoutday/article/details/8204770
[fifo_pipe]: https://blog.csdn.net/zhang63020936/article/details/40295499
[linux_pipe]: https://blog.csdn.net/jnu_simba/article/details/8950648
[linux_Pipe Capacity_PIPE_BUF]: https://blog.csdn.net/jnu_simba/article/details/8952287