函数进阶

最新推荐文章于 2021-11-27 00:30:41 发布
原创 最新推荐文章于 2021-11-27 00:30:41 发布 · 288 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨函数调用机制，包括栈帧、递归及其优化策略，详解字符串处理函数，如长度计算、拷贝、连接、比较及查找，同时覆盖输入输出函数，如错误报告、流操作和格式化I/O。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一. 函数的调用过程

函数的调用过程要为函数开辟栈空间，用于本次函数的调用中临时变量的保存、现场保护。这块栈空间称之为函数栈帧。

在函数调用的过程中ebp和esp这两个寄存器存放了维护这个栈的栈底和栈顶指针。ebp存放指向函数栈帧栈底的地址。 esp存放指向函数栈帧栈顶的地址。

eg：

#include <stdio.h>
int Add(int x, int y)
{   
       int z = 0;  
       z = x + y;  
       return z;
}
int main()
{  
       int a = 10;  
       int b = 20;   
       int ret = Add(a, b);  
       printf("ret = %d\n", ret);
       return 0;
}

二. 函数递归

函数调用自身称为递归。（大事化小）

使用递归的条件：

1.存在限制条件，当满足这个限制条件时，停止递归；

2.每次递归调用后越来越接近这个限制条件。

eg1：接受一个整型值，把它转换为字符并且打印。如输入1234，输出1 2 3 4

#include<stdio.h>
void Print(int n)
{
       if (n > 9)
       {
              Print(n/10);
       }
       printf("%d ",n%10);
}
int main()
{
       int num = 1234;
       Print(num);
       return 0;
}

eg2：编写函数不允许创建临时变量，求字符串长度

#include <stdio.h>
int Strlen(const char*str)
{
       if (*str == '\0')   
              return 0;
       else return 1 + Strlen(str + 1);
}
int main()
{
       char *p = "abcdef";
       int len = Strlen(p);
       printf("%d\n", len);   
       return 0;
}

eg3：求n的阶乘

#include <stdio.h>
int factorial(int n)
{
       if (n <= 1)    
              return 1;  
       else      
              return n * factorial(n - 1);
}
int main()
{
       int n = 10;
       printf("%d\n",factorial(n));
}

eg4：求第n个斐波那契数列

#include <stdio.h>
int fib(int n)
{
       if (n <= 2)      
              return 1;
       else     
              return fib(n - 1) + fib(n - 2);
}
int main()
{
       int n = 20;
       printf("%d\n", fib(20));
       return 0;
}

以上例子，当参数特别大时会报错：栈溢出。

系统分配给程序的栈空间是有限的，但是如果出现了死循环或者死递归，可能导致一直开辟栈空间，最终将栈空间耗尽，这样的现象称为栈溢出。

为了解决栈溢出，可以将递归写成非递归。或者使用static对象替代nonstatic局部对象（栈对象），不仅可以减少每次递归调用和返回产生和释放nonstatic对象的开销，而且static对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。

例如求n个斐波那契数列:

#include <stdio.h>
int fib(int n)
{
       int result;  
       int pre_result;  
       int next_older_result;   
       result = pre_result = 1;    
       while (n > 2)
       {
              n -= 1;     
              next_older_result = pre_result;   
              pre_result = result;    
              result = pre_result + next_older_result;
       }    
       return result;
}
int main()
{
       int n = 500;
       printf("%d\n", fib(n));//315178285
       return 0;
}

三. main函数的参数

int main( int argc, char *argv[ ], char *envp[ ] ) 
{  
       program-statements
}

第一个参数：argc是个整型变量，表示命令行参数的个数（含第一个参数）。

第二个参数：argv是个字符指针的数组，每个元素是一个字符指针，指向一个字符串。这些字符串就是命令行中的每一个参数（字符串）。

第三个参数：envp是字符指针的数组，数组的每一个原元素是一个指向一个环境变量（字符串） 的字符指针。

