学习记录——day22 文件IO

已于 2024-07-31 10:27:10 修改
阅读量903 收藏 24
点赞数 28
文章标签： 学习
于 2024-07-30 18:17:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64918301/article/details/140787234
版权

          文件IO是使用系统调用（内核提供的函数）来完成数据的读写操作，不提供缓冲区，基于文件描述符操作文件，每进行一次文件io操作，进程就会从用户空间向内核空间进行一次切换，效率没有标准io高。

文件描述符

        1、文件描述符本质上是一个整数，当文件存储在本地磁盘时，属于静态文件，当使用open函数打开文件时，该文件就属于动态文件，后期需要对文件进行操作的化就需要基于一个句柄来完成，这个句柄就是文件描述符，用一个整数表示。

        2、文件描述符是一个非负整数，一个进程能够使用的文件描述符默认为1024个【0,1023】，可以通过指令uimit -a查看，并且可以通过ulimit -n进行修改进程能够打开的文件描述符个数

         3、使用原则： 最小未分配原则

        4、特殊的文件描述符：0、1、2，分别对应了标准输入、标准输出、标准出错

stdin->_fileno     ===>   0    ===> STDIN_FILENO
stdout->_fileno    ===>  1    ===> STDOUT_FILENO
stderr->_fileno    ===>  2    ===>　STDERR_FILENO

#include <myhead.h>

int main(int argc, char const *argv[])
{
    printf("stdin -> _fileno = %d\n",stdin ->_fileno);  //0
    printf("stdout -> _fileno = %d\n",stdout ->_fileno); //1
    printf("stderr -> _fileno = %d\n",stderr ->_fileno); //2

    FILE *fp = NULL;
    if ((fp = fopen("./file.txt","w")) == NULL)
    {
        perror("fopen error");
        return -1;
    }

    printf("fp -> _fileno = %d\n", fp -> _fileno);//3 最小未分配
    
    return 0;
}

 

myhead.h 包含头文件如下

open打开文件

       #include <sys/types.h>
       #include <sys/stat.h>
       #include <fcntl.h>

       int open(const char *pathname, int flags);
       int open(const char *pathname, int flags, mode_t mode);
        功能：以指定的方式打开指定的文件
        参数1：要打开的文件路径
        参数2：文件打开标识
            必须包含以下三者之一：
                O_RDONLY:以只读的形式打开文件
                O_WRONLY:以只写的形式打开文件
                O_RDWR:以读写的形式打开文件
            以下的可以选择性加入，使用位或完成：
                O_CREAT：如果文件存在，就直接打开，如果文件不存在，则创建文件，此时，参数3必须要加，表示创建的文件权限
                O_TRUNC：表示清空文件内容
                O_APPEND:以追加的形式打开文件
                O_EXCL:确保打开的是不存在的文件，通常跟O_CREAT一起使用，

                                表示本次操作必须创建新文件，如果文件存在，则open函数报错，错误                                   码为：EEXIST
——————————————————————————————————————
                "r":O_RDONLY
                "r+":O_RDWR
                "w":O_WRONLY|O_CREAT|O_TRUNC
                "w+":O_RDWR|O_CREAT|O_TRUNC
                "a":O_WRONLY|O_APPEND|O_CREAT
                "a+":O_RDWR|O_APPEND|O_CREAT

——————————————————————————————————————
            参数3：

当参数2中有O_CREAT属性时，参数3必须加上，表示本次创建文件的文件权 限，

                但是，最终的权限不是用户给定的权限，

                  文件最终的权限是 给定的权限                          mode&~umask的值，umask可以通过指令umask进行查看当前终端的默认掩码，
           可以通过 umask -n   来将掩码更改成 n，但是，这种方式更改的umask只在当前终端              有效，其他终端无效
           也可以通过umask（n）来更改umask的值
                  #include <sys/stat.h>

                 mode_t umask(mode_t cmask);
                 功能：更改当前的umask的值
                 参数：要更改的umask的值
            普通文件权限一般为：0664
            目录文件权限一般为：0775
         ——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
         返回值：成功返回一个新的文件描述符，失败返回-1并置位错误码                      
        

man  fopen

close 关闭文件

       #include <unistd.h>

       int close(int fd);
    功能：关闭文件描述符
    参数：要关闭的文件描述符
    返回值：成功返回0，失败返回-1并置位错误码
    

       #include <unistd.h>

       int close(int fd);
    功能：关闭文件描述符
    参数：要关闭的文件描述符
    返回值：成功返回0，失败返回-1并置位错误码
    
