标准IO、目录IO

已于 2022-10-09 18:44:42 修改
阅读量313 收藏
点赞数 1
分类专栏： 文件IO 文章标签： java servlet jvm
于 2022-10-09 18:40:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48102054/article/details/127231860
版权

一、printf函数输出问题。
1.printf函数的对象是谁？
printf()功能就是输出一个字符串到屏幕上，屏幕对象有两个，分别是标准输出、标准出错。
printf()其对象就是标准输出。

2.标准输出与标准出错有什么区别？
标准输出是有缓冲区的，其内容是先放在缓冲区，再输出。
标准出错是没有缓冲区的，其内容是直接输出。

3.研究一下printf()的输出问题。
例子1： 
int main(int argc,char *argv[])
{
    printf("helloworld");
    printf("appletree");
    while(1);
    return 0;
}

执行结果：不会输出任何的内容，然后卡在死循环中。
分析： 因为printf函数是一个行缓冲区函数，所以必须要在标准输出缓冲区中遇到'\n'就可以输出东西。

例子2：
int main(int argc,char *argv[])
{
    printf("helloworld");
    printf("appletree\n");
    printf("yueqian");
    while(1);
    return 0;
}

执行结果：输出helloworld和appletree，但是yueqian并没有输出。
分析：证明必须要遇到\n才可以将\n之前的全部东西输出。

例子3：
int main(int argc,char *argv[])
{
    printf("helloworld");
    printf("appletree");
    return 0;
}

执行结果：输出helloworldappletree
分析：程序退出时，会刷新标准输出缓冲区。


例子4：
int main(int argc,char *argv[])
{
    while(1)
    {
        printf("helloworld");
        usleep(100000);  //0.1s
    }
    return 0;
}

执行结果：等到缓冲区满了(1024B)，就会将缓冲区中所有的数据全部输出。
分析：标准输出的缓冲区满了，即使没有'\n'，程序也没有退出，也是会全部输出的。
   

例子5：
int main(int argc,char *argv[])
{
    int x;
    printf("helloworld");
    printf("appletree");
    scanf("%d",&x);
    while(1);
    return 0;
}

执行结果：输出helloworldappletree
分析：键盘输入的函数也会刷新printf的缓冲区。

例子6：主动刷新缓冲区   ---> fflush()  -->  man 3 fflush
功能： 刷新一个流。
fflush - flush a stream
#include <stdio.h>
int fflush(FILE *stream);
参数：
    stream： 文件指针    如果要刷新标准输出缓冲区，这里填stdout。
返回值：
    成功:0
    失败:-1

int main(int argc,char *argv[])
{
    printf("helloworld");
    printf("appletree");
    fflush(stdout);   ---> 主动刷新标准输出缓冲区
    while(1);
    return 0;
}

例子7： 将printf的输出对象修改为标准出错，你想输出什么东西，就会马上输出。
修改输出对象： fprintf()  --> man 3 fprintf
#include <stdio.h>

int fprintf(FILE *stream, const char *format, ...);
参数：
    stream: 输出对象的文件指针。  stderr
    format: 输出的内容。
返回值： 输出的字符个数
         return the number of characters printed

printf("hello");          --> 默认的对象是标准输出
fprintf(stdout,"hello");  --> 将hello放在标准输出的缓冲区中，等价于上面那句话。
fprintf(stderr,"hello");  --> 将hello直接存放在标准出错中，而标准出错没有缓冲区的，所以会直接输出。

-------------------------------
int main(int argc,char *argv[])
{
    //fprintf(stderr,"hello");
    fprintf(stdout,"hello");  //等价于printf("hello")
    while(1);
    
    return 0;
}
-------------------------------
二、标准IO函数。
格式输入：scanf() fscanf() sscanf()    
格式输出：printf() fprintf() sprintf()           <按指定格式读写文件>
字符输入：getchar()  getc()  fgetc()      <按字符读写文件> ---char
字符输出：putchar()  putc()  fputc()  
字符串输入：gets()  fgets()          <按行读写文件>----string
字符串输出：puts() fputs()