#include <stdio.h>
int main(int argc, char* argv[], char* envp[])
{    
       int i = 0;  
       for(i=0; i<argc; i++)  
       {     
              printf("%s\n", argv[i]);  
       }    
       return 0;
}
//F:\C\test0718\Debug\test0718.exe
#include <stdio.h>
int main(int argc, char* argv[], char* envp[])
{
       int i = 0;
       while (envp[i] != NULL)
       {
              printf("%s\n", envp[i]);
              i++;
       }
       return 0;
}
/*
COMPUTERNAME=DESKTOP-QV5439H
ComSpec=C:\Windows\system32\cmd.exe
FPS_BROWSER_APP_PROFILE_STRING=Internet Explorer
FPS_BROWSER_USER_PROFILE_STRING=Default
HOMEDRIVE=C:
HOMEPATH=\Users\Yuri
LOCALAPPDATA=C:\Users\Yuri\AppData\Local
LOGONSERVER=\\DESKTOP-QV5439H
MSBuildLoadMicrosoftTargetsReadOnly=true
NUMBER_OF_PROCESSORS=4
OneDrive=C:\Users\Yuri\OneDrive
OS=Windows_NT
Path=C:\Program Files (x86)\Intel\iCLS Client\;C:\Program Files\Intel\iCLS Client\;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;F:\Git\cmd;C:\Program Files\TortoiseGit\bin;C:\Users\Yuri\AppData\Local\Microsoft\WindowsApps;
PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC
PkgDefApplicationConfigFile=C:\Users\Yuri\AppData\Local\Microsoft\VisualStudio\15.0_97bd02f3\devenv.exe.config
PROCESSOR_ARCHITECTURE=x86
PROCESSOR_ARCHITEW6432=AMD64
PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 61 Stepping 4, GenuineIntel
*/
//以上只是部分

结果显示都是环境变量。envp数组的最后一个元素存放NULL指针。

四. 可变参数列表

通过将函数实现为可变参数的形式，可以使得函数可以接受1个以上的任意多个参数（不固定）。

eg：实现一个函数可以求任意个参数的平均值

#include <stdio.h>
#include <stdarg.h>
int average(int n, ...)
{   
       va_list arg;   
       int i = 0;    
       int sum = 0;   
       va_start(arg, n);
       for(i=0; i<n; i++)   
       {
              sum += va_arg(arg, int);
       }    
       return sum / n;  
       va_end(arg);
}
int main()
{
       int a = 1;   
       int b = 2;
       int c = 3;  
       int avg1 = average(2, a, c);  
       int avg2 = average(3, a, b, c);
       printf("avg1 = %d\n", avg1);   
       printf("avg2 = %d\n", avg2);   
       return 0;
}
/*
avg1 = 2
avg2 = 2
*/

声明一个 va_list  类型的变量 arg ，它用于访问参数列表的未确定部分。 

这个变量是调用 va_start 来初始化的。它的第一个参数是 va_list 的变量名，第2个参数是省略号前后一个有名字的参数。初始化过程把 arg 变量设置为指向可变参数部分的第一 个参数。 

为了访问参数，需要使用 va_arg ，这个宏接受两个参数： va_list 变量和参数列表中下一 个参数的类型。在这个例例子中所有的可变数都是整型。 va_arg 返回这个参数的值，并使用 va_arg 指向下⼀个可变参数。 

当访问完最后一个可变参数之后，我们需要调用 va_end。

可变参数的限制：

可变参数必须从头到尾逐个访问。如果在访问了几个可变参数之后想半途终止，这是可以的，但是，如果想⼀开始就访问参数列表中间的参数，那是不行的。

参数列表中至少有一个命名参数。如果连一个命名参数都没有，就无法使用va_start。

这些宏是无法直接判断实际存在参数的数量。

这些宏无法判断每个参数的类型。

如果在va_arg中指定了错误的类型，那么其后果是不可预测的。

五. 字符函数与字符串函数

1.求字符串长度

