常用函数整理（基础篇）

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;
}

输出：

str1: Sample string
str2: Sample string
str3: copy successful

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;
}

输出：

these strings are concatenated. 

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 is an unsigned integral type.

数字

要从源复制的最大字符数。

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;
}

输出：

To be or not to be
To be or not to be
To be 

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 is an unsigned integral type.

目的地

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

源

要追加的 C 字符串。

数字

要追加的最大字符数。

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;
}

输出：

To be or not

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 is an unsigned integral type.

str1

要比较的 C 字符串。

str2

要比较的 C 字符串。

数字

要比较的最大字符数。

size_t是无符号整数类型。

返回值

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

例

/* 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;
}

输出：

Looking for R2 astromech droids...
found R2D2
found R2A6

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;
}

输出：

This is a sample string

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;
}

输出：

Splitting string "- This, a sample string." into tokens:
This
a
sample
string

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 字符串。

返回值

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

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 is an unsigned integral type.

PTR

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

价值

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

数字

要设置为该值的字节数。

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;
}

输出：

------ every programmer should know memset!

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.

基础

基值。

指数

指数值。

返回值

提高权力的结果.

如果 是有限负数，而 是有限的但不是整数值，则会导致域错误。

如果两者均为零，则还可能导致某些实现出现域错误。

如果为零且为负数，则可能会导致域错误或极点错误（或无，具体取决于库实现）。

如果结果太大或太小而无法用返回类型的值表示，则该函数也可能导致范围错误。

sqrt<math.h>

//开平方

• C99

    double sqrt  (double x);

     float sqrtf (float x);

long double sqrtl (long double x);

Parameters

x

Value whose square root is computed.

If the argument is negative, a domain error occurs.

x

计算平方根的值。

如果参数为负数，则会发生域错误。

返回值

的平方根。

如果为负数，则发生域错误：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;
}

输出：

sqrt(1024.000000) = 32.000000

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;
}

输出：

Enter sentence: just testing
The sentence entered is 12 characters long.

islower<ctype.h>

//判断小写字母

int islower ( int c );

Parameters

c

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

c

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

返回值

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

isupper<ctype.h>

//判断大写字母

int isupper ( int c );

Parameters

c

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

c

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

返回值

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

toupper<ctype.h>

//小写——>大写

int toupper ( int c );

Parameters

c

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

c

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

返回值

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

tolower<ctype.h>

//大写——>小写

int tolower ( int c );

Parameters

c

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

c

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

返回值

小写等效于 c（如果存在此类值），否则为 c（未更改）。

该值作为 int 值返回，该值可以隐式转换为 char。

isalpha<ctype.h>

//判断是不是字母

int isalpha ( int c );

Parameters

c

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

c

要检查、转换为 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

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

每个库实现都可以提供可与此函数一起使用的其他信号值宏常量。

请注意，并非所有运行环境都需要生成自动信号，即使在上述特定情况下也是如此，尽管所有运行环境都必须传递通过显式调用函数生成的信号。raise

函数

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

返回值

返回类型与参数的类型相同。

如果请求成功，该函数将返回指向特定处理程序函数的指针，该处理程序函数负责在调用之前处理此信号（如果有）。或者，或者在调用之前，信号由默认处理程序处理或被忽略。

如果函数未成功注册新的信号处理程序，它将返回并可能设置为正值。

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 is an unsigned integral type.

size

Size in bytes of each element in the array.

size_t 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*

数字

数组中由 指向的元素数。

是无符号整型。basesize_t

大小

数组中每个元素的大小（以字节为单位）。

是无符号整型。size_t

比较

指向比较两个元素的函数的指针。

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

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

返回值

没有

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;
}

可能的输出：

Error opening file unexist.ent: No such file or directory

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 不存在，则程序输出可能需要与此类似的内容：

The following error occurred: No such file or directory

isspace<ctype.h>

//判断是不是空白字符

int isspace ( int c );

Parameters

c

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

c

要检查、转换为 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 字符串，将任何空格字符替换为换行符。输出：

Example
sentence
to
test
isspace

isdigit<ctype.h>

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

int isdigit ( int c );

Parameters

c

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

c

要检查、转换为 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;
}

输出

The year that followed 1776 was 1777

iscntrl<ctype.h>

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

int iscntrl ( int c );

Parameters

c

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

c

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

返回值

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

isxdigit<ctype.h>

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

int isxdigit ( int c );

Parameters

c

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

c

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

返回值

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

salnum<ctype.h>

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

int isalnum ( int c );

Parameters

c

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

c

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

返回值

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

ispunct<ctype.h>

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

int ispunct ( int c );

Parameters

c

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

c

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

返回值

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

isgraph<ctype.h>

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

int isgraph ( int c );

Parameters

c

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

c

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

返回值

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

isprint <ctype.h>

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

int isprint ( int c );

Parameters

c

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

c

要检查、转换为 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 is an unsigned integral type.

目的地

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

源

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

数字

要复制的字节数。

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 is an unsigned integral type.

目的地

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

源

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

数字

要复制的字节数。

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

指向内存块的指针。

数字

要比较的字节数。

返回值

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

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 的值，其偏移值为类型中的成员。

malloc<stdlib.h>

//动态内存的开辟

void* malloc (size_t size);

Parameters

size

Size of the memory block, in bytes.

size_t is an unsigned integral type.

大小

内存块的大小（以字节为单位）。

是无符号整型。size_t

返回值

成功时，指向函数分配的内存块的指针。

此指针的类型始终为 ，可以强制转换为所需类型的数据指针，以便可取消引用。

如果函数无法分配请求的内存块，则返回空指针。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是无符号整型。

返回值

成功时，指向函数分配的内存块的指针。

此指针的类型始终为 ，可以强制转换为所需类型的数据指针，以便可取消引用。

如果函数无法分配请求的内存块，则返回空指针。void*

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 is an unsigned integral type.

PTR

指向先前分配有 、 或 的内存块的指针。

或者，这可以是一个空指针，在这种情况下，将分配一个新块（就像被调用一样）。malloccallocreallocmalloc

大小

内存块的新大小（以字节为单位）。

是无符号整型。size_t

返回值

指向重新分配的内存块的指针，该内存块可能与新位置相同，也可能是新位置。

此指针的类型为 ，可以强制转换为所需类型的数据指针，以便可取消引用。ptrvoid*

free<stdlib.h>

//释放动态开辟的内存

void free (void* ptr);

Parameters

ptr

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

PTR

指向先前分配有 、 或 的内存块的指针。malloccallocrealloc

返回值

没有

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 的格式说明符遵循以下原型：

%[*][宽度][长度]说明符 其中末尾的说明符

字符是最重要的组成部分，因为它定义了提取哪些字符、它们的解释及其相应参数的类型：

除 n 外，任何说明符至少应使用一个字符。否则，匹配将失败，扫描到此结束。

格式说明符还可以包含子说明符：星号 （*）、宽度和长度（按此顺序），它们是可选的，遵循以下规范：

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

注意：黄色行表示 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]说明符 其中末尾的说明符

字符是最重要的组成部分，因为它定义了其相应参数的类型和解释：

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

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

请注意，c 说明符将 int（或 wint_t）作为参数，但在格式化 char 值（或 wchar_t）以进行输出之前执行正确的转换。

注意：黄色行表示 C99 引入的说明符和子说明符。有关扩展类型的说明符，请参阅。<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 is an unsigned integral type.

count

Number of elements, each one with a size of size bytes.

size_t is an unsigned integral type.

stream

Pointer to a FILE object that specifies an input stream.

PTR

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

大小

要读取的每个元素的大小（以字节为单位）。

size_t是无符号整数类型。

计数

元素数，每个元素的大小为字节大小。

size_t 是无符号整数类型。

流

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

返回值

返回成功读取的元素总数。

如果此数字与 count 参数不同，则表示读取时发生读取错误或到达文件末尾。在这两种情况下，都会设置正确的指标，可以分别用 ferror 和 feof 进行检查。

如果大小或计数为零，则该函数返回零，并且流状态和 ptr 指向的内容保持不变。

size_t 是无符号整数类型。

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 is an unsigned integral type.

count

Number of elements, each one with a size of size bytes.

size_t is an unsigned integral type.

stream

Pointer to a FILE object that specifies an output stream.

PTR

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

大小

要写入的每个元素的大小（以字节为单位）。

size_t是无符号整数类型。

计数

元素数，每个元素的大小为字节大小。

size_t 是无符号整数类型。

流

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

返回值

返回成功写入的元素总数。

如果此数字与 count 参数不同，则写入错误阻止函数完成。在这种情况下，将为流设置错误指示器（ferror）。

如果大小或计数为零，则该函数返回零，错误指示器保持不变。

size_t 是无符号整数类型。

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

s

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).

s

函数处理作为其源以检索数据的 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> exclusively to be used as arguments for this function:

流

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

抵消

二进制文件：要从源偏移的字节数。

文本文件：零或 ftell 返回的值。

起源

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

返回值

如果成功，该函数将返回零。

否则，它将返回非零值。

如果发生读取或写入错误，则设置错误指示器（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 对象的指针。

返回值

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

否则，返回零。