常用函数整理（基础篇）

比眉伴天荒 2023-10-14 14:02 72阅读 0赞

![9bf5fbdfb9d14fb4a4367bc72a40f609.png][]**目录**

strcpy

返回值

strcat

Parameters

返回值

例

strncpy

Parameters

返回值

例

strncat

Parameters

返回值

例

strncmp

Parameters

返回值

例

strstr

Parameters

返回值

例

strtok

Parameters

返回值

例

getchar

返回值

putchar

Parameters

返回值

strcmp

Parameters

返回值

memset

Parameters

返回值

例

system

Parameters

参数

返回值

pow

Parameters

返回值

sqrt

Parameters

返回值

例

strlen

Parameters

返回值

例

islower

Parameters

返回值

isupper

Parameters

返回值

toupper

Parameters

返回值

tolower

Parameters

返回值

isalpha

Parameters

返回值

assert

Parameters

返回值

signal

Parameters

返回值

qsort

Parameters

返回值

strerror

Parameters

返回值

例

perror

Parameters.

返回值

例

isspace

Parameters

返回值

例

isdigit

Parameters

返回值

例

iscntrl

Parameters

返回值

isxdigit

Parameters

返回值

salnum

Parameters

返回值

ispunct

Parameters

返回值

isgraph

Parameters

返回值

isprint

Parameters

返回值

memcpy

Parameters

返回值

memmove

Parameters

返回值

memcmp

Parameters

返回值

offsetof

Parameters

返回值

malloc

Parameters

返回值

calloc

Parameters

返回值

realloc

Parameters

返回值

free

Parameters

返回值

fopen

Parameters

返回值

fclose

Parameters

返回值

fgetc

Parameters

返回值

fputc

Parameters

返回值

fgets

Parameters

返回值

fputs

Parameters

返回值

fscanf

Parameters

返回值

fprintf

Parameters

返回值

fread

Parameters

返回值

fwrite

Parameters

返回值

sprintf

Parameters

返回值

sscanf

Parameters

返回值

fseek

返回值

ftell

Parameters

返回值

rewind

Parameters

返回值

feof

Parameters

返回值

## strcpy<string.h> ##

*//字符串拷贝*

char * strcpy ( char * destination, const char * source );

destination(目的地):

Pointer to the destination array where the content is to be copied.

指向要在其中复制内容的目标数组的指针。

source(源):

C string to be copied.

#### 返回值 ####

返回*目标*。

/* strcpy example */
    #include <stdio.h>
    #include <string.h>
    
    int main ()
    {
      char str1[]="Sample string";
      char str2[40];
      char str3[40];
      strcpy (str2,str1);
      strcpy (str3,"copy successful");
      printf ("str1: %s\nstr2: %s\nstr3: %s\n",str1,str2,str3);
      return 0;
    }

输出：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;text-align:left;vertical-align:top;"> <pre style="margin-left:0;"><span style="color:#000000;"><span style="background-color:#ffffff;">
str1: Sample string
str2: Sample string
str3: copy successful
</span></span></pre> </td> 
  </tr> 
 </tbody> 
</table>

## strcat<string.h> ##

//字符串追加

char * strcat ( char * destination, const char * source );

#### Parameters ####

destination(目的地):

Pointer to the destination array, which should contain a C string, and be large enough to contain the concatenated resulting string.(指向目标数组的指针，该数组应包含 C 字符串，并且足够大以包含串联的结果字符串。)

source（源）：

C string to be appended. This should not overlap *destination*.要追加的 C 字符串。这不应与*目标*重叠。（）

#### 返回值 ####

返回*目标*。

#### 例 ####

/* strcat example */
    #include <stdio.h>
    #include <string.h>
    
    int main ()
    {
      char str[80];
      strcpy (str,"these ");
      strcat (str,"strings ");
      strcat (str,"are ");
      strcat (str,"concatenated.");
      puts (str);
      return 0;
    }

输出：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;vertical-align:top;"> <pre style="margin-left:0;"><span style="color:#000000;"><span style="background-color:#ffffff;">
these strings are concatenated. </span></span></pre> </td> 
  </tr> 
 </tbody> 
</table>

## strncpy<string.h> ##

//字符串拷贝，可选择拷贝多少

char * strncpy ( char * destination, const char * source, size_t num );

#### Parameters ####

destination（目的地）

Pointer to the destination array where the content is to be copied.（指向要在其中复制内容的目标数组的指针。）

source（源）

C string to be copied.（要复制的 C 字符串。）

num

Maximum number of characters to be copied from *source*.  
[size\_t][size_t] is an unsigned integral type.

数字

要从*源*复制的最大字符数。  
[size\_t][size_t] 是无符号整数类型。

#### 返回值 ####

返回*目标*。

#### 例 ####

/* strncpy example */
    #include <stdio.h>
    #include <string.h>
    
    int main ()
    {
      char str1[]= "To be or not to be";
      char str2[40];
      char str3[40];
    
      /* copy to sized buffer (overflow safe): */
      strncpy ( str2, str1, sizeof(str2) );
    
    
      /* partial copy (only 5 chars): */
      strncpy ( str3, str2, 5 );
      str3[5] = '\0';   /* null character manually added */
    
      puts (str1);
      puts (str2);
      puts (str3);
    
      return 0;
    }

输出：

## strncat<string.h> ##

//字符串追加，可选择追加多少

char * strncat ( char * destination, const char * source, size_t num );

#### Parameters ####

destination

Pointer to the destination array, which should contain a C string, and be large enough to contain the concatenated resulting string, including the additional null-character.

source

C string to be appended.

num

Maximum number of characters to be appended.  
[size\_t][size_t] is an unsigned integral type.

目的地

指向目标数组的指针，该数组应包含一个 C 字符串，并且足够大以包含串联的结果字符串，包括其他 null 字符。

源

要追加的 C 字符串。

数字

要追加的最大字符数。  
[size\_t][size_t]是无符号整数类

型。

#### 返回值 ####

返回*目标*。

#### 例 ####

/* strncat example */
    #include <stdio.h>
    #include <string.h>
    
    int main ()
    {
      char str1[20];
      char str2[20];
      strcpy (str1,"To be ");
      strcpy (str2,"or not to be");
      strncat (str1, str2, 6);
      puts (str1);
      return 0;
    }

输出：

## strncmp<string.h> ##

//字符串比较：

int strncmp ( const char * str1, const char * str2, size_t num );

#### Parameters ####

str1

C string to be compared.

str2

C string to be compared.

num

Maximum number of characters to compare.  
[size\_t][size_t] is an unsigned integral type.

str1

要比较的 C 字符串。

str2

要比较的 C 字符串。

数字

要比较的最大字符数。  
[size\_t][size_t]是无符号整数类型。

#### 返回值 ####

返回一个整数值，该值指示字符串之间的关系：

<table> 
 <tbody> 
  <tr> 
   <th>返回值</th> 
   <th>表明</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>&lt;0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">不匹配的第一个字符在&nbsp;<em>str1</em>&nbsp;中的值低于&nbsp;<em>str2</em>&nbsp;中的值</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">两个字符串的内容相等</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>&gt;0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">第一个不匹配的字符在&nbsp;<em>str1</em>&nbsp;中的值大于<em>在 str2</em>&nbsp;中的值</td> 
  </tr> 
 </tbody> 
</table>

#### 例 ####

/* strncmp example */
    #include <stdio.h>
    #include <string.h>
    
    int main ()
    {
      char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
      int n;
      puts ("Looking for R2 astromech droids...");
      for (n=0 ; n<3 ; n++)
        if (strncmp (str[n],"R2xx",2) == 0)
        {
          printf ("found %s\n",str[n]);
        }
      return 0;
    }

输出：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;vertical-align:top;"> <pre style="margin-left:0;"><span style="color:#000000;"><span style="background-color:#ffffff;">
Looking for R2 astromech droids...
found R2D2
found R2A6</span></span></pre> </td> 
  </tr> 
 </tbody> 
</table>

## strstr<string.h> ##

//判断str2是不是str1的子串

const char * strstr ( const char * str1, const char * str2 );
          char * strstr (       char * str1, const char * str2 );

#### Parameters ####

str1

C string to be scanned.

str2

C string containing the sequence of characters to match.

str1

要扫描的 C 字符串。