1.sprintf()    ---> (常用)保存一个字符串到一个缓冲区中，作用：拼接字符串。
#include <stdio.h>
int sprintf(char *str, const char *format, ...);
参数：
   str: 保存字符串的缓冲区的地址。  （注意：必须要足够大接受数据）
   format: 保存的内容。
返回值：
   保存的内容的字符串长度。
例子1：
   int a = 10;
   printf("a = %d\n",a);          //将a的值存放到%d的位置，然后将a=10这句话输出到标准输出缓冲区中。
例子2：
   int a = 10;
   fprintf(stderr,"a = %d\n",a);  //将a的值存放到%d的位置，然后将a=10这句话输出到标准出错中。
例子3：
   int a = 10;
   char buf[100] = {0};
   sprintf(buf,"a = %d\n",a);     //将a的值存放在%d的位置，然后将a=10这句话保存到buf这个数组中。
说明：
 sprintf 函数可以作为字符串拼接函数

练习1：
char buf1[] = "guoqing"
char buf2[] = "shuangwaiwai"
char buf3[1024];
使用sprintf函数将buf1和buf2拼接到buf3中

#include <stdio.h>

int main(int argc,char **argv)
{
/* 	char buf1[] = "guoqing";
	char buf2[] = "shuangwaiwai"; */
	char buf1[] = "国庆";
	char buf2[] = "爽歪歪";	
	char buf3[1024] = {0};	
	
	sprintf(buf3,"%s%s",buf1,buf2);

	printf("buf3:%s\n",buf3);
	
	return 0;
}

2.getchar()     --->  从标准输入缓冲区中获取一个字符。 作用：清空标准输入的缓冲区。（重点）
#include <stdio.h>
int getchar(void);
参数:无
返回值:
    成功：获取的字符
    失败：-1
注意：
每次scanf()之前，都最好先清空缓冲区。
while(getchar()!='\n');  //清空缓冲区
scanf();  //一定可以保证缓冲区是空的。

3.getc()   --->  从某一个文件指针中获取一个字符
#include <stdio.h>
int getc(FILE *stream);
参数：
   stream： 文件指针
返回值:
    成功：获取的字符
    失败：-1
 
说明：
1)getchar()   --> 固定从标准输入缓冲区获取，不能从别的地方获取。
2)getc(stdin)  等价于 getchar()  --> 指定从标准输入缓冲区中获取一个字符
FILE *fp = fopen("xxx","r");
getc(fp);                      --> 指定从xxx这个文件中获取一个字符。
------------------------------
#include <stdio.h>
int main()
{
    FILE *fp = fopen("1.txt","r");  //hello
    
    int c = getc(fp);
    printf("c = %d\n",c);
    printf("c = %c\n",c);
    
    c = getc(fp);
    printf("c = %d\n",c);
    printf("c = %c\n",c);
    
    fclose(fp);
    
    return 0;
}
---------------------------------
总结：
getc和getchar两个功能有重叠部分 getc() > getchar()
getc重复使用的时候，光标也在移动

4.fgetc()   等价于  getc()
两个参数一样
#include <stdio.h>
int fgetc(FILE *stream);
int getc(FILE *stream);

5.putchar()   -->  把某一个字符存放在标准输出的缓冲区中
#include <stdio.h>
int putchar(int c);
参数：
    c: 需要输出的字符
返回值：
    成功：写入的字符
    失败：-1
-------------------------
#include <stdio.h>

int main(int argc,char *argv[])
{
    int c = putchar('x');
    printf("c = %d\n",c);
    printf("c = %c\n",c);
    
    return 0;
}
--------------------------

6.putc()  ---> 将字符存放在文件指针中。
#include <stdio.h>
int putc(int c, FILE *stream);
参数：
    c: 需要输出的字符
    stream: 文件指针
返回值：
    成功：写入的字符
    失败：-1