#include<myhead.h>

int main(int argc, const char *argv[])
{

    //创建一个文件描述符变量，用于存储文件描述符
    int fd = -1;
    if((fd = open("./file.txt", O_WRONLY|O_CREAT|O_TRUNC, 0664)) == -1)
    {
        perror("open error");
        return -1;
    }

    printf("open success fd = %d\n", fd);     //3


    //关闭文件
    if(close(fd) == -1)
    {
        perror("close fd 1");
        return -1;
    }


    return 0;
}

read/write 数据读写

       #include <unistd.h>

       ssize_t write(int fd, const void *buf, size_t count);
    功能：向指定的文件中，写入指定的信息
    参数1：已打开的文件描述符
    参数2：要写入的数据的起始地址
    参数3：要写入的数据大小
    返回值：成功返回写入字符的个数，失败返回-1并置位错误码
    
           #include <unistd.h>

       ssize_t read(int fd, void *buf, size_t count);
    功能：从指定的文件中读取count个字节的数据到buf中
    参数1：打开的文件描述符
    参数2：要存放数据的容器起始地址
    参数3：要读取的字节个数
    返回值：成功返回读取字节的个数，失败返回-1并置位错误码

       #include <unistd.h>

       ssize_t write(int fd, const void *buf, size_t count);
    功能：向指定的文件中，写入指定的信息
    参数1：已打开的文件描述符
    参数2：要写入的数据的起始地址
    参数3：要写入的数据大小
    返回值：成功返回写入字符的个数，失败返回-1并置位错误码
    
           #include <unistd.h>

       ssize_t read(int fd, void *buf, size_t count);
    功能：从指定的文件中读取count个字节的数据到buf中
    参数1：打开的文件描述符
    参数2：要存放数据的容器起始地址
    参数3：要读取的字节个数
    返回值：成功返回读取字节的个数，失败返回-1并置位错误码
#include <myhead.h>

typedef struct
{
    char name[20];
    int age;
    double score;
} Stu;

int main(int argc, char const *argv[])
{
    int fd = -1; // 创建一个文件描述符变量，用于存储文件描述符
    if ((fd = open("./file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0664)) == -1)
    {
        perror("open error");
        return -1;
    }

    printf("open success fd = %d\n", fd); // 3

    Stu s[3] = {{"张三", 10, 99.5}, {"李四", 18, 90.5}, {"王五", 16, 89.5}};

    write(fd, s, sizeof(s));

    // 关闭文件
    if (close(fd) == -1)
    {
        perror("close fd 1");
        return -1;
    }

    if ((fd = open("./file.txt", O_RDONLY, 0664)) == -1)
    {
        perror("open error");
        return -1;
    }

    printf("open success fd = %d\n", fd); // 3

    Stu temp;
    read(fd,&temp,sizeof(temp));

    printf("%s %d %.2lf\n",temp.name,temp.age,temp.score);

    return 0;
}

lseek

       #include <sys/types.h>
       #include <unistd.h>

       off_t lseek(int fd, off_t offset, int whence);
    功能：移动文件的光标
    参数1：文件描述符
    参数2：偏移量
            >0:向后偏移
            =0:不偏移
            <0:向前偏移
    参数3：偏移起始位置
            SEEK_SET:文件开头
            SEEK_END:文件结尾
            SEEK_CUR:文件当前位置
    返回值：成功返回文件光标当前的位置，失败返回-1并置位错误码

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //打开文件，以读写的形式
    int fd = -1;
    if((fd = open("./gg.bmp", O_RDWR)) == -1)
    {
        perror("open error");
        return -1;
    }

    //偏移光标
    lseek(fd, 2, SEEK_SET);

    //定义变量接受大小
    int img_size = 0;
    read(fd, &img_size, sizeof(img_size));
    printf("img_size = %d\n", img_size);

    //将光标直接偏移到文件末尾，返回值就是文件大小
    printf("size = %ld\n", lseek(fd, 0, SEEK_END));

    //关闭文件
    close(fd);

    return 0;
}

使用文件IO完成两个文件的拷贝

#include <myhead.h>
int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        // printf("终端输入有误\n");
        write(2,"input file error\n",sizeof("input file error\n"));
        return -1;
    }
    
    umask(0000);
    
    int fd = open(argv[1],O_RDONLY);
    int fb = open(argv[2],O_RDWR|O_CREAT|O_TRUNC,0664);

    char temp[128] = "";

    while (1)
    {
        int flag = read(fd,temp,sizeof(temp));
        if (flag == 0)
        {
            break;
        }
        
        write(fb,temp,flag);
    }
    
    //下面子规方法会拷贝多余的信息
    // while (read(fd,temp,sizeof(temp)))
    // {
    //     write(fb,temp,sizeof(temp));
    // }
    
    close(fd);
    close(fb);
    
    return 0;
}