str2

包含要匹配的字符序列的 C 字符串。

#### 返回值 ####

指向 *str1* 中指定的整个字符序列在 str2 中首次出现的指针，如果序列在 *str1* 中不存在，则为 null 指针。

#### 例 ####

/* strstr example */
    #include <stdio.h>
    #include <string.h>
    
    int main ()
    {
      char str[] ="This is a simple string";
      char * pch;
      pch = strstr (str,"simple");
      if (pch != NULL)
        strncpy (pch,"sample",6);
      puts (str);
      return 0;
    }

输出：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;vertical-align:top;"> <pre style="margin-left:0;"><span style="color:#000000;"><span style="background-color:#ffffff;">
This is a sample string
</span></span></pre> </td> 
  </tr> 
 </tbody> 
</table>

## strtok<string.h> ##

//分割字符串

char * strtok ( char * str, const char * delimiters );

#### Parameters ####

str

C string to truncate.  
Notice that this string is modified by being broken into smaller strings (tokens).  
Alternativelly, a null pointer may be specified, in which case the function continues scanning where a previous successful call to the function ended.

delimiters

C string containing the delimiter characters.  
These can be different from one call to another.

str

要截断的 C 字符串。  
请注意，此字符串是通过分解为较小的字符串（标记）来修改的。  
或者，可以指定空指针，在这种情况下，函数将继续扫描以前成功调用函数的位置。

分隔符

包含分隔符字符的 C 字符串。  
这些可能因调用而异。

#### 返回值 ####

如果找到令牌，则指向令牌开头的指针。  
否则为*空指针*。  
当在正在扫描的字符串中到达字符串的末尾（即空字符）时，始终返回*空指针*。

#### 例 ####

/* strtok example */
    #include <stdio.h>
    #include <string.h>
    
    int main ()
    {
      char str[] ="- This, a sample string.";
      char * pch;
      printf ("Splitting string \"%s\" into tokens:\n",str);
      pch = strtok (str," ,.-");
      while (pch != NULL)
      {
        printf ("%s\n",pch);
        pch = strtok (NULL, " ,.-");
      }
      return 0;
    }

输出：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;vertical-align:top;"> <pre style="margin-left:0;"><span style="color:#000000;"><span style="background-color:#ffffff;">
Splitting string "- This, a sample string." into tokens:
This
a
sample
string</span></span></pre> </td> 
  </tr> 
 </tbody> 
</table>

## getchar<stdio.h> ##

//输入

int getchar ( void );

#### 返回值 ####

成功后，将返回字符读取（提升为 int 值）。  
返回类型为 int 以适应特殊值 [EOF][]，该值指示失败：  
如果标准输入位于*文件末尾*，则该函数返回 [EOF][] 并设置 [stdin][] 的 *eof 指示器* （[feof][]）。  
如果发生其他读取错误，该函数还会返回 [EOF][]，但改为设置其*错误指示器* （[ferror][]）。

## putchar<stdio.h> ##

//输出

int putchar ( int character );

#### Parameters ####

character

The int promotion of the character to be written.  
The value is internally converted to an unsigned char when written.

字符

要编写的字符的 int 提升。  
写入时，该值在内部转换为无符号字符。

#### 返回值 ####

成功后，将返回所写*字符*。  
如果发生写入错误，则返回 [EOF][] 并设置*错误指示器*（[ferror][]）。

## strcmp<string.h> ##

//字符串比较

int strcmp ( const char * str1, const char * str2 );

#### Parameters ####

str1

C string to be compared.

str2

C string to be compared.

str1

要比较的 C 字符串。

str2

要比较的 C 字符串。

#### 返回值 ####

返回一个整数值，该值指示字符串之间的关系：

<table> 
 <tbody> 
  <tr> 
   <th> <p></p> <p>返回值</p> </th> 
   <th>表明</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>&lt;0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">第一个不匹配的字符在 PTR1 中的值低于&nbsp;<em>PTR2</em>&nbsp;中的值</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">两个字符串的内容相等</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>&gt;0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">第一个不匹配的字符在 PTR1 中的值大于<em>在 PTR2</em>&nbsp;中的值</td> 
  </tr> 
 </tbody> 
</table>

##  ##

## memset<string.h> ##

//内存设置将这个地址开始的num个数设置为value

void * memset ( void * ptr, int value, size_t num );

#### Parameters ####

ptr

Pointer to the block of memory to fill.

value

Value to be set. The value is passed as an int, but the function fills the block of memory using the *unsigned char* conversion of this *value*.

num

Number of bytes to be set to the *value*.  
[size\_t][size_t] is an unsigned integral type.

PTR

指向要填充的内存块的指针。

价值

要设置的值。该值作为 int 传递，但该函数使用此*值*的*无符号 char* 转换填充内存块。

数字

要设置为*该值*的字节数。  
[size\_t][size_t] 是无符号整数类型。

#### 返回值 ####

*返回 PTR*。

#### 例 ####

/* memset example */
    #include <stdio.h>
    #include <string.h>
    
    int main ()
    {
      char str[] = "almost every programmer should know memset!";
      memset (str,'-',6);
      puts (str);
      return 0;
    }

输出：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;vertical-align:top;"> <pre style="margin-left:0;"><span style="color:#000000;"><span style="background-color:#ffffff;">
------ every programmer should know memset!
</span></span></pre> </td> 
  </tr> 
 </tbody> 
</table>

## system<stdlib.h> ##

//系统命令操作

int system (const char* command);

#### Parameters ####

command

C-string containing the system command to be executed.  
Or, alternatively, a *null pointer*, to check for a command processor.

#### 参数 ####

命令

包含要执行的系统命令的 C 字符串。  
或者，或者使用*空指针*来检查命令处理器。

#### 返回值 ####

如果为 null 指针，则该函数在命令处理器可用时返回非零值，如果*不可用*，则返回零值。  
  
如果不是空指针，则返回的值取决于系统和库实现，但通常应是被调用命令返回的状态代码， 如果支持。

## pow<math.h> ##

//平方

double pow  (double base     , double exponent);
          float powf (float base      , float exponent);
    long double powl (long double base, long double exponent);

#### Parameters ####

base

Base value.

exponent

Exponent value.

基础

基值。

指数

指数值。

#### 返回值 ####

提高权力的结果.  
  
如果 是[有限][Link 1]负数，而 [是有限的][Link 1]但不是整数值，则会导致*域错误*。  
如果两者均为零，则还可能导致某些实现出现*域错误*。  
如果为零且为负数，则可能会导致*域*错误或*极点错误*（或无，具体取决于库实现）。  
如果结果太大或太小而无法用返回类型的值表示，则该函数也可能导致*范围错误*。

## sqrt<math.h> ##

//开平方

*  C99

double sqrt  (double x);
          float sqrtf (float x);
    long double sqrtl (long double x);

#### Parameters ####

Value whose square root is computed.  
If the argument is negative, a *domain error* occurs.

计算平方根的值。  
如果参数为负数，则会发生*域错误*。

#### 返回值 ####

的平方根。  
如果为负数，则发生*域错误*：xx

#### 例 ####

/* sqrt example */
    #include <stdio.h>      /* printf */
    #include <math.h>       /* sqrt */
    
    int main ()
    {
      double param, result;
      param = 1024.0;
      result = sqrt (param);
      printf ("sqrt(%f) = %f\n", param, result );
      return 0;
    }

输出：

## strlen<string.h.h> ##

//计算字符串长度，‘\\0’结束

size_t strlen ( const char * str );

#### Parameters ####

str

C string.

str

C 字符串。

#### 返回值 ####

字符串的长度。

#### 例 ####

/* strlen example */
    #include <stdio.h>
    #include <string.h>
    
    int main ()
    {
      char szInput[256];
      printf ("Enter a sentence: ");
      gets (szInput);
      printf ("The sentence entered is %u characters long.\n",(unsigned)strlen(szInput));
      return 0;
    }

输出：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;vertical-align:top;"> <pre style="margin-left:0;">Enter sentence: just testing
The sentence entered is 12 characters long.
</pre> </td> 
  </tr> 
 </tbody> 
</table>

## islower<ctype.h> ##

//判断小写字母

int islower ( int c );

#### Parameters ####

Character to be checked, casted to an int, or EOF.