----------------------------
#include <stdio.h>
int main(int argc,char *argv[])
{
    //putc('x',stdout);
    
    FILE *fp = fopen("2.txt","w");
    putc('x',fp);
    
    putc('k',fp);
    
    fclose(fp);
    
    return 0;
}
-----------------------------
总结：
putc和putchar两个功能有重叠部分 putc() > putchar() 
连续使用putc(),光标也会移动

7.fputc() 等价于 putc()
两个函数参数一样，返回值也一样
#include <stdio.h>
int fputc(int c, FILE *stream);
int putc(int c, FILE *stream);

8.gets()   -->  从标准输入缓冲区中获取一个字符串(不要用、危险)
#include <stdio.h>
char *gets(char *s);
参数：
        s: 缓冲区
返回值：
    成功:s的值
    失败:NULL

------------------------------
#include <stdio.h>
int main(int argc,char *argv[])
{
    char s[10] = {0};
    gets(s);    ---> 如果获取的字符超过10个，就会有问题。
    printf("s = %s\n",s);
    
    return 0;
}
说明：
gets()函数很危险，不要用。
/tmp/ccQKjzYm.o: In function `main':
gets.c:(.text+0x39): warning: the `gets' function is dangerous and should not be used.
-----------------------------

9.fgets()   --> 获取一个字符串
#include <stdio.h>
char *fgets(char *s, int size, FILE *stream);
参数：
    s: 缓冲区的地址
    size: 最多获取的字节数
    stream: 文件指针
返回值：
    成功:s的值
    失败:NULL
注意如下:
int main(int argc,char *argv[])
{
    FILE *fp = fopen("1.txt","r+");

    char buf[10] = {0};
    fgets(buf,6,fp);
    printf("buf:%s\n",buf);
    /*        
    buf:abcde
    说明：如果你想从文件里面拿出5个字节，你至少要拿6个;因为最后
    一个会自动补'\0'结束符。
    */
    return 0;
}
练习2：
用代码来验证fgets的功能

#include <stdio.h>
#include <string.h>

int main(int argc,char *argv[])
{
/* 	char buf[10] = {0};
	//等价于scanf,但是不同之处是fgets将‘\n’也会拿到buf中
	fgets(buf,sizeof(buf),stdin);
	printf("buf:%s strlen(buf)=%ld\n",buf,strlen(buf)); */
	
	FILE *fp = fopen("1.txt","r+");

	char buf[10] = {0};
	fgets(buf,6,fp);
	printf("buf:%s\n",buf);
			
/* 	buf:abcde
	说明：如果你想从文件里面拿出5个字节，你至少要拿6个;因为最后
	一个会自动补'\0'结束符。 */
	
	return 0;
}

10.puts()   ---> 输出一个字符串到标准输出中。
#include <stdio.h>
int puts(const char *s);
参数：
    s: 输出的字符串
返回值：
    成功：输出字符串的字符个数
    失败：-1

-------------------------
#include <stdio.h>
int main()
{
    char *s = "helloworld";
    puts(s);
    return 0;
}
-------------------------

11.fputs()  --->输出一个字符串到指定的文件指针中
#include <stdio.h>
int fputs(const char *s, FILE *stream);
参数：
    s: 缓冲区的地址
    stream: 文件指针
返回值：
    成功:非负数
    失败:负数

12.scanf() --->从标准输入里面按照指定格式获取数据
#include <stdio.h>
int scanf(const char *format, ...);
案例
int num;
scanf("%d",&num);