文件描述符拷贝问题

拷贝用文件：

1、简单完成两个文件描述符变量的拷贝

        这种情况下，没有新文件描述符产生，使用的是同一个文件描述符，共享同一个文件光标

#include <myhead.h>
int main(int argc, char const *argv[])
{
    int fd1 = -1;
    if ((fd1 = open("./file2.txt",O_RDONLY)) == -1)
    {
        perror("open eroor");
        return -1;
    }

    //1、
    // int fd2 = fd1;  //定义变量存储文件描述符     
    //                 //未出现新的文件描述符fd1 fd2 公用光标

    //2、   
    // int fd2 = dup(fd1); //出现新的文件描述符  
    //                     //但仍然公用光标
    
    lseek(fd2,8,SEEK_SET);  //光标偏移

    char buf[128] = "";
    read(fd1,buf,5);
    printf("buf = %s\n",buf);  //1、buf = 55555   
                               //2、buf = 55555  

    close(fd1);
    return 0;
}

2、dup函数完成拷贝

        该操作，会生成新的文件描述符，但是与旧的文件描述符共享同一个光标

#include <myhead.h>
int main(int argc, char const *argv[])
{
    int fd1 = -1;
    if ((fd1 = open("./file2.txt",O_RDONLY)) == -1)
    {
        perror("open eroor");
        return -1;
    }

    //1、
    // int fd2 = fd1;  //定义变量存储文件描述符     
    //                 //未出现新的文件描述符fd1 fd2 公用光标

    //2、   
    // int fd2 = dup(fd1); //出现新的文件描述符  
    //                     //但仍然公用光标
    
    lseek(fd2,8,SEEK_SET);  //光标偏移

    char buf[128] = "";
    read(fd1,buf,5);
    printf("buf = %s\n",buf);  //1、buf = 55555   
                               //2、buf = 55555  

    close(fd1);
    return 0;
}

3、使用dup2拷贝文件描述符

       int dup2(int oldfd, int newfd);
    功能：拷贝旧文件描述符，放入新文件描述符中，如果新文件描述符之前已经打开，则在拷贝时，默认将其关闭
    参数1：旧文件描述符
    参数2：新文件描述符
    返回值：成功返回新文件描述符，失败返回-1并置位错误码

#include <myhead.h>
int main(int argc, char const *argv[])
{
    int fd2 = open("./04.c",O_RDONLY);

    int fd1 = open("./file2.txt",O_RDONLY);

    //使fd2指向fd1指向的文件，fd2原本指向的文件静默关闭
    dup2(fd1,fd2);  //不产生新的文件描述符
                    //共用光标
    printf("fd1= %d,fd2 = %d\n",fd1,fd2); //4  3
    
    lseek(fd2,8,SEEK_SET);

    char buf[128] = "";
    read(fd1,buf,5);
    printf("buf = %s\n",buf);  //buf = 55555
    
    close(fd1);
    close(fd2);
    return 0;
}

4、dup2的常规用法

#include <myhead.h>
int main(int argc, char const *argv[])
{
    int fd = -1;
    if ((fd = open("./aa.txt",O_WRONLY|O_CREAT|O_TRUNC)))
    {
        perror("open error");
        return -1;
    }
    
    //将标准输出重定向到fd中，标准输出静默关闭
    dup2(fd,STDOUT_FILENO);
    dup2(fd,STDIN_FILENO);//将标准输入重定向到fd中
    dup2(fd,STDERR_FILENO);//将标准出错重定向到fd中

    printf("hello\n");

    return 0;
}

5、多次使用open函数打开同一个文件时，这多个文件描述符是不共享文件光标的