要检查、转换为 int 或 EOF 的字符。

#### 返回值 ####

如果 *c* 确实是小写字母，则与零（即 true）不同的值。否则为零（即假）。

## isupper<ctype.h> ##

//判断大写字母

int isupper ( int c );

#### Parameters ####

Character to be checked, casted to an int, or EOF.

要检查、转换为 int 或 EOF 的字符。

#### 返回值 ####

一个不同于零的值（即 true），如果 *c* 确实是一个大写字母。否则为零（即假）。

## toupper<ctype.h> ##

//小写——>大写

int toupper ( int c );

#### Parameters ####

Character to be converted, casted to an int, or EOF.

要转换、转换为 int 或 EOF 的字符。

#### 返回值 ####

大写等效于 c（如果存在此类值），否则为 *c*（未更改）。该值作为 int 值返回，该值可以隐式转换为 char。

## tolower<ctype.h> ##

//大写——>小写

int tolower ( int c );

#### Parameters ####

Character to be converted, casted to an int, or EOF.

要转换、转换为 int 或 EOF 的字符。

#### 返回值 ####

小写等效于 c（如果存在此类值），否则为 *c*（未更改）。  
该值作为 int 值返回，该值可以隐式转换为 char。

## isalpha<ctype.h> ##

//判断是不是字母

int isalpha ( int c );

#### Parameters ####

Character to be checked, casted to an int, or EOF.

要检查、转换为 int 或 EOF 的字符。

#### 返回值 ####

一个不同于零的值（即 true），如果 *c* 确实是一个字母。否则为零（即假）。

## assert<assert.h> ##

//断言

void assert (int expression);

#### Parameters ####

expression

Expression to be evaluated. If this expression evaluates to `0`, this causes an *assertion failure* that terminates the program.

表达

要计算的表达式。如果此表达式的计算结果为 NULL，则会导致*断言失败*，从而终止程序.

#### 返回值 ####

没有

## signal<signal.h> ##

//信号处理

void (*signal(int sig, void (*func)(int)))(int);

#### Parameters ####

sig

处理功能设置为的*信号值*。以下宏常量表达式标识标准信号值：

<table> 
 <tbody> 
  <tr> 
   <th>宏观</th> 
   <th>信号</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SIGABRT</td> 
   <td style="background-color:#ffffff;border-color:#000000;">（信号中止）异常终止，例如由函数启动。<a href="https://legacy.cplusplus.com/abort" title="abort" rel="nofollow">abort</a></td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SIGFPE</td> 
   <td style="background-color:#ffffff;border-color:#000000;">（信号浮点异常）错误的算术运算，例如零除法或导致溢出的运算（不一定使用浮点运算）。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SIGILL</td> 
   <td style="background-color:#ffffff;border-color:#000000;">（信号非法指令）无效的函数图像，例如非法指令。这通常是由于代码损坏或尝试执行数据。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SIGINT</td> 
   <td style="background-color:#ffffff;border-color:#000000;">（信号中断）交互式注意力信号。通常由应用程序用户生成。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SIGSEGV</td> 
   <td style="background-color:#ffffff;border-color:#000000;">（信号分割违规）对存储的无效访问：当程序尝试读取或写入其分配的内存时。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SIGTERM</td> 
   <td style="background-color:#ffffff;border-color:#000000;">（信号终止）终止请求发送到程序。</td> 
  </tr> 
 </tbody> 
</table>

每个库实现都可以提供可与此函数一起使用的其他*信号值*宏常量。  
  
请注意，并非所有运行环境都需要生成自动信号，即使在上述特定情况下也是如此，尽管所有运行环境都必须传递通过显式调用函数生成的信号。[raise][]

函数

指向函数的指针。这可以是由程序员定义的函数，也可以是以下预定义函数之一：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SIG_DFL</td> 
   <td style="background-color:#ffffff;border-color:#000000;">默认处理：信号由该特定信号的默认操作处理。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SIG_IGN</td> 
   <td style="background-color:#ffffff;border-color:#000000;">忽略信号：忽略信号。</td> 
  </tr> 
 </tbody> 
</table>

#### 返回值 ####

返回类型与参数的类型相同。  
  
如果请求成功，该函数将返回指向特定处理程序函数的指针，该处理程序函数负责在调用之前处理此信号（如果有）。或者，或者在调用之前，信号由默认处理程序处理或被忽略。  
  
如果函数未成功注册新的信号处理程序，它将返回并可能设置为正值。

## qsort<stdlib.h> ##

//排序任意类型数据

void qsort (void* base, size_t num, size_t size,
                int (*compar)(const void*,const void*));

#### Parameters ####

base

Pointer to the first object of the array to be sorted, converted to a `void*`.

num

Number of elements in the array pointed to by base.  
[size\_t][size_t 1] is an unsigned integral type.

size

Size in bytes of each element in the array.  
[size\_t][size_t 1] is an unsigned integral type.

compar

Pointer to a function that compares two elements.  
This function is called repeatedly by qsort to compare two elements. It shall follow the following prototype:

基础

指向要排序的数组的第一个对象的指针，转换为 .`void*`

数字

数组中由 指向的元素数。  
是无符号整型。base[size\_t][size_t 1]

大小

数组中每个元素的大小（以字节为单位）。  
是无符号整型。[size\_t][size_t 1]

比较

指向比较两个元素的函数的指针。  
重复调用此函数以比较两个元素。它应遵循以下原型：qsort

将两个指针作为参数（都转换为常量 void\*）。该函数通过返回（以稳定和传递的方式）来定义元素的顺序：

<table> 
 <tbody> 
  <tr> 
   <th>返回值</th> 
   <th>意义</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>&lt;0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">指向的元素 在指向的元素之前p1p2</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">指向的元素等效于p1p2</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>&gt;0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">指向的元素在指向的元素之后p1p2</td> 
  </tr> 
 </tbody> 
</table>

#### 返回值 ####

没有

## strerror<string.h> ##

//获取错误消息字符串的指针

char * strerror ( int errnum );

#### Parameters ####

errnum

Error number.

错误号。

#### 返回值 ####

指向描述错误错误的字符串的指针。

#### 例 ####

/* strerror example : error list */
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    
    int main ()
    {
      FILE * pFile;
      pFile = fopen ("unexist.ent","r");
      if (pFile == NULL)
        printf ("Error opening file unexist.ent: %s\n",strerror(errno));
      return 0;
    }

可能的输出：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;vertical-align:top;"> <pre style="margin-left:0;"><span style="color:#000000;"><span style="background-color:#ffffff;">
Error opening file unexist.ent: No such file or directory
</span></span></pre> </td> 
  </tr> 
 </tbody> 
</table>

## perror<stdio.h> ##

//根据errno中保存的错误代码，打印出来

void perror ( const char * str );

#### Parameters. ####

str

C string containing a custom message to be printed before the error message itself.  
If it is a null pointer, no preceding custom message is printed, but the error message is still printed.  
By convention, the name of the application itself is generally used as parameter.

str

C 字符串，包含要在错误消息本身之前打印的自定义消息。  
如果是空指针，则不会打印前面的自定义消息，但仍会打印错误消息。  
按照惯例，应用程序本身的名称通常用作参数。

#### 返回值 ####

没有

#### 例 ####

/* perror example */
    #include <stdio.h>
    
    int main ()
    {
      FILE * pFile;
      pFile=fopen ("unexist.ent","rb");
      if (pFile==NULL)
        perror ("The following error occurred");
      else
        fclose (pFile);
      return 0;
    }

如果文件 unexist.ent 不存在，则程序输出可能需要与此类似的内容：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;vertical-align:top;"> <pre style="margin-left:0;"><span style="color:#000000;"><span style="background-color:#ffffff;">The following error occurred: No such file or directory</span></span></pre> </td> 
  </tr> 
 </tbody> 
</table>

## isspace<ctype.h> ##

//判断是不是空白字符

int isspace ( int c );

#### Parameters ####

Character to be checked, casted to an int, or EOF.

要检查、转换为 int 或 EOF 的字符。

#### 返回值 ####

一个不同于零的值（即 true），如果 *c* 确实是一个空格字符。否则为零（即假）。

#### 例 ####