（1）strlen

size_t strlen ( const char * str );

字符串已 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )。

参数指向的字符串必须要以 '\0' 结束。 

注意函数的返回值为size_t，是无符号的。

模拟实现：

计数器方式：

int my_strlen(const char * str)
{    
       int count = 0;    
       while(*str)  
       {      
              count++;    
              str++;  
       }   
       return count;
}

不创建临时变量计数器方式：

int my_strlen(const char * str)
{
       if (*str == '\0')    
              return 0;   
       else       
              return 1 + my_strlen(str + 1);
}

指针方式：

int my_strlen(char *s)
{
       char *p = s;
       while (*p != '\0')
              p++;
       return p - s;
}

2.长度不受限制的字符串函数

（1）strcpy字符串拷贝

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

源字符串必须以 '\0' 结束。

会将源字符串中的 '\0' 拷贝到目标空间。 

目标空间必须足够大，以确保能存放源字符串。 

目标空间必须可变。

不能将字符串拷贝到常量字符串中。

模拟实现：

char *my_strcpy(char *dest, const char*src)
{
       char *ret = dest;    
       assert(dest != NULL);
       assert(src != NULL);       
       while ((*dest++ = *src++))
       { ; }   
       return ret;
}

（2）strcat 字符串连接

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

源字符串、目标字符串都必须以 '\0' 结束。 

目标空间必须有足够的大，能容纳下源字符串的内容。 

目标空间必须可修改。

模拟实现：

char *my_strcat(char *dest, const char*src)
{
       char *ret = dest;  
       assert(dest != NULL);
       assert(src != NULL);  
       while (*dest)
       {
              dest++;
       }   
       while ((*dest++ = *src++))
       { ; }
       return ret;
}

（3）strcmp字符串比较

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

标准规定：

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

#include<stdio.h>
int main()
{
       char *p = "abcdef";
       char *q = "abcdef";
       if (p == q)
       {
              printf("p==q");
       }
       else
       {
              printf("p!=q");
       }
       return 0;
}
//输出p==q
//常量字符串存一份，p与q指向同一块空间。若是两个内容一样的字符串数组，则不相等。

3.长度受限制的字符串函数

（1）strncpy

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

拷贝num个字符从源字符串到目标空间。 如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

（2）strncat

char * strncat ( char * destination, const char * source, size_t num );
#include <stdio.h>
#include <string.h>
int main() {
       char str1[20];
       char str2[20];
       strcpy(str1, "Hello ");
       strcpy(str2, "i am a student");
       strncat(str1, str2, 7);
       puts(str1);
       return 0;
}
//Hello i am a

（3）strncmp

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

比较到出现另一个字符不一样或者另一个字符串结束或者num个字符全部比较完.

eg：

#include <stdio.h>
#include <string.h>
int main() {
       char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
       int n;
       printf("Looking for R2 astromech droids :\n");
       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
*/

4.字符串查找

（1）strstr

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

返回str1中str2的第1次出现的指针或空指针。

函数返回一个指针，指向字符串中第一个出现的str2，如果str2没有出现在str1中，则返回NULL。如果str2指向长度为零的字符串，则函数返回字符串。

eg:

#include <stdio.h>
#include <string.h>
int main()
{
       char str[] = "This is a simple string";
       char * pch;
       pch = strstr(str, "simple");
       strncpy(pch, "sample", 6);
       printf("%s\n", str);
       return 0;
}
//This is a sample string

模拟实现：

char *my_strstr(const char* str1, const char* str2)
{
       assert(str1);    
       assert(str2);   
       char *cp = (char*)str1;  
       char *substr = (char *)str2;  
       char *s1 = NULL;     
       if (*str2 == '\0')  
              return NULL;  
       while (*cp)
       {
              s1 = cp;     
              substr = str2;   
              while (*s1 && *substr && (*s1 == *substr))
              {
                     s1++;
                     substr++;
              }    
              if (*substr == '\0')
                     return cp;
              cp++;
       }
}

（2）strtok（在字符串中查找下一个标记）

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

第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。） 

strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。 

如果字符串中不存在更多的标记，则返回 NULL 指针。

eg：

#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
*/
#include <stdio.h>
int main()
{
       char *p = "Taylor@163.com";
       const char* sep = ".@";
       char arr[30];
       char *str = NULL;
       strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容  
       for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
       {
              printf("%s\n", str);
       }
}
/*
Taylor
163
com
*/

5.错误信息报告

（1）strerror

char * strerror ( int errnum );
#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));
       //errno: Last error number  
       return 0;
}
/*
Error opening file unexist.ent: No such file or directory
*/