#include <myhead.h>
int main(int argc, char const *argv[])
{
    int fd1 = -1;
    if ((fd1 = open("./file2.txt",O_RDONLY)))
    {
        perror("open error");
        return -1;
    }
    
    int fd2 = -1;
    if ((fd2 = open("./file2.txt",O_RDONLY)))
    {
        perror("open error");
        return -1;
    }

    lseek(fd1,8,SEEK_SET);  //移动fd1的光标

    char buf[10] = ""; //从读取fd2的指向读取数据
    read(fd2,,buf,5);

    printf("%s\n",buf); //  55555

    return 0;
}

文件属性函数

stat 函数原型 

       #include <sys/types.h>
       #include <sys/stat.h>
       #include <unistd.h>

       int stat(const char *pathname, struct stat *statbuf);
       功能：获取给定的文件状态属性
       参数1：要获取的文件名
       参数2：文件属性结构体指针，是一个地址传递，需要传递一个结构体变量的地址，通过函数调用结束后，该变量中就有内容了
       struct stat {
               dev_t     st_dev;         /* 设备号 */
               ino_t     st_ino;         /* Inode 号 */
               mode_t    st_mode;        /* 文件类型和文件权限 */
               nlink_t   st_nlink;       /* 硬链接数 */
               uid_t     st_uid;         /* 拥有者的用户id号 */
               gid_t     st_gid;         /* 拥有者的组id号 */
               dev_t     st_rdev;        /* 特殊文件的设备号 */
               off_t     st_size;        /* 总大小，以字节为单位 */
               blksize_t st_blksize;     /* 块的大小 */
               blkcnt_t  st_blocks;      /* 总块数 */

             
           };
        如何获取文件的类型和文件权限
        1>    使用st_mode & S_IFMT可以得到文件的类型
           S_IFSOCK   0140000   socket
           S_IFLNK    0120000   symbolic link
           S_IFREG    0100000   regular file
           S_IFBLK    0060000   block device
           S_IFDIR    0040000   directory
           S_IFCHR    0020000   character device
           S_IFIFO    0010000   FIFO
        2>    使用st_mode & 0777可以得到文件的权限
           S_ISUID     04000   set-user-ID bit
           S_ISGID     02000   set-group-ID bit (see below)
           S_ISVTX     01000   sticky bit (see below)

           S_IRWXU     00700   owner has read, write, and execute permission
           S_IRUSR     00400   owner has read permission
           S_IWUSR     00200   owner has write permission
           S_IXUSR     00100   owner has execute permission

           S_IRWXG     00070   group has read, write, and execute permission
           S_IRGRP     00040   group has read permission
           S_IWGRP     00020   group has write permission
           S_IXGRP     00010   group has execute permission

           S_IRWXO     00007   others (not in group) have read,  write,  and
                               execute permission
           S_IROTH     00004   others have read permission
           S_IWOTH     00002   others have write permission
           S_IXOTH     00001   others have execute permission
       
       返回值：成功返回0，失败返回-1并置位错误码

#include<myhead.h>

int main(int argc, const char *argv[])
{
    //判断外部传来的文件
    if(argc != 2)
    {
        printf("input file error\n");
        return -1;
    }

    //定义接受文件的属性结构体变量
    struct stat sb;                 //stat buf
    //调用函数，获取文件状态
    if(stat(argv[1], &sb) == -1)
    {
        perror("stat error");
        return -1;
    }

    //程序执行至此，sb中就记录了传入的文件的信息
    //输出文件类型
    switch(sb.st_mode & S_IFMT)
    {
    case S_IFSOCK:
        {
            printf("套接字文件\t");
        }
        break;
    case S_IFLNK:
        {
            printf("链接文件\t");
        }
        break;
    case S_IFREG:
        {
            printf("普通文件\t");
        }
        break;
    case S_IFBLK:
        {
            printf("块设备文件\t");
        }
        break;
    case S_IFDIR:
        {
            printf("目录文件\t");
        }
        break;
    case S_IFCHR:
        {
            printf("字符设备文件\t");
        }
        break;
    case S_IFIFO:
        {
            printf("管道文件\t");
        }
        break;
    }

    //输出文件权限
    printf("%#o\t", sb.st_mode&0777);
    //输出文件大小
    printf("%ld\t", sb.st_size);
    //输出文件inode号
    printf("%ld\n", sb.st_ino);

    return 0;
}

使用文件I0完成，将源文件中的所有内容进行加密(大写转小写、小写转大写)后写入目标文件中源文件内容不变