/* isspace example */
    #include <stdio.h>
    #include <ctype.h>
    int main ()
    {
      char c;
      int i=0;
      char str[]="Example sentence to test isspace\n";
      while (str[i])
      {
        c=str[i];
        if (isspace(c)) c='\n';
        putchar (c);
        i++;
      }
      return 0;
    }

此代码逐个字符打印出 C 字符串，将任何空格字符替换为换行符。输出：

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;vertical-align:top;"> <pre style="margin-left:0;"><span style="color:#000000;"><span style="background-color:#ffffff;">Example
sentence
to
test
isspace
</span></span></pre> </td> 
  </tr> 
 </tbody> 
</table>

## isdigit<ctype.h> ##

//判断是不是十进制0——9的数

int isdigit ( int c );

#### Parameters ####

Character to be checked, casted to an int, or EOF.

要检查、转换为 int 或 EOF 的字符。

#### 返回值 ####

如果 *c* 确实是十进制数字，则与零（即 true）不同的值。否则为零（即假）。

#### 例 ####

/* isdigit example */
    #include <stdio.h>
    #include <stdlib.h>
    #include <ctype.h>
    int main ()
    {
      char str[]="1776ad";
      int year;
      if (isdigit(str[0]))
      {
        year = atoi (str);
        printf ("The year that followed %d was %d.\n",year,year+1);
      }
      return 0;
    }

输出

<table> 
 <tbody> 
  <tr> 
   <td style="background-color:#e7e7e7;border-color:#c0c0c0;vertical-align:top;"> <pre style="margin-left:0;"><span style="color:#000000;"><span style="background-color:#ffffff;">
The year that followed 1776 was 1777
</span></span></pre> </td> 
  </tr> 
 </tbody> 
</table>

## iscntrl<ctype.h> ##

//判断控制字符。如：“\\t”或“%d”这种

int iscntrl ( int c );

#### Parameters ####

Character to be checked, casted to an int, or EOF.

要检查、转换为 int 或 EOF 的字符。

#### 返回值 ####

如果 *c* 确实是控制字符，则与零（即 true）不同的值。否则为零（即假）。

####  ####

## isxdigit<ctype.h> ##

//判断是不是十六进制数字

int isxdigit ( int c );

#### Parameters ####

Character to be checked, casted to an int, or EOF.

要检查、转换为 int 或 EOF 的字符。

#### 返回值 ####

一个不同于零的值（即 true），如果 *c* 确实是十六进制数字。否则为零（即假）。

## salnum<ctype.h> ##

//判断是不是字母/数字

int isalnum ( int c );

#### Parameters ####

Character to be checked, casted as an int, or EOF.

要检查的字符，转换为 int 或 EOF。

#### 返回值 ####

一个不同于零的值（即 true），如果 *c* 确实是数字或字母。否则为零（即假）。

## ispunct<ctype.h> ##

//判断是不是标点字符(任何不属于字母/数字的图形字符)

int ispunct ( int c );

#### Parameters ####

Character to be checked, casted to an int, or EOF.

要检查、转换为 int 或 EOF 的字符。

#### 返回值 ####

如果 *c* 确实是标点符号，则与零（即 true）不同的值。否则为零（即假）。

## isgraph<ctype.h> ##

//判断是不是任何图形字符

int isgraph ( int c );

#### Parameters ####

Character to be checked, casted to an int, or EOF.

要检查、转换为 int 或 EOF 的字符。

#### 返回值 ####

一个不同于零的值（即 true），如果 *c* 确实具有图形表示为字符。否则为零（即假）。

## isprint <ctype.h> ##

//判断是不是任何可打印字符

int isprint ( int c );

#### Parameters ####

Character to be checked, casted to an int, or EOF.

要检查、转换为 int 或 EOF 的字符。

#### 返回值 ####

如果 *c* 确实是可打印字符，则与零（即 true）不同的值。否则为零（即假）。

## memcpy<string.h> ##

//内存拷贝（不能拷贝自己）

void * memcpy ( void * destination, const void * source, size_t num );

#### Parameters ####

destination

Pointer to the destination array where the content is to be copied, type-casted to a pointer of type void\*.

source

Pointer to the source of data to be copied, type-casted to a pointer of type const void\*.

num

Number of bytes to copy.  
[size\_t][size_t] is an unsigned integral type.

目的地

指向要在其中复制内容的目标数组的指针，类型转换为 void\* 类型的指针。

源

指向要复制的数据源的指针，类型转换为 const void\* 类型的指针。

数字

要复制的字节数。  
[size\_t][size_t] 是无符号整数类型。

#### 返回值 ####

返回*目标*。

## memmove<string.h> ##

//内存拷贝（可拷贝自己）

void * memmove ( void * destination, const void * source, size_t num );

#### Parameters ####

destination

Pointer to the destination array where the content is to be copied, type-casted to a pointer of type void\*.

source

Pointer to the source of data to be copied, type-casted to a pointer of type const void\*.

num

Number of bytes to copy.  
[size\_t][size_t] is an unsigned integral type.

目的地

指向要在其中复制内容的目标数组的指针，类型转换为 void\* 类型的指针。

源

指向要复制的数据源的指针，类型转换为 const void\* 类型的指针。

数字

要复制的字节数。  
[size\_t][size_t] 是无符号整数类型。

#### 返回值 ####

返回*目标*。

## memcmp<string.h> ##

//内存比较

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

#### Parameters ####

ptr1

Pointer to block of memory.

ptr2

Pointer to block of memory.

num

Number of bytes to compare.

PTR1

指向内存块的指针。

PTR2

指向内存块的指针。

数字

要比较的字节数。

#### 返回值 ####

返回一个整数值，该值指示内存块内容之间的关系：

<table> 
 <tbody> 
  <tr> 
   <th>返回值</th> 
   <th>表明</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>&lt;0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">两个内存块中不匹配的第一个字节在 PTR1 中的值低于&nbsp;<em>PTR2</em>&nbsp;中的值（如果评估为<em>无符号字符</em>值）</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">两个内存块的内容相等</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><code>&gt;0</code></td> 
   <td style="background-color:#ffffff;border-color:#000000;">两个内存块中不匹配的第一个字节在 PTR1 中的值大于在&nbsp;<em>PTR2</em>&nbsp;中的值（如果评估为<em>无符号字符</em>值）</td> 
  </tr> 
 </tbody> 
</table>

## offsetof<stddef.h> ##

//计算偏移量（结构体在内存）

offsetof (type,member)

#### Parameters ####

type

A type in which *member* is a valid member designator.

*  C++98

type shall be a structure or union type.

member

A member of *type*.

类型

成员为有效*成员*指示符的类型。

成员

*类型的*成员。

#### 返回值 ####

[类型为 size\_t][size_t 2] 的值，其偏移值为*类型*中*的成员*。

## malloc<stdlib.h> ##

//动态内存的开辟

void* malloc (size_t size);

#### Parameters ####

size

Size of the memory block, in bytes.  
[size\_t][size_t 1] is an unsigned integral type.

大小

内存块的大小（以字节为单位）。  
是无符号整型。[size\_t][size_t 1]

#### 返回值 ####

成功时，指向函数分配的内存块的指针。  
此指针的类型始终为 ，可以强制转换为所需类型的数据指针，以便可取消引用。  
如果函数无法分配请求的内存块，则返回*空指针*。`void*`

## calloc<stdlib.h> ##

//动态内存的开辟并初始化为0

void* calloc (size_t num, size_t size);

#### Parameters ####

num

Number of elements to allocate.

size

Size of each element.

数字

要分配的元素数。

大小

每个元素的大小。  
[size\_t][size_t 1]是无符号整型。

#### 返回值 ####

## realloc<stdlib.h> ##

//动态内存扩容

void* realloc (void* ptr, size_t size);

#### Parameters ####

ptr

Pointer to a memory block previously allocated with [malloc][], [calloc][] or [realloc][].  
Alternatively, this can be a *null pointer*, in which case a new block is allocated (as if [malloc][] was called).

size

New size for the memory block, in bytes.  
[size\_t][size_t 1] is an unsigned integral type.

PTR

指向先前分配有 、 或 的内存块的指针。  
或者，这可以是一个*空指针*，在这种情况下，将分配一个新块（就像被调用一样）。[malloc][][calloc][][realloc][][malloc][]

大小

内存块的新大小（以字节为单位）。  
是无符号整型。[size\_t][size_t 1]