6.内存操作函数

（1）memcpy

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

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。 

这个函数在遇到 '\0' 的时候并不会停下来。 

如果source和destination有任何的重叠，复制的结果都是未定义的。

#include <stdio.h>
#include <string.h>
struct {
       char name[40];
       int age;
}person, person_copy;
int main()
{
       char myname[] = "Taylor de Fermat";
       //using memcpy to copy string:
       memcpy(person.name, myname, strlen(myname) + 1);
       person.age = 22;
       //using memcpy to copy structure:
       memcpy(&person_copy, &person, sizeof(person));
       printf("person_copy: %s, %d \n", person_copy.name, person_copy.age);
       return 0;
}
//person_copy: Taylor de Fermat, 22

模拟实现：

void * memcpy(void * dst, const void * src, size_t count)
{
       void * ret = dst;     
       assert(dst);
       assert(src);
       //copy from lower addresses to higher addresses
       while (count--)
       {
              *(char *)dst = *(char *)src;
              dst = (char *)dst + 1;
              src = (char *)src + 1;
       }
       return(ret);
}

（2）memmove

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

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。 

如果源空间和目标空间出现重叠，就得使用memmove函数处理。

#include <stdio.h>
#include <string.h>
int main()
{
       char str[] = "memmove can be very useful......";
       memmove(str + 20, str + 15, 11);
       puts(str);
       return 0;
}
//memmove can be very very useful.

模拟实现：

void * memcpy(void * dst, const void * src, size_t count)
{
       void * ret = dst;
       if (dst <= src || (char *)dst >= ((char *)src + count))
       {
              //Non-Overlapping Buffers
              //copy from lower addresses to higher addresses
              while (count--)
              {
                     *(char *)dst = *(char *)src;
                     dst = (char *)dst + 1;
                     src = (char *)src + 1;
              }
       }
       else {
              //Overlapping Buffers
              //copy from higher addresses to lower addresses
              dst = (char *)dst + count - 1;
              src = (char *)src + count - 1;
              while (count--) { *(char *)dst = *(char *)src;
              dst = (char *)dst - 1;
              src = (char *)src - 1;
              }
       }
       return(ret);
}

（3）memcmp

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

比较从ptr1和ptr2指针开始的num个字节。

返回值：

<0ptr1 less than ptr2
0ptr1 identical to ptr2
>0

ptr1 greater than ptr2

#include <stdio.h>
#include <string.h>
int main()
{
       char buffer1[] = "DWgaOtP12df0";
       char buffer2[] = "DWGAOTP12DF0";
       int n;
       n = memcmp(buffer1, buffer2, sizeof(buffer1));
       if (n > 0)
              printf("'%s' is greater than '%s'.\n", buffer1, buffer2);
       else if (n < 0)
              printf("'%s' is less than '%s'.\n", buffer1, buffer2);
       else printf("'%s' is the same as '%s'.\n", buffer1, buffer2);
       return 0;
}
//'DWgaOtP12df0' is greater than 'DWGAOTP12DF0'.

六. 输入输出函数

1.错误报告函数

void perror ( const char * str );