#include <myhead.h>
int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        // printf("终端输入有误\n");
        write(2, "input file error\n", sizeof("input file error\n"));
        return -1;
    }

    umask(0000);

    int fd = open(argv[1], O_RDONLY);
    int fb = open(argv[2], O_RDWR | O_CREAT | O_TRUNC, 0664);

    char temp = {0}; // 定义中转变量

    while (1)
    {
        int flag = read(fd, &temp, 1);
        if (flag == 0)
        {
            break;
        }
        if (temp >= 'A' && temp <= 'Z') // 大小转小写
        {
            temp = temp + 32;
        }
        else if (temp >= 'a' && temp <= 'z') // 小写转大写
        {
            temp = temp - 32;
        }

        write(fb, &temp, flag);
    }

    close(fd);
    close(fb);

    return 0;
}

结果

#INCLUDE <MYHEAD.H>
INT MAIN(INT ARGC, CHAR CONST *ARGV[])
{
    IF (ARGC != 3)
    {
        // PRINTF("终端输入有误\N");
        WRITE(2, "INPUT FILE ERROR\N", SIZEOF("INPUT FILE ERROR\N"));
        RETURN -1;
    }

    UMASK(0000);

    INT FD = OPEN(ARGV[1], o_rdonly);
    INT FB = OPEN(ARGV[2], o_rdwr | o_creat | o_trunc, 0664);

    CHAR TEMP = {0}; // 定义中转变量

    WHILE (1)
    {
        INT FLAG = READ(FD, &TEMP, 1);
        IF (FLAG == 0)
        {
            BREAK;
        }
        IF (TEMP >= 'a' && TEMP <= 'z') // 大小转小写
        {
            TEMP = TEMP + 32;
        }
        ELSE IF (TEMP >= 'A' && TEMP <= 'Z') // 小写转大写
        {
            TEMP = TEMP - 32;
        }

        WRITE(FB, &TEMP, FLAG);
    }

    CLOSE(FD);
    CLOSE(FB);

    RETURN 0;
}

 对文件夹的操作

opendir  打开文件夹

       #include <sys/types.h>
       #include <dirent.h>

       DIR *opendir(const char *name);
    功能：打开指定的文件夹
    参数：要打开的文件夹路径
    返回值：成功返回文件夹指针，失败返回NULL

#include <myhead.h>

int main(int argc, char const *argv[])
{
    //定义文件夹指针
    DIR * pd = opendir("./");
    if (NULL == pd)
    {
        perror("opendir");
        return -1;
    }

    //读取文件夹
    struct dirent* rp = NULL;  //读取文件目录信息

    while ((rp = readdir(pd)) != NULL)
    {
        printf("%-20s\t%#o\t%d\t%ld\n",rp->d_name,rp->d_type,rp->d_reclen,rp->d_ino);
    }//文件名  文件类型  结构体大小   inode号
    
    //关闭文件夹
    closedir(pd);
    
    return 0;
}

closedir   关闭文件夹

       #include <sys/types.h>

       #include <dirent.h>

       int closedir(DIR *dirp);
    功能：关闭指定的文件夹
    参数：之前打开的文件夹指针
    返回值：成功返回0，失败返回-1并置位错误码

readdir  读取文件夹信息

       #include <dirent.h>

       struct dirent *readdir(DIR *dirp);
    功能：读取打开的文件夹中的记录信息
    参数：文件夹指针
    返回值：成功返回当前文件夹指针对应的目录信息，失败返回NULL并置位错误码
     struct dirent {
               ino_t          d_ino;       /* Inode 号 */
               off_t          d_off;       /* 文件夹指针的偏移量*/
               unsigned short d_reclen;    /* 当前结构体的长度 */
               unsigned char  d_type;      /* 文件的类型，不支持所有的文件类型 */
               char           d_name[256]; /* 文件名称 */
           };
           关于文件类型：
             DT_BLK      This is a block device.

              DT_CHR      This is a character device.

              DT_DIR      This is a directory.

              DT_FIFO     This is a named pipe (FIFO).

              DT_LNK      This is a symbolic link.

              DT_REG      This is a regular file.

              DT_SOCK     This is a UNIX domain socket.

              DT_UNKNOWN  The file type could not be determined.