#### 返回值 ####

指向重新分配的内存块的指针，该内存块可能与新位置相同，也可能是新位置。  
此指针的类型为 ，可以强制转换为所需类型的数据指针，以便可取消引用。ptr`void*`

## free<stdlib.h> ##

//释放动态开辟的内存

void free (void* ptr);

#### Parameters ####

ptr

Pointer to a memory block previously allocated with [malloc][], [calloc][] or [realloc][].

PTR

指向先前分配有 、 或 的内存块的指针。[malloc][][calloc][][realloc][]

#### 返回值 ####

没有

## fopen<stdio.h> ##

//打开文件

FILE * fopen ( const char * filename, const char * mode );

#### Parameters ####

filename

C string containing the name of the file to be opened.  
Its value shall follow the file name specifications of the running environment and can include a path (if supported by the system).

mode

C string containing a file access mode.

文件名

包含要打开的文件的名称的 C 字符串。  
其值应遵循运行环境的文件名规范，并且可以包含路径（如果系统支持）。

模式

包含文件访问模式的 C 字符串。

#### 返回值 ####

如果文件成功打开，该函数将返回指向 [FILE][] 对象的指针，该对象可用于在将来的操作中标识流。  
否则，将返回空指针。  
在大多数库实现中，[errno][] 变量在失败时也设置为特定于系统的错误代码。

## fclose<stdio.h> ##

//关闭文件

int fclose ( FILE * stream );

#### Parameters ####

stream

Pointer to a [FILE][] object that specifies the stream to be closed.

流

指向指定要关闭的流的 [FILE][] 对象的指针。

#### 返回值 ####

如果流成功关闭，则返回零值。  
失败时，将返回 [EOF][]。

## fgetc<stdio.h> ##

//字符输入

int fgetc ( FILE * stream );

#### Parameters ####

stream

Pointer to a [FILE][] object that identifies an input stream.

流

指向标识输入流的 [FILE][] 对象的指针。

#### 返回值 ####

成功后，将返回字符读取（提升为 int 值）。  
返回类型为 int 以适应特殊值 [EOF][]，该值表示失败：  
如果位置指示器位于*文件末尾*，则该函数返回 [EOF][] 并设置*流*的 *eof 指示器* （[feof][]）。  
如果发生其他读取错误，该函数还会返回 [EOF][]，但改为设置其*错误指示器* （[ferror][]）。

## fputc<stdio.h> ##

//字符输出

int fputc ( int character, FILE * stream );

#### Parameters ####

character

The int promotion of the character to be written.  
The value is internally converted to an unsigned char when written.

stream

Pointer to a [FILE][] object that identifies an output stream.

字符

要编写的字符的 int 提升。  
写入时，该值在内部转换为无符号字符。

流

指向标识输出流的 [FILE][] 对象的指针。

#### 返回值 ####

成功后，将返回所写*字符*。  
如果发生写入错误，则返回 [EOF][] 并设置*错误指示器*（[ferror][]）。

## fgets<stdio.h> ##

//字符按行输入

char * fgets ( char * str, int num, FILE * stream );

#### Parameters ####

str

Pointer to an array of chars where the string read is copied.

num

Maximum number of characters to be copied into *str* (including the terminating null-character).

stream

Pointer to a [FILE][] object that identifies an input stream.  
[stdin][] can be used as argument to read from the *standard input*.

str

指向在其中复制字符串读取的字符数组的指针。

数字

要复制到 *str* 的最大字符数（包括终止空字符）。

流

指向标识输入流的 [FILE][] 对象的指针。  
[stdin][] 可以用作从*标准输入*读取的参数。

#### 返回值 ####

成功后，函数返回 *str*。  
如果在尝试读取字符时遇到*文件末尾*，则设置 *eof 指示器* （[feof][]）。如果在读取任何字符之前发生这种情况，则返回的指针为空指针（*str 的内容保持不变*）。  
如果发生读取错误，则设置*错误指示器*（[ferror][]），并返回空指针（但*str*指向的内容可能已更改）。

## fputs<stdio.h> ##

//字符按行输出

int fputs ( const char * str, FILE * stream );

#### Parameters ####

str

*C string* with the content to be written to *stream*.

stream

Pointer to a [FILE][] object that identifies an output stream.

str

包含要写入*流*的内容的 *C 字符串*。

流

指向标识输出流的 [FILE][] 对象的指针。

#### 返回值 ####

成功时，将返回非负值。  
出错时，该函数返回 [EOF][] 并设置*错误指示器*（[ferror][]）。

## fscanf<stdio.h> ##

//格式化（scanf（这里面的就是格式化））输入

int fscanf ( FILE * stream, const char * format, ... );

#### Parameters ####

stream

Pointer to a [FILE][] object that identifies the input stream to read data from.

format

C string that contains a sequence of characters that control how characters extracted from the stream are treated:

流

指向标识要从中读取数据的输入流的 [FILE][] 对象的指针。

格式

C 字符串，包含一系列字符，这些字符控制如何处理从流中提取的字符：

*  空格字符：该函数将读取并忽略在下一个非空格字符之前遇到的任何空格字符（空格**字符**包括空格、换行符和制表符 - 请参阅 [isspace][]）。*格式*字符串中的单个空格验证从*流*中提取的任意数量的空格字符（包括无）。
 *  **非空格字符，格式说明符 （%） 除外：**任何不是空格字符（空白、换行符或制表符）或*格式说明符*的一部分（以 % 字符开头）的字符都会导致函数从流中读取下一个字符，将其与此非空格字符进行比较，如果匹配，则将其丢弃，函数继续使用*格式*的下一个字符。如果字符不匹配，函数将失败，返回流的后续字符并使其未读状态。
 *  **格式说明符：**由初始百分号 （%） 形成的序列表示格式说明符，用于指定要从*流*中检索并存储到附加参数所指向的位置的数据的类型和格式。

fscanf 的格式说明符遵循以下原型：  
  
%\[\*\]\[宽度\]\[长度\]说明符 其中末尾的说明*符*  
  
字符是最重要的组成部分，因为它定义了提取哪些字符、它们的解释及其相应参数的类型：