perror 以一种简单、统一的方式报告错误。ANSIC函数库的许多函数调用操作系统来完成某些任务，I/O函数尤其如此，当操作系统按照要求执行某些任务的时候就可能会失败，例如：尝试打开⼀个根本就不存在的文件，读取内容。操作系统的做法就是发生错误的时候，能够提示发生了错误。标准库函数提供了一个全局的变量 errno （在errno.h中定义），来记录错误的错误码，交给用户程序，用于提示错误的准确原因。

eg:

#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;
}
//The following error occurred: No such file or directory

如果perror函数的参数str指针不是NULL，并指向一个非空的字符串，perror函数先打印这个字符串，然后跟着输出一个分号和一个空格，接着输出错误信息提示。

errno这个值只有在调用库函数的时候发生问题了，才能会被设置。而函数调用成功之后也不会修改，所以不能使用errno来判断一个函数是否执行成功。

2.终止执行

void exit (int status);

参数status返回给操作系统，用于提示程序是否正常完成。 

C语言定义了预定义符号： EXIT_SUCCESS 和  EXIT_FAILURE 来表示成功或者失败返回。

#include <stdio.h>      /* printf, fopen */
#include <stdlib.h>     /* exit, EXIT_FAILURE */
int main()
{
       FILE * pFile;
       pFile = fopen("myfile.txt", "r");  
       if (pFile == NULL)
       {
              printf("Error opening file");  
              exit(EXIT_FAILURE);
       }
       else
       {   
              /* file operations here */
       }
       return 0;
}
//Error opening file

3.I/O函数

功能

函数名

适用于

字符输入函数

getchar

标准输入流

字符输出函数

putchar

标准输出流

字符输入函数

fgetc, getc

所有输入流

字符输出函数

fputc, putc

所有输出流

文本行输入函数

fgets, gets

所有输入流

文本行输出函数

fputs, puts

所有输出流

格式化输入函数

scanf

标准输入流

格式化输出函数

printf

标准输出流

格式化输入函数

fscanf

所有输入流

格式化输出函数

fprintf

所有输出流

二进制输入

fread

文件

二进制输出

fwrite

文件

4.打开流

FILE * fopen ( const char * filename, const char * mode );
#include <stdio.h>
int main ()
{
       FILE * pFile;
       pFile = fopen ("myfile.txt","w");
       if (pFile!=NULL)
       {  
              fputs ("fopen example",pFile);
              fclose (pFile);
       }
       return 0;
}

5.关闭流

int fclose ( FILE * stream );
#include <stdio.h>
int main ()
{
       FILE * pFile;
       pFile = fopen ("myfile.txt","wt");
       fprintf (pFile, "fclose example");
       fclose (pFile);
       return 0;
}

文件使用方式

含义

如果指定文件不存在

r（只读）

为了输入数据，打开一个已经存在的文本文件

出错

w（只写）

为了输出数据，打开一个文本文件

建立一个新文件

a（追加）

向文本文件尾添加数据

出错

rb（只读）

为了输入数据，打开一个二进制文件

出错

wb（只写） 

为了输出数据，打开一个二进制文件

建立一个新文件

ab（追加）

向一个二进制文件尾添加数据

出错

r+（读写）

为了读和写，打开一个文本文件

出错

w+（读写）

为了读和写，建议一个新的文件

建立一个新文件

a+（读写）

打开一个文件，在文件尾进行读写

建立一个新文件

rb+（读写）

为了读和写打开一个二进制文件

出错

wb+（读写）

为了读和写，新建一个新的二进制文件

建立一个新文件

ab+（读写）

打开一个二进制文件，在文件尾进行读和写

建立一个新文件

6.字符I/O

（1）getchar和putchar函数

int getchar ( void );
int putchar ( int character );
#include<stdio.h>
int main()
{
       int c;
       puts("Enter text. Include a dot ('.') in a sentence to exit");
       do
       {   
              //getchar 是从标准输⼊入获取⼀一个字符  
              c=getchar();   
              //putchar 是向标准输出流输出⼀一个字符   
              putchar (c);  
       } while (c != '.');
       return 0;
}
/*
Enter text. Include a dot ('.') in a sentence to exit
edd
edd
cc
cc
vv
vv
*/