子座
关注
  • 28
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深度学习（基于Tensorflow2.0）学习笔记——Day2
01-20
本篇学习笔记主要关注如何在Tensorflow2.0环境下开始深度学习的学习和实践。 【深度学习基础知识回顾】 在开始实战前，对深度学习的基础知识进行回顾是必要的。这包括神经网络的基本概念、反向传播算法、损失函数...
深度学习（基于Tensorflow2.0）学习笔记——Day3
01-06
经过一番折腾，我们终于配置好了Tensorflow2.0的环境，接下来通过Tensorflow来一起揭开深度学习的神秘面纱吧。 实战Tensorflow分类器 首先我们打开我们昨天的Hello TF工程，进入编辑界面之后，依次点击Kernel -> ...
深度学习（基于Tensorflow2.0）学习笔记——Day4
01-07
这也就引出了我们接下来学习的内容： 数据归一化处理 回调函数的作用 数据归一化处理 归一化大家都不陌生，简单的理解，它的作用就是把你需要用到的数据经过处理后（通过某种算法）将其限制在你所规定的范围内。那么...
Oracle学习笔记——day01
09-02
此外，我们还学习了日期函数如`SYSDATE`，用于获取当前系统日期，以及如何使用`NULL`表示未知或无值的记录。在处理多条件查询时，了解逻辑运算符的优先级和正确使用括号是非常重要的。 在深入学习Oracle数据库时，...
Oracle学习笔记——day04
09-02
在Oracle学习笔记的第四天，我们探讨了数据库管理和操作的一些核心概念，主要集中在DDL（数据定义语言）、DML（数据操作语言）、DCL（数据控制语言）以及事务管理。以下是对这些内容的详细阐述： 首先，我们看到了...
从根儿上学习spring 九 之run方法启动第四段(3)
baidu_19338587的博客
08-04 593
一般情况下调用doGetBean方法获取的bean实例都是为了真实使用的，像我们上面举得A，B对象的例子获取的A，B对象当然都是为了真实使用的，但有种场景就只是为了做类型检查，比如有时候为了判断FactoryBean里的对象的类型就要先获取FactoryBean再通过getObject方法获取里面的真实对象来判断其类型，这时获取的FactoryBean实例可能就只是为了类型检查并不是为了真实使用。二:当bean是多例时，会有不同的创建bean的逻辑，下面我们按照代码顺序先分析单例的情况。
学习日志7.29--QOS（Quality of Service）服务质量
m0_62560069的博客
07-29 305
命令：[R1-GigabitEthernet0/0/2]qos car outbound cir 20，在接口2限制，qos限速car传出速率(outbound)，速率分为传出速率和传入速率，对于这个拓扑就是传出速率，单位为20kbps。再在PC机上做发包设置，目的地址是2.2.2.2，源地址是1.1.1.1，端口号在范围允许内随便写但是要保持一致，周期发送时间间隔为10ms，一秒就可以发送100次配置好后，发送。我们日常生活中办理的是宽带，在网络速率上我们要求的是带宽，指传输的速率，比如50Mbps。
从根儿上学习spring 五 之run方法启动第二段
baidu_19338587的博客
08-04 533
讲完了PropertySources和PropertySource，我们再回头看图6的方法configurePropertySources方法似乎变得很简单没必要一行行分析了吧，这个方法就是向environment的sources属性里加入启动时的两个PropertySource，有不清楚的同学再结合我上面说的对着代码看两遍就清楚了，我就不再赘述了。Environment接口继承了PropertyResolver接口，PropertyResolver接口主要提供了获取配置属性的方法，如图3所示。
从根儿上学习spring 三 之依赖注入原理了解
baidu_19338587的博客
08-04 309
举个例子，你为公司所有业务部门写了一个针对一些中间件优雅下线的通用功能，可你不确定后面公司业务部门会不会后面引入其它的中间件，所以你定义了一个接口GraceDownInteface，接口里定义一个下线方法，规定所有实现了该接口的方法在服务挂掉前都会被自动执行。前面的beanFactory和bean分别代表需要扩展的对象，BeanFactory是spring的 bean容器，bean就是spring创建的bean实例。针对上面的步骤我们都可以对其做扩展处理，并且可以在每步的前后都可以做扩展处理。
机械学习—零基础学习日志（高数18——无穷小与无穷大）
AI_freshfish的博客
08-01 630
这里可以记住，无穷小有一个特殊，那就是零。零是最高阶的无穷小，且零是唯一一个常数无穷小。张宇老师还是使用了超实数概念来讲解无穷小。其实是利于理解的，但希望大家接触新概念过程不要太抗拒。数学概念理解，其实可以借用生活概念。张宇老师这里把1除以无穷小，理解成把1分为若干个无穷小。所以得到的就是无穷大。1除以超实数所以得到超实数的结果。
【C++】构造函数的深入学习
weixin_60546365的博客
07-30 484
所有对象共享同一份数据 -- 你改了别人用的就是改过的数据。类中声明，类外初始化 -- 必须要有一个初始值否则没法用。所有对象共享同一个函数，类外访问不到私有静态函数。静态成员函数只能访问静态成员变量。静态成员变量访问权限：在Private作用域下访问，出了这个类不可以访问。分配内存 -- 生成了exe程序，还没有双击运行之前已经分配在全局区中。语法：构造函数（）：属性1（值1），属性2（值2）...{ }先构造A再构造B，先析构B再析构A（先进后出LIFO）C++提供初始化列表语法用来初始化属性。
编程的魅力、发展历程、核心要素、学习路径以及它对个人成长和社会进步的深远影响
z86666610的博客
08-02 501
进入21世纪，随着互联网的普及和移动设备的兴起，编程语言更加多样化，如Python、JavaScript等，它们以其简洁易学的特点吸引了大量初学者。同时，人工智能、大数据、云计算等新兴技术的快速发展，更是将编程推向了新的高度，使得编程成为推动社会进步的重要力量。编程的魅力，在于它让我们能够将自己的想法直接转化为现实，体验到从无到有的创造过程。本文将深入探讨编程的魅力、发展历程、核心要素、学习路径以及它对个人成长和社会进步的深远影响，旨在为读者勾勒出一幅全面而生动的编程世界图景。
系统化学习 H264视频编码（05）码流数据及相关概念解读
最新发布
wangdsh的博客
08-04 739
针对本文，我们主要研究 H.264码流数据结构及相关概念。包括VCL层(Video Coding Layer,视频数据编码层)及其相关概念宏块、片等，NAL层(Network Abstraction Layer,视频数据网络抽象层)及其相关概念SODB、RBSP、EBSP和NALU等；NALU详细信息解读以及Annex格式和RTP格式解读。
大模型学习笔记 - InstructGPT中的微调与对齐
m0_37531129的博客
08-04 698
LLM 我们不一定要预训练模型，但是一定要会微调。InstructGPT更是微调的最经典的文章。这里详细介绍InstructGPT的微调技术。
大模型学习笔记 - 大纲
m0_37531129的博客
08-04 179
TO BE ADDEDTO BE ADDEDTO BE ADDEDTO BE ADDEDTO BE ADDED
学习大数据DAY30 python基础语法3
shh2000424的博客
08-02 905
上机练习5的作业我昨天就写完了，但是因为它是今天的作业，我就今天发咯。按行作为分隔符条件，返回所有行组成的列表（每行内容是一个元素）今天写的代码比较多，但是整理一下思路还是不难写的。检测到一个错误时，解释器就无法继续执行（程序。了，反而出现了一些错误提示，这就是所谓的异常。方法将任何字符串写入打开的文件，换行符。方法则是读取所有行，一次性全部读出，取款机程序重新执行数据没有保存。文件以字典的形式存储在列表里。语句抛出一个指定的异常。
C++ 学习(2) ---- std::cout 格式化输出
小猪佩奇的博客
08-04 527
C++ 通常使用cout输出数据，和printf()函数相比，cout实现格式化输出数据的方式更加多样化；一方面，cout 作为ostream类的对象，该类中提供有一些成员方法，可实现对输出数据的格式化；另一方面，为了方面用户格式化输出数据，C++ 标准库专门提供了一个 <iomanip> 头文件，该头文件中包含有大量的格式控制符，也就是流操作算子，使用上更加方便；
从根儿上学习spring 四 之run方法启动第一段
baidu_19338587的博客
08-04 460
由上图可以看到在getSpringFactoriesInstances方法里先获取了类加载器，然后使用SpringFactoriesLoader.loadFactoryNames(type, classLoader)方法是获取所有META-INF/spring.factories资源文件里的数据，META-INF/spring.factories文件里的内容大概是xxx=yyyy的形式，而这里的xxx就是type.getname()的值，yyyy就是获取到的names集合里的每个string值。
(leetcode学习)46. 全排列
m0_54888411的博客
08-04 106
最多就6个数排列，可以考虑打表；给定一个不含重复数字的数组。dfs就完事了，慢是慢了点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值