<table> 
 <tbody> 
  <tr> 
   <th><em>规范</em></th> 
   <th>描述</th> 
   <th>提取的字符</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">i，u</td> 
   <td style="background-color:#ffffff;border-color:#000000;">整数</td> 
   <td style="background-color:#ffffff;border-color:#000000;">任意数量的数字，可选在前面加上符号（+或-）。<br> 默认采用十进制数字 （0-9），但 0 前缀引入八进<a href="https://legacy.cplusplus.com/isdigit" title="制数字" rel="nofollow">制数字</a>&nbsp;（0-7）&nbsp;和&nbsp;0x&nbsp;<a href="https://legacy.cplusplus.com/isxdigit" title="十六进制数字" rel="nofollow">十六进制数字</a>&nbsp;（0-f）。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">d</td> 
   <td style="background-color:#ffffff;border-color:#000000;">十进制整数</td> 
   <td style="background-color:#ffffff;border-color:#000000;">任意数量的<a href="https://legacy.cplusplus.com/isdigit" title="十进制数字" rel="nofollow">十进制数字</a>&nbsp;（0-9），可选前面加一个符号（+或&nbsp;-）。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">o</td> 
   <td style="background-color:#ffffff;border-color:#000000;">八进制整数</td> 
   <td style="background-color:#ffffff;border-color:#000000;">任意数量的八进制数字 （0-7），可选地在前面加上符号 （+或&nbsp;-）。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">x</td> 
   <td style="background-color:#ffffff;border-color:#000000;">十六进制整数</td> 
   <td style="background-color:#ffffff;border-color:#000000;">任意数量的<a href="https://legacy.cplusplus.com/isxdigit" title="十六进制数字" rel="nofollow">十六进制数字</a>（0-9、a-f、A-F），可以选择在&nbsp;0x&nbsp;或&nbsp;0X&nbsp;前面加上，并且所有数字前面都可以选择带有符号（+或&nbsp;-）。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">f，&nbsp;e，&nbsp;g</td> 
   <td style="background-color:#ffffff;border-color:#000000;">浮点数</td> 
   <td style="background-color:#ffffff;border-color:#000000;">一系列十进制数字，可以选择包含小数点，可以选择在前面加上符号（+或-），可以选择后跟e或E字符以及<a href="https://legacy.cplusplus.com/isdigit" title="十进制" rel="nofollow">十进制</a>整数（或支持的其他一些序列）。<br> 符合 C99 的实现还支持前面带有 或 的十六进制浮点格式。<a href="https://legacy.cplusplus.com/strtod" title="strtod" rel="nofollow">strtod</a><code>0x</code><code>0X</code></td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">一个</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">c</td> 
   <td style="background-color:#ffffff;border-color:#000000;">字符</td> 
   <td style="background-color:#ffffff;border-color:#000000;">下一个字符。如果指定了&nbsp;1&nbsp;以外的宽度，则该函数将读取精确<em>宽度</em>字符，并将它们存储在作为参数传递的数组的连续位置。末尾不附加空字符。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">s</td> 
   <td style="background-color:#ffffff;border-color:#000000;">字符串</td> 
   <td style="background-color:#ffffff;border-color:#000000;">任意数量的非空格字符，在找到的第一个<a href="https://legacy.cplusplus.com/isspace" title="空格" rel="nofollow">空格</a>字符处停止。终止空字符会自动添加到存储序列的末尾。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">p</td> 
   <td style="background-color:#ffffff;border-color:#000000;">指针地址</td> 
   <td style="background-color:#ffffff;border-color:#000000;">表示指针的字符序列。使用的特定格式取决于系统和库实现，但它与<a href="https://legacy.cplusplus.com/fprintf" title="用于在 fprintf" rel="nofollow">用于在 fprintf</a>&nbsp;中格式化&nbsp;%p&nbsp;的格式相同。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">[<em>字符</em>]</td> 
   <td style="background-color:#ffffff;border-color:#000000;">扫描集</td> 
   <td style="background-color:#ffffff;border-color:#000000;">方括号之间指定的任意数量的字符。<br> 不是第一个字符的短划线 （-） 可能会在某些库实现中产生不可移植的行为。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">[^<em>字符</em>]</td> 
   <td style="background-color:#ffffff;border-color:#000000;">否定扫描集</td> 
   <td style="background-color:#ffffff;border-color:#000000;">任意数量的字符，其中没有一个指定为括号之间的<em>字符</em>。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">n</td> 
   <td style="background-color:#ffffff;border-color:#000000;">计数</td> 
   <td style="background-color:#ffffff;border-color:#000000;">不消耗任何输入。<br> 到目前为止读取的字符数存储在指向的位置。stream</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">%</td> 
   <td style="background-color:#ffffff;border-color:#000000;">%</td> 
   <td style="background-color:#ffffff;border-color:#000000;">一个&nbsp;% 后跟另一个 % 与单个&nbsp;%&nbsp;匹配。</td> 
  </tr> 
 </tbody> 
</table>

除 n 外，任何说明符至少应使用一个字符。否则，匹配将失败，扫描到此结束。  
  
格式说明符还可以包含子*说明符*：*星号* （\*）、*宽度*和*长度*（按此顺序），它们是可选的，遵循以下规范：

<table> 
 <tbody> 
  <tr> 
   <th><em>子说明符</em></th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">*</td> 
   <td style="background-color:#ffffff;border-color:#000000;">可选的起始星号表示数据将从流中读取但被忽略（即它不存储在参数指向的位置）。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><em>width</em></td> 
   <td style="background-color:#ffffff;border-color:#000000;">指定当前读取操作中要读取的最大字符数（可选）。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><em>length</em></td> 
   <td style="background-color:#ffffff;border-color:#000000;">hh，&nbsp;h，&nbsp;l，&nbsp;ll，&nbsp;j，&nbsp;z，&nbsp;t，&nbsp;L（可选）之一。<br> 这会更改相应参数所指向的预期存储类型（见下文）。</td> 
  </tr> 
 </tbody> 
</table>

这是一个图表，显示了存储输入的相应参数的预期类型（带和不带*长度*子说明符）：

<table> 
 <tbody> 
  <tr> 
   <th></th> 
   <th colspan="7">说明符</th> 
  </tr> 
  <tr> 
   <th><em>长度</em></th> 
   <th>D i</th> 
   <th>U o x</th> 
   <th>F e g a</th> 
   <th>c s [] [^]</th> 
   <th>p</th> 
   <th>n</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><em>（none）</em></td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">国际*</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">无符号 int*</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">浮*</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">煳*</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">无效**</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">国际*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">呵呵</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">签名字符*</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">无符号字符*</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;">签名字符*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">h</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">短内线*</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">无符号短整型*</td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">短内线*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">l</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">多头整型*</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">无符号长整型*</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">双*</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">wchar_t*</td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">多头整型*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">ll</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">长 长 长 内特*</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">无符号长长 int*</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;">长 长 长 内特*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">j</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/intmax_t" title="intmax_t" rel="nofollow">intmax_t</a>*</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/uintmax_t" title="uintmax_t" rel="nofollow">uintmax_t</a>*</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/intmax_t" title="intmax_t" rel="nofollow">intmax_t</a>*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">z</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/size_t" title="size_t" rel="nofollow">size_t</a>*</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/size_t" title="size_t" rel="nofollow">size_t</a>*</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/size_t" title="size_t" rel="nofollow">size_t</a>*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">t</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/ptrdiff_t" title="ptrdiff_t" rel="nofollow">ptrdiff_t</a>*</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/ptrdiff_t" title="ptrdiff_t" rel="nofollow">ptrdiff_t</a>*</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/ptrdiff_t" title="ptrdiff_t" rel="nofollow">ptrdiff_t</a>*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">L</td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">长双*</td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
  </tr> 
 </tbody> 
</table>

**注意：**黄色行表示 C99 引入的说明符和子说明符。

#### 返回值 ####

成功后，该函数返回成功填充的参数列表的项数。此计数可以与预期的项目数匹配，也可以由于匹配失败、读取错误或*文件末尾*的到达而减少（甚至为零）。  
  
如果发生读取错误或在读取时到达*文件末尾*，则会设置正确的指示器（[feof][] 或 [ferror][]）。并且，如果在成功读取任何数据之前发生任一情况，则返回 [EOF][]。  
  
如果在解释宽字符时发生编码错误，该函数会将 [errno][] 设置为 EILSEQ。

## fprintf<stdio.h> ##

//格式化（scanf（这里面的就是格式化））输出

int fprintf ( FILE * stream, const char * format, ... );

#### Parameters ####

stream

Pointer to a [FILE][] object that identifies an output stream.

format

C string that contains the text to be written to the stream.

流

指向标识输出流的 [FILE][] 对象的指针。

格式

包含要写入流的文本的 C 字符串。  
它可以选择性地包含嵌入的格式说明符，这些*说明符*由后续附加参数中指定的值替换，并根据请求设置格式。  
  
*格式说明符*遵循此原型： %\[flags\]\[width\]\[.precision\]\[length\]说明符 其中末尾的说明*符*  
  
字符是最重要的组成部分，因为它定义了其相应参数的类型和解释：