（2）getc和putc函数

int getc ( FILE * stream ); 
int putc ( int character, FILE * stream );
#include <stdio.h>
int main ()
{
       FILE * pFile;  
       int c;
       int n = 0;
       pFile=fopen ("myfile.txt","r");
       if (pFile==NULL)
              perror ("Error opening file");
       else
       {    
              do   
              {    
                     c = getc (pFile);   
                     if (c == '$') n++;
              }
              while (c != EOF);
              fclose (pFile);
              printf ("File contains %d$.\n",n);
       }  
       return 0;
}
//File contains 0$.

（3）fgetc和fputc函数

int fgetc ( FILE * stream ); 
int fputc ( int character, FILE * stream );

getc和fgetc功能一样。 putc和fputc功能一样。 

有些编译器将getc和putc实现为宏。

7.未格式化的行I/O

（1）gets和puts

char * gets ( char * str ); 
int puts ( const char * str );
#include <stdio.h>
int main()
{
       char string[256];
       printf("Insert your full address: ");  
       gets(string);     
       // warning: unsafe (see fgets instead)  
       printf ("Your address is: %s\n",string);
       puts(string);
       return 0;
}
/*
Insert your full address: jjsd8294rhv
Your address is: jjsd8294rhv
jjsd8294rhv
*/

（2）fgets和fputs

char * fgets ( char * str, int num, FILE * stream );
 int fputs ( const char * str, FILE * stream );
#include <stdio.h>
int main() {
       FILE * pFile;  
       char mystring[100];
       pFile = fopen("myfile.txt", "r");  
       if (pFile == NULL)
              perror("Error opening file");
       else
       {
              if (fgets(mystring, 100, pFile) != NULL)   
                     puts(mystring);    
              fclose(pFile);
       }  
       return 0;
}
//fclose example

8.格式化的行I/O

（1）scanf和printf

int scanf ( const char * format, ... ); 
int printf ( const char * format, ... );

（2）fscanf和fprintf

int fscanf ( FILE * stream, const char * format, ... ); 
int fprintf ( FILE * stream, const char * format, ...);
#include <stdio.h>
int main()
{
       char str[80];
       float f;
       FILE * pFile;
       pFile = fopen("myfile.txt", "w+");
       fprintf(pFile, "%f %s", 3.1416, "PI");
       rewind(pFile);
       fscanf(pFile, "%f", &f);
       fscanf(pFile, "%s", str);
       fclose(pFile);
       printf("I have read: %f and %s \n", f, str);
       return 0;
}
//I have read: 3.141600 and PI

9.二进制I/O

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream ) ;
#include <stdio.h>
int main()
{
       FILE * pFile;
       char buffer[] = { 'x' , 'y' , 'z' };
       pFile = fopen("myfile.bin", "wb");
       fwrite(buffer, sizeof(char), sizeof(buffer), pFile);
       fclose(pFile);
       return 0;
}

10.文件结束判定

在文件读取过程中，不能用feof函数的返回值直接用来判断文件的是否结束。而是应用于当文件读取结束的时候，判断是读取失败结束，还是遇到文件尾结束。

文本文件读取是否结束，判断返回值是否为EOF （fgetc），或者NULL（fgets） 

例如： fgetc判断是否为EOF。fgets判断返回值是否为NULL。

二进制文件的读取结束判断，判断返回值是否小于实际要读的个数。 

例如： fread判断返回值是否小于实际要读的个数。

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
       int c;
       FILE* fp = fopen("test.txt", "r");
       if(!fp) {
              perror("File opening failed");
              return EXIT_FAILURE;
       }    
       //fgetc 当读取失败的时候或者遇到文件结束的时候，都会返回EOF    
       while ((c = fgetc(fp)) != EOF) // 标准C I/O读取文件循环    
       {
              putchar(c);
       }   
       //判断是什么原因结束的    
       if (ferror(fp))
              puts("I/O error when reading");
       else if (feof(fp))
              puts("End of file reached successfully");
       fclose(fp);
}

 