13.fscanf() --->从文件指针里面按照指定格式获取数据(重点：拆分字符串)
#include <stdio.h>
int fscanf(FILE *stream, const char *format, ...);
案例
FILE *fp = fopen("1.txt","r+");
char buf[1024];
fscanf(fp,“%s",buf)

练习3：
用fscanf将1.txt里面的字符串拆分 “aaa,bbb,ccc”
char buf1[]
char buf2[]
char buf3[]
//可以切割以逗号隔开的字符串
fscanf(fp,"%[^','],%[^','],%s",buf1,buf2,buf3); //OK

#include <stdio.h>
#include <string.h>

int main()
{
	FILE *fp = fopen("1.txt","r+");
	
/* 	char buf[1024] = {0};
	
	fscanf(fp,"%s",buf);
	
	printf("buf:%s\n",buf);
	 */
	
/* 	int num = 0;
	fscanf(fp,"%d",&num);
	printf("num:%d\n",num); */
	
	char buf1[1024] = {0};
	char buf2[1024] = {0};
	char buf3[1024] = {0};
	//fscanf(fp,"%s,%s,%s",buf1,buf2,buf3); //错误
	
	//可以切割以逗号隔开的字符串
	fscanf(fp,"%[^','],%[^','],%s",buf1,buf2,buf3); //OK
	
	//fscanf(fp,"%3s,%3s,%3s",buf1,buf2,buf3);//有局限性
	
	printf("buf1:%s buf2:%s buf3:%s\n",buf1,buf2,buf3);
	
	return 0;
}

14.sscanf --->从字符串里面按照指定格式获取数据（重点：拆分字符串）
#include <stdio.h>
int sscanf(const char *str, const char *format, ...);
案例1
char *str = "bling"
char name[20]={0};
sscanf(str,"%s",name);
案例2
char *str1 = "bling,zhangsan,lisi";
char buf1[1024] = {0};
char buf2[1024] = {0};
char buf3[1024] = {0};
sscanf(str1,"%[^','],%[^','],%s",buf1,buf2,buf3);//拆分字符串
printf("buf1:%s buf2:%s buf3:%s\n",buf1,buf2,buf3);

三、目录IO
1.为什么要学习目录IO接口？
目录可以存放一些文件/目录，如果学习目录IO操作，那么我们就可以通过目录的名字来将目录下的全部名字读取出来，方便后续的操作。
例如：usr_data/
bling.txt aaa.txt bbb.txt  --> 通过目录IO操作函数，就可以求出这些文件的名字。

2.访问文件与访问目录有什么区别？
访问文件  --> 得到文件里面的内容。
访问目录  --> 得到目录项的名字、属性、类型..

四、目录IO函数接口？
1.如何打开目录？  -->  opendir()  --> man 3 opendir
#include <sys/types.h>
#include <dirent.h>   //目录的专属头文件
DIR *opendir(const char *name);
参数：
    name： 需要打开的那个目录的路径
返回值：
    成功：目录流指针
    失败：NULL

问题：打开一个目录是不是意味着已经切换进去了？
答案：没有切换进去。

2.如何切换到目录中？  --> chdir()   --> man 3 chdir
问题：一定要切换到目录下，才能读取目录的东西吗？
答案：不一定，但是切换进去之后，该目录下所有的文件都是当前目录下的文件，访问这些文件就很方便。
#include <unistd.h>
 int chdir(const char *path);
参数：
  path:  需要切换的那个目录的路径。

返回值：
    成功：0
    失败：-1

3.如何读取目录下的内容？  -->  readdir()  --> man 3 readdir
#include <dirent.h>
struct dirent *readdir(DIR *dirp);
参数：
    dirp: 目录流指针
返回值：    
    成功：结构体指针
    失败：NULL    ---> 当读取目录完毕，就会返回NULL

说明：
每读取一个目录项，都会返回一个结构体指针，来代表这一个项的属性。
struct dirent{
               ino_t          d_ino;       //索引号
               off_t          d_off;       //偏移量
               unsigned short d_reclen;    //记录文件名长度
               unsigned char  d_type;      //文件类型
               char           d_name[256]; //文件名(重点掌握)
};

文件类型：
DT_BLK      This is a block device.      ---> 块设备文件     //6
DT_CHR      This is a character device.  ---> 字符设备文件   //2
DT_DIR      This is a directory.         ---> 目录文件       //4
DT_FIFO     This is a named pipe (FIFO). ---> 管道文件       //1
DT_LNK      This is a symbolic link.     ---> 链接文件       //10
DT_REG      This is a regular file.      ---> 普通文件       //8
DT_SOCK     This is a UNIX domain socket.---> 套接字文件     //12

文件名：最多可以设置256个字符。
练习：
读一次和循环读打印它的文件名

4.关闭文件。  --> closedir()  --> man 3 closedir
#include <sys/types.h>
#include <dirent.h>
int closedir(DIR *dirp);
参数：
    dirp:  目录流指针
返回值：
    成功：0
    失败：-1

5.重置目录指针。   ---> rewinddir()  --> man 3 rewinddir
#include <sys/types.h>
#include <dirent.h>
void rewinddir(DIR *dirp);
参数：
     dirp:  目录流指针
返回值：无

例子： 写代码，读取一个目录下的全部文件名出来。
#include <sys/types.h>
#include <dirent.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

int main()
{
    //1. 打开目录。
    DIR *dp = opendir("./bling_dir");
    if(dp == NULL)
        printf("opendir error!\n");
    
    //2. 切换到目录下。
    chdir("./bling_dir");
    
    //3. 不断去读取该目录下的文件名。
    struct dirent *ep = NULL;
    
    while(1)
    {
        ep = readdir(dp);
        if(ep == NULL)  //说明已经读取到最后一项了
        {
            break;
        }
        
        if(ep->d_name[0] == '.')  //如果文件名的第一个字符是.
        {
            continue;
        }
        
        printf("%s\n",ep->d_name);
    }
    
    //4. 关闭该目录。
    closedir(dp);
    
    return 0;
}

JAN JM
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++标准IO文档
02-22
### C++标准IO知识点详解 #### 一、C++标准IO概述 C++标准库提供了丰富的输入输出（IO）功能，这些功能通过一系列面向对象的API实现，支持对各种设备如控制台、文件等的读写操作。这些API还包括一些特殊类型，允许...
RapidIO 4.0协议标准
12-28
### RapidIO 4.0协议标准详解 #### 一、概述 **RapidIO 4.0协议**是RapidIO组织发布的一项重要的输入/输出逻辑规范标准，它旨在为高性能计算、通信设备以及嵌入式系统提供一个高速、低延迟的互连技术。RapidIO 4.0...
c语言 标准i o 流,C的标准I/O库
weixin_29973077的博客
05-22 415
标准I/O库.这个东东一般只要上个C语言的人都学过.比如printf函数.这些东东,大都是建立在一个叫FILE的对象上.下面我清数下这此函数.(可能还有很多没有!)int fwide(FILE *fp,int mode); //流处理是宽字节还是字节的或者无字节的,看下面的_IO_fwide_maybe_incompatiblevoid setbuf(FILE* fp,char *res...
C++标准库之：IO库
时空旅客的专栏
12-02 789
C++语言不直接处理输入输出，而是通过一族定义在标准库中的类型来处理IO。这些类型支持从设备读取数据、向设备写入数据的IO操作，设备可以是文件、控制台窗口等。还有一些类型允许内存IO，即，从string读取数据，向string写入数据。
【嵌入式Linux笔记】02--系统IO 、标准IO、目录操作
Jason的技术探索与分享
12-16 482
本文内容：系统IO 、标准IO、目录操作   linux文件IO 1.课程概览   核心内容：使用linux中提供一系列函数(API),去操作linux当中的文件             (新建文件、打开文件、读写文件、关闭文件)   我们发现前面我已经学过如何操作文件：             使用命令来操作：vi  touch  gedit vim             使用函数接口来写...
linux文件IO、标准IO和目录IO
weixin_43937576的博客
09-29 937
一、文件IO 1.open – 打开或创建一个文件 open（char *, flag, mode）在fcntl.h文件中声明。函数的作用：创建或打开某个文件，参数：最多有三个参数; 第一个参数，char * 包含有文件名和路径 第二个参数：flag 打开文件的方式 第三个参数：mode 创建文件的权限。 flag内容如下： flag 功能 O_RDONLY 只读 O_W...
文件IO与标准IO
weixin_49606782的博客
08-29 828
注：linux除了支持普通文件外,还支持很多特有的文件,因为linux把一切都看做了文件.文件io linu系统特有的使用的是GLIBC库 针对linu所有文件。在Linux中对文件的访问我们主要使用到到标准io 与文件io两种接口。标准io 是由标准c库提供的 通用的 只针对普通的文件。通过代码实现对文件的创建、删除、修改等操作。...
标准IO和文件IO
wy749929317的博客
03-17 1496
一、标准IO 标准I/O指的是ANSIC中定义的用于I/O操作的一系列函数，所需头文件：#include<stdio.h> 流： 标准I/O都是基于流进行操作，当用标准I/O打开一个文件时，就会创建一个FILE结构体来描述这个文件，我们把这个结构体形象地称为流。 流的打开和关闭： 使用标准I/O打开流的函数有：fopen()/fdopen()/freopen()，它们可以以不同模式打开文件，都返回一个指向FILE的指针，该指针指向对应的I/O流。关闭流的函数fclose()，将流的缓冲
系统IO和标准IO
qq_38406587的博客
04-04 2949
一、系统IO和标准IO I/O：是一切实现的基础 stdio标准IO sysio系统调用IO（文件IO） stdio：FILE类型贯穿始终 sysio：fd是在文件IO中贯穿始终的类型，fd是文件描述符（整型数）
C语言标准IO
qq_45698138的博客
04-28 3259
文章目录一、文件指针1、fopen打开文件，得到这个文件的文件指针2、fclose关闭文件3、每次一个字符的读写fgetc,fputc,feof,ferror注意：4、每次一行的读写 fgets,fputs注意：安全gets：5、每次读写若干数据块 fread,fwrite注意：6、获取或设置文件当前位置偏移量fseek,ftell,rewind注意：7、标准格式化IO，fprintf,sprintf,fscanf,scanf注意： 一、文件指针 FILE指针：每个被使用的文件都在内存中开辟出一个区域，用来
Linux中的系统IO与标准IO
不吃鱼的猫的博客
01-27 5491
一、系统IO与标准IO的区别 什么是系统IO与标准IO：（IO为Input/Output,即输入/输出接口） 系统IO：由操作系统直接提供的接口函数 标准IO：由标准C库（第三方库）提供的接口函数（通过封装操作系统提供的系统IO，再给用户使用） 系统IO和标准IO的主要区别： 系统IO：不带缓冲机制，系统IO可以操作普通文件与驱动文件 标准IO：带缓冲机制，标准IO只可以操作普通...
标准IO概述与操作
仙八哥的博客
03-22 1957
标准IO介绍 标准io（input/output）就是标准接口的意思 1、文件的概念和类型（了解） 2、如何理解标准IO（了解） 3、流（FILE）的含义（了解） 4、流的缓冲类型（熟练） 缓冲区实验 //不输出 #include <stdio.h> #include <unistd.h> int main(int argc,char*argv[]){ printf("hello world"); while(1){ sleep(1); } }
利用标准IO，格式化IO
08-28
读一个，写到另一个文件，每隔一秒钟向文件中写入一行数据
无缓存IO操作和标准IO文件操作区别
05-30
无缓存I/O操作与标准I/O文件操作之间的主要区别在于数据处理的层次和缓存机制。系统调用是操作系统内核提供给应用程序的一种接口，允许应用程序请求内核执行特定的任务，如I/O操作。在I/O操作中，无论是无缓存还是...
文件IO 文件操作 操作文件 标准IO和文件IO
03-23
文件IO 文件操作 操作文件 标准IO和文件IO 文件IO是计算机系统中最基本的输入/输出操作之一，它允许程序访问和操作文件。文件IO可以分为两大类：标准IO和文件IO。标准IO是指使用标准输入输出流来读取和写入文件，而...
JAVA进阶补充
2301_80150315的博客
08-15 1014
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 899
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1136
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
【Spring框架】
最新发布
m0_71941456的博客
08-18 836
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
Linux文件属性与标准IO函数探索
这个文档对于初学者来说，是一个很好的Linux系统编程入门教程，涵盖了基本的文件操作和I/O概念，同时也提供了对标准库函数的理解和使用。通过学习这些基础知识，开发者能够更好地理解和控制在Linux系统上的程序行为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值