<table> 
 <tbody> 
  <tr> 
   <th><em>规范</em></th> 
   <th>输出</th> 
   <th>例</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">d&nbsp;<em>或</em>&nbsp;i</td> 
   <td style="background-color:#ffffff;border-color:#000000;">有符号十进制整数</td> 
   <td style="background-color:#ffffff;border-color:#000000;">392</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">u</td> 
   <td style="background-color:#ffffff;border-color:#000000;">无符号十进制整数</td> 
   <td style="background-color:#ffffff;border-color:#000000;">7235</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">o</td> 
   <td style="background-color:#ffffff;border-color:#000000;">无符号八进制</td> 
   <td style="background-color:#ffffff;border-color:#000000;">610</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">x</td> 
   <td style="background-color:#ffffff;border-color:#000000;">无符号十六进制整数</td> 
   <td style="background-color:#ffffff;border-color:#000000;">7FA</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">X</td> 
   <td style="background-color:#ffffff;border-color:#000000;">无符号十六进制整数（大写）</td> 
   <td style="background-color:#ffffff;border-color:#000000;">7FA</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">f</td> 
   <td style="background-color:#ffffff;border-color:#000000;">十进制浮点数，小写</td> 
   <td style="background-color:#ffffff;border-color:#000000;">392.65</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">F</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">十进制浮点数，大写</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">392.65</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">e</td> 
   <td style="background-color:#ffffff;border-color:#000000;">科学记数法（尾数/指数），小写</td> 
   <td style="background-color:#ffffff;border-color:#000000;">3.9265e+2</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">E</td> 
   <td style="background-color:#ffffff;border-color:#000000;">科学记数法（尾数/指数），大写</td> 
   <td style="background-color:#ffffff;border-color:#000000;">3.9265E+2</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">g</td> 
   <td style="background-color:#ffffff;border-color:#000000;">使用最短表示形式：%e&nbsp;或&nbsp;%f</td> 
   <td style="background-color:#ffffff;border-color:#000000;">392.65</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">G</td> 
   <td style="background-color:#ffffff;border-color:#000000;">使用最短表示形式：%E&nbsp;或&nbsp;%F</td> 
   <td style="background-color:#ffffff;border-color:#000000;">392.65</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">一个</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">十六进制浮点数，小写</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">-0xc.90FEP-2</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">一个</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">十六进制浮点数，大写</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">-0XC.90FEP-2</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">c</td> 
   <td style="background-color:#ffffff;border-color:#000000;">字符</td> 
   <td style="background-color:#ffffff;border-color:#000000;">一个</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">s</td> 
   <td style="background-color:#ffffff;border-color:#000000;">字符串</td> 
   <td style="background-color:#ffffff;border-color:#000000;">样本</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">p</td> 
   <td style="background-color:#ffffff;border-color:#000000;">指针地址</td> 
   <td style="background-color:#ffffff;border-color:#000000;">b8000000</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">n</td> 
   <td style="background-color:#ffffff;border-color:#000000;">没有打印任何内容。<br> 相应的参数必须是指向有符号 int&nbsp;的指针。<br> 到目前为止写入的字符数存储在指向的位置。</td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">%</td> 
   <td style="background-color:#ffffff;border-color:#000000;">一个&nbsp;% 后跟另一个 % 字符会将单个&nbsp;%&nbsp;写入流。</td> 
   <td style="background-color:#ffffff;border-color:#000000;">%</td> 
  </tr> 
 </tbody> 
</table>

格式说明符还可以包含子*说明符*：*标志*、*宽度*、*.precision* 和*修饰符*（按此顺序），它们是可选的，并遵循以下规范：

<table> 
 <tbody> 
  <tr> 
   <th><em>标志</em></th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">-</td> 
   <td style="background-color:#ffffff;border-color:#000000;">在给定字段宽度内左对齐;右对齐是默认值（请参阅<em>宽度</em>子说明符）。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">+</td> 
   <td style="background-color:#ffffff;border-color:#000000;">即使在正数中，也会在结果前面加上加号或减号（+或-）。默认情况下，只有负数前面带有&nbsp;-&nbsp;符号。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><em>（空格）</em></td> 
   <td style="background-color:#ffffff;border-color:#000000;">如果不打算写入任何符号，则会在值之前插入一个空格。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">#</td> 
   <td style="background-color:#ffffff;border-color:#000000;">与&nbsp;o、x&nbsp;或&nbsp;X&nbsp;说明符一起使用时，对于小于零的值，值前面分别带有&nbsp;0、0x&nbsp;或&nbsp;0X。<br> 与&nbsp;a、A、e、E、f、F、g&nbsp;或&nbsp;G&nbsp;一起使用时，它强制写入输出包含小数点，即使后面没有更多的数字。&nbsp;默认情况下，如果没有数字后跟，则不写入小数点。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">0</td> 
   <td style="background-color:#ffffff;border-color:#000000;">指定填充时，用零 （0） 而不是空格左填充数字（请参阅<em>宽度</em>子说明符）。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <th><em>宽度</em></th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><em>（数字）</em></td> 
   <td style="background-color:#ffffff;border-color:#000000;">要打印的最小字符数。如果要打印的值小于此数字，则用空格填充结果。即使结果更大，也不会截断该值。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">*</td> 
   <td style="background-color:#ffffff;border-color:#000000;"><em>宽度</em>不是在<em>格式</em>字符串中指定的，而是作为必须格式化的参数之前的附加整数值参数指定的。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <th><em>。精度</em></th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">.<em>数</em></td> 
   <td style="background-color:#ffffff;border-color:#000000;">对于整数说明符 （d，&nbsp;i，&nbsp;o，&nbsp;u，&nbsp;x，&nbsp;X）：<em>精度</em>指定要写入的最小位数。如果要写入的值短于此数字，则结果将用前导零填充。即使结果较长，也不会截断该值。<em>精度</em>为 0 表示不为值&nbsp;0&nbsp;写入任何字符。<br> 对于&nbsp;a、a、e、e、f&nbsp;和&nbsp;F&nbsp;说明符：这是小数点<strong>后</strong>要打印的位数（默认情况下为 6）。<br> 对于&nbsp;g&nbsp;和&nbsp;G&nbsp;说明符：这是要打印的最大有效位数。<br> 对于&nbsp;s：这是要打印的最大字符数。默认情况下，将打印所有字符，直到遇到结尾空字符。<br> 如果在指定期间时没有显式<em>精度</em>值，则假定为&nbsp;0。</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">.*</td> 
   <td style="background-color:#ffffff;border-color:#000000;"><em>精度</em>不是在<em>格式</em>字符串中指定的，而是作为必须格式化的参数之前的附加整数值参数指定的。</td> 
  </tr> 
 </tbody> 
</table>

长度子说明符修改数据类型的*长度*。这是一个图表，显示用于解释带有和不带有*长度*说明符的相应参数的类型（如果使用不同的类型，则执行正确的类型提升或转换（如果允许）：

<table> 
 <tbody> 
  <tr> 
   <th></th> 
   <th colspan="7">说明符</th> 
  </tr> 
  <tr> 
   <th><em>长度</em></th> 
   <th>D i</th> 
   <th>u o x X</th> 
   <th>f F e E g G a A</th> 
   <th>c</th> 
   <th>s</th> 
   <th>p</th> 
   <th>n</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;"><em>（无）</em></td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">国际</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">无符号整数</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">双</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">国际</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">煳*</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">无效*</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">国际*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">呵呵</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">签名字符</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">无符号字符</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;">签名字符*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">h</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">短内</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">无符号短整型</td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">短内线*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">l</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">长整</td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">无符号长整型</td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#d0e0d0;border-color:#000000;"><a href="https://legacy.cplusplus.com/wint_t" title="wint_t" rel="nofollow">wint_t</a></td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">wchar_t*</td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">多头整型*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">将</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">长 长</td> 
   <td style="background-color:#ffffe0;border-color:#000000;">无符号长长</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;">长 长 长 内特*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">j</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/intmax_t" title="intmax_t" rel="nofollow">intmax_t</a></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/uintmax_t" title="uintmax_t" rel="nofollow">uintmax_t</a></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/intmax_t" title="intmax_t" rel="nofollow">intmax_t</a>*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">z</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/size_t" title="size_t" rel="nofollow">size_t</a></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/size_t" title="size_t" rel="nofollow">size_t</a></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/size_t" title="size_t" rel="nofollow">size_t</a>*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffe0;border-color:#000000;">t</td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/ptrdiff_t" title="ptrdiff_t" rel="nofollow">ptrdiff_t</a></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/ptrdiff_t" title="ptrdiff_t" rel="nofollow">ptrdiff_t</a></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"></td> 
   <td style="background-color:#ffffe0;border-color:#000000;"><a href="https://legacy.cplusplus.com/ptrdiff_t" title="ptrdiff_t" rel="nofollow">ptrdiff_t</a>*</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">L</td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#d0e0d0;border-color:#000000;">长双</td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
   <td style="background-color:#ffffff;border-color:#000000;"></td> 
  </tr> 
 </tbody> 
</table>

请注意，c 说明符将 int（或 [wint\_t][wint_t]）作为参数，但在格式化 char 值（或 wchar\_t）以进行输出之前执行正确的转换。  
  
**注意：**黄色行表示 C99 引入的说明符和子说明符。有关扩展类型的说明符，请参阅。[<cinttypes>][cinttypes]

#### 返回值 ####

成功后，将返回写入的字符总数。  
  
如果发生写入错误，则设置*错误指示器*（[ferror][]）并返回负数。  
  