带你学习javascript的函数进阶（二）
01-08
总之，JavaScript的函数进阶涵盖了多种强大的概念，如严格模式、高阶函数、闭包和递归，这些都极大地丰富了我们的编程工具箱，帮助我们编写更加健壮、可维护的代码。通过深入学习和实践这些概念，开发者可以提高代码...
day11-函数进阶作业讲解
05-21
函数进阶作为编程学习的一个重要部分，是指在掌握了基础的函数定义、调用和参数传递等知识之后，进一步深化对函数的使用和理解。在高级阶段，学习者需要掌握函数的高级特性，如闭包、递归、高阶函数等。闭包能够使...
JavaScript进阶（四）- 函数进阶
Ludwig1957的博客
02-07 448
2021.2.6 文章目录JavaScript进阶（四）函数进阶函数的定义和调用函数的定义方式函数的调用方式this函数内this的指向改变函数内部this指向call()、apply()、bind()总结严格模式什么是严格模式开启严格模式严格模式中的变化高阶函数闭包变量作用域什么是闭包闭包案例递归什么是递归利用递归求数学题浅拷贝和深拷贝 JavaScript进阶（四） 函数进阶 函数的定义和调用 函数的定义方式 函数声明方式function()关键字（命名函数） 函数表达式（匿名函数） new Fu.
day10-函数的返回值
一纸青尘染流年的博客
10-12 304
函数的返回值 1.什么是返回值 返回值就是从函数内部传递到函数外部的数据（默认情况下函数内部产生的新数据，在函数外部不能使用） 2.怎么确定函数返回值 1) python中每个函数都有返回值，返回值是什么就看执行函数体的时候遇到的return关键字后面的数据是什么 如果没有遇到return，返回值就是None (希望作为返回值的数据在函数结束的时候放在return后面) 2) return的作用 遇到return会确定函数返回值并且直接结束函数 3.怎么在函数外部获取函数返回值 函数调用表达式的值就是
函数的进阶
weixin_30329623的博客
11-01 110
本节主要内容: 1. 函数参数--动态传参 2. 名称空间, 局部名称空间, 全局名称空间, 作⽤域, 加载顺序. 3. 函数的嵌套 4. gloabal, nonlocal关键字 ⼀. 函数参数--动态传参 之前我们说过了传参, 如果我们需要给⼀个函数传参, ⽽参数⼜是不确定的. 或者我给⼀个 函数传很多参数, 我的形参就要写很多, 很⿇烦, 怎么办呢. 我们可以考虑使⽤动...
计算机语言python函数进阶
05-09
Python函数进阶 多参数解析 使⽤ `*args`（元组） 和 `**kwargs` （字典）来调⽤函数 使用`*args`非关键字可变参数方式 # 以元祖方式传递 nums = (1, 2, 3) 使用`**kwargs`关键字可变参数方式 # 以字典...
001.Python面向对象深入及函数进阶_笔记.pdf
最新发布
07-23
Python面向对象编程深入探讨及函数进阶是编程学习中的重要课题，涉及到编程范式的理解和实际应用。首先，面向对象编程（OOP）是一种将数据和函数封装在一起的方法，使得程序设计更加模块化和易于维护。Python中的OOP...
【黑马python：函数进阶】81-84
11-09
黑马Python：函数进阶系列课程的第81-84讲，主要围绕Python编程语言中的函数功能进行深入讲解。在这一阶段，学员们将接触到函数的高级特性，包括但不限于装饰器的应用、偏函数的创建与使用、闭包的概念及其在实际...
分析函数进阶（一）
charels
12-03 624
分析函数进阶（一） 一、常用分析函数介绍 --分析函数可以并行，这是它应用比较广泛的一个原因。 --分析函数可以实现以下几类功能 1.Rankings and percentiles --排序和计算比例 2.Moving window calculations --移动窗口计算 3.Lag/lead analysis -- 4.First/last ana
递归实现：接受一个整型值（无符号）按顺序打印它的每一位
qq_48690739的博客
07-17 96
#include<stdio.h> void print(int n) { if (n > 9) { print(n / 10); } printf("%d ", n % 10); } int main() { unsigned int ret = 0; scanf("%d", &ret); print(ret); system("pause"); return 0; }
拆分整数（以函数递归的方式拆分一个整数）
clearlover76的博客
11-27 783
#include<stdio.h> void print(unsigned int n) { if (n>9) { print(n / 10); } printf("%d\t", n % 10); } int main() { unsigned int num = 0; scanf("%u", &num); print(num); return 0; }
Selenium2(WebDriver)总结(一)---启动浏览器、设置profile&加载插件
weixin_34277853的博客
02-02 785
本文主要记录下在使用selenium2/webdriver时启动各种浏览器的方法、以及如何加载插件、定制浏览器信息(设置profile)等 环境搭建可参考我的另一篇文章：http://www.cnblogs.com/puresoul/p/3483055.html 一、Driver下载地址： 　　http://docs.seleniumhq.org/download/ 二、启动firefox...
初识C语言，简单的函数递归==＞实现依次打印出数字中的每一位
慕雪华年的博客
10-26 948
简单的Print递归 说句题外话，很多时候单词我是认识的，但是如果它全大写了，我总要反应老一会才能想出来它的意思 有和我一样的人吗? 今天的c语言课讲到了一道非常经典的递归题目 代码如下： #include <stdio.h> void Print(int n) { if (n > 9) Print(n / 10); printf("%d ", n % 10); } int main() { int num = 0; scanf("%d", &num); Pr
va_list 、va_start、 va_arg、 va_end 使用说明
热门推荐
11-07 3万+
在ANSI C中，这些宏的定义位于stdarg.h中： typedef char *va_list; va_start宏，获取可变参数列表的第一个参数的地址（list是类型为va_list的指针，param1是可变参数最左边的参数）： #define va_start(list,param1)   ( list = (va_list)&amp;param1+ sizeof(param1) )...
栈让我用完了
chunlovenan的专栏
04-16 1192
问题：从事一个项目的开发已经好几个月了，多了一个模块就task_create()一下。昨天当我将串口的代码加入到项目工程文件中进行编译的时候，（还没有调用串口驱动程序，知识初始化一下），但是导致的结果是程序运行不是预期的效果。 解决方法：靠人品 本来想从系统的__start处，彻底的想追踪一下代码的运行情况，但是我潜意识告诉我，随便从app层来下个断点试试，我就在不同的任务创建处，
JS函数进阶
安然同学
05-13 2032
JS函数高级 1、原型与原型链 1、原型(prototype) 1、函数的prototype属性 每个函数都有一个prototype属性，它默认指向一个空的Object对象(即原型对象) 原型对象中有一个属性constructor，它指向函数对象 function Fun () {//alt + shift +r(重命名rename) } console...
va_start用法
tracing everything
08-25 8683
此文转自别人博客，感谢原作者1:当无法列出传递函数的所有实参的类型和数目时,可用省略号指定参数表void foo(...);void foo(parm_list,...);2:函数参数的传递原理函数参数是以数据结构:栈的形式存取,从右至左入栈.eg:先介绍一下可变参数表的调用形式以及原理：首先是参数的内存存放格式：参数存放在内存的堆栈段中，在执行函数的时候，从最后一个开始入栈。因此栈底
函数进阶：日期运算与逻辑实现
"本章主要介绍了函数进阶的技巧，以日期运算是核心案例，涵盖了日期合法性的判断、计算两个日期之间的天数差、日期加减整数后的日期计算以及确定日期是星期几的方法。通过定义结构体date来存储年月日，并利用二维...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值