如果在写入宽字符时发生多字节字符编码错误，[errno][] 将设置为 EILSEQ 并返回负数。

## fread<stdio.h> ##

//二进制方式读取

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );

#### Parameters ####

ptr

Pointer to a block of memory with a size of at least (size\*count) bytes, converted to a void\*.

size

Size, in bytes, of each element to be read.  
[size\_t][size_t 2] is an unsigned integral type.

count

Number of elements, each one with a size of *size* bytes.  
[size\_t][size_t 2] is an unsigned integral type.

stream

Pointer to a [FILE][] object that specifies an input stream.

PTR

指向大小至少为 （size\*count） 字节的内存块的指针，转换为 void\*。

大小

要读取的每个元素的大小（以字节为单位）。  
[size\_t][size_t 2]是无符号整数类型。

计数

元素数，每个元素的大小为字节*大小*。  
[size\_t][size_t 2] 是无符号整数类型。

流

指向指定输入流的 [FILE][] 对象的指针。

#### 返回值 ####

返回成功读取的元素总数。  
如果此数字与 *count* 参数不同，则表示读取时发生读取错误或到达*文件末尾*。在这两种情况下，都会设置正确的指标，可以分别用 [ferror][] 和 [feof][] 进行检查。  
如果*大小*或*计数*为零，则该函数返回零，并且流状态和 *ptr* 指向的内容保持不变。  
[size\_t][size_t 2] 是无符号整数类型。

## fwrite<stdio.h> ##

//二进制方式写到文件

size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );

#### Parameters ####

ptr

Pointer to the array of elements to be written, converted to a const void\*.

size

Size in bytes of each element to be written.  
[size\_t][size_t 2] is an unsigned integral type.

count

Number of elements, each one with a size of *size* bytes.  
[size\_t][size_t 2] is an unsigned integral type.

stream

Pointer to a [FILE][] object that specifies an output stream.

PTR

指向要写入的元素数组的指针，转换为 const void\*。

大小

要写入的每个元素的大小（以字节为单位）。  
[size\_t][size_t 2]是无符号整数类型。

计数

元素数，每个元素的大小为字节*大小*。  
[size\_t][size_t 2] 是无符号整数类型。

流

指向指定输出流的 [FILE][] 对象的指针。

#### 返回值 ####

返回成功写入的元素总数。  
如果此数字与 *count* 参数不同，则写入错误阻止函数完成。在这种情况下，将为*流*设置*错误指示器*（[ferror][]）。  
如果*大小*或*计数*为零，则该函数返回零，*错误指示器*保持不变。  
[size\_t][size_t 2] 是无符号整数类型。

## sprintf<stdio.h> ##

//把格式化的数据写到字符串中

int sprintf ( char * str, const char * format, ... );

#### Parameters ####

str

Pointer to a buffer where the resulting C-string is stored.  
The buffer should be large enough to contain the resulting string.

format

C string that contains a format string that follows the same specifications as *format* in [printf][] (see [printf][] for details).

str

指向存储生成的 C 字符串的缓冲区的指针。  
缓冲区应足够大以包含生成的字符串。

格式

C 字符串，其中包含一个格式字符串，该字符串遵循与 printf 中的*格式*相同的规范（有关详细信息，请参阅 [printf][]）。

#### 返回值 ####

成功后，将返回写入的字符总数。此计数不包括自动追加在字符串末尾的其他 null 字符。  
失败时，返回负数。

## sscanf<stdio.h> ##

//从字符串转化出格式化数据

int sscanf ( const char * s, const char * format, ...);

#### Parameters ####

C string that the function processes as its source to retrieve the data.

format

C string that contains a format string that follows the same specifications as *format* in [scanf][] (see [scanf][] for details).

函数处理作为其源以检索数据的 C 字符串。

格式

C 字符串，其中包含一个格式字符串，该字符串遵循与 scanf 中的*格式*相同的规范（有关详细信息，请参阅 [scanf][]）

#### 返回值 ####

成功后，该函数返回参数列表中成功填充的项数。此计数可以与预期的项目数匹配，或者在匹配失败的情况下更少（甚至为零）。  
如果在成功解释任何数据之前输入失败，则返回 [EOF][]。

## fseek<stdio.h> ##

//定位文件指针位置

int fseek ( FILE * stream, long int offset, int origin );

stream

Pointer to a [FILE][] object that identifies the stream.

offset

Binary files: Number of bytes to offset from *origin*.  
Text files: Either zero, or a value returned by [ftell][].

origin

Position used as reference for the *offset*. It is specified by one of the following constants defined in [<cstdio>][cstdio] exclusively to be used as arguments for this function:

流

指向标识流的 [FILE][] 对象的指针。

抵消

二进制文件：要从*源*偏移的字节数。  
文本文件：零或 [ftell][] 返回的值。

起源

用作*偏移*参考的位置。它由 [<cstdio>][cstdio] 中定义的以下常量之一指定，专门用作此函数的参数：

<table> 
 <tbody> 
  <tr> 
   <th>不断</th> 
   <th>参考位置</th> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SEEK_SET</td> 
   <td style="background-color:#ffffff;border-color:#000000;">文件开头</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SEEK_CUR</td> 
   <td style="background-color:#ffffff;border-color:#000000;">文件指针的当前位置</td> 
  </tr> 
  <tr> 
   <td style="background-color:#ffffff;border-color:#000000;">SEEK_END</td> 
   <td style="background-color:#ffffff;border-color:#000000;">文件结尾 *</td> 
  </tr> 
 </tbody> 
</table>

#### 返回值 ####

如果成功，该函数将返回零。  
否则，它将返回非零值。  
如果发生读取或写入错误，则设置*错误指示器*（[ferror][]）。

## ftell<stdio.h> ##

//返回文件指针相对于起始位置的偏移量

long int ftell ( FILE * stream );

#### Parameters ####

stream

Pointer to a [FILE][] object that identifies the stream.

流

指向标识流的 [FILE][] 对象的指针。

#### 返回值 ####

成功后，返回仓位指标的当前值。  
失败时，返回 -1L，并将 [errno][] 设置为特定于系统的正值。

## rewind<stdio.h> ##

//让文件指针位置回到起始位置

void rewind ( FILE * stream );

#### Parameters ####

stream

Pointer to a [FILE][] object that identifies the stream.

流

指向标识流的 [FILE][] 对象的指针。

#### 返回值 ####

没有

## feof<stdio.h> ##

//当文件读取结束时，判断结束原因是不是：遇到文件结束

int feof ( FILE * stream );

#### Parameters ####

stream

Pointer to a [FILE][] object that identifies the stream.

流

指向标识流的 [FILE][] 对象的指针。

#### 返回值 ####

如果设置了与流关联的*文件结束指示符*，则返回非零值。  
否则，返回零。

[9bf5fbdfb9d14fb4a4367bc72a40f609.png]: https://img-blog.csdnimg.cn/9bf5fbdfb9d14fb4a4367bc72a40f609.png
[size_t]: https://legacy.cplusplus.com/cstring:size_t
[EOF]: https://legacy.cplusplus.com/EOF
[stdin]: https://legacy.cplusplus.com/stdin
[feof]: https://legacy.cplusplus.com/feof
[ferror]: https://legacy.cplusplus.com/ferror
[Link 1]: https://legacy.cplusplus.com/isfinite
[raise]: https://legacy.cplusplus.com/raise
[size_t 1]: https://legacy.cplusplus.com/cstdlib:size_t
[size_t 2]: https://legacy.cplusplus.com/size_t
[malloc]: https://legacy.cplusplus.com/malloc
[calloc]: https://legacy.cplusplus.com/calloc
[realloc]: https://legacy.cplusplus.com/realloc
[FILE]: https://legacy.cplusplus.com/FILE
[errno]: https://legacy.cplusplus.com/errno
[isspace]: https://legacy.cplusplus.com/isspace
[wint_t]: https://legacy.cplusplus.com/wint_t
[cinttypes]: https://legacy.cplusplus.com/%3Ccinttypes%3E
[printf]: https://legacy.cplusplus.com/printf
[scanf]: https://legacy.cplusplus.com/scanf
[ftell]: https://legacy.cplusplus.com/ftell
[cstdio]: https://legacy.cplusplus.com/cstdio