美文网首页
系统编程-文件操作2

系统编程-文件操作2

作者: 帅碧 | 来源:发表于2016-12-01 16:23 被阅读0次
  • 作业
  • 文件的拷贝
#include <stdio.h>
#include <unistd.h>  //write()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define PER_IO_BYTES 4096
int myOpen(const char *pathname,mode_t mode)
{
    int fd  = -1;
    if (NULL != pathname)
    {
        fd = open(pathname, mode | O_CREAT
                  , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (-1 == fd)
        {
            printf("open error: %s\n", strerror(errno));
        }
    }
    return fd;
}
int main(int argc,char *argv[])
{
    int fdForRead=-1;
    fdForRead=myOpen(argv[1],O_RDONLY);
    if(-1==fdForRead)
    {
        return -1;
    }
    int fdForWrite=-1;
    fdForWrite=myOpen(argv[2],O_WRONLY);
    if(-1==fdForWrite)
    {
        close(fdForRead);
        return -1;  
    }
    unsigned char caBuf[PER_IO_BYTES]={'\0'};
    int ret=0;
    while(1)
    {
        memset(caBuf,'\0',PER_IO_BYTES);
        ret =read(fdForRead,caBuf,PER_IO_BYTES);
        if(-1==ret)
        {
            printf("read error:%s\n",strerror(errno));
            return -1;
        }
        else if(0==ret)
        {
            printf("copy file success\n");
            break;
        }
        else
        {
            printf("read %d bytes from %s\n",ret,argv[1]);
            ret=write(fdForWrite,caBuf,ret);
            if(-1==ret)
            {
                printf("write error:%s\n",strerror(errno));
                return -1;
            }
            printf("write %d bytes from %s\n",ret,argv[2]);
        }
                
        
    }
    return 0;
}
  • readFromSTDIN

#include <stdio.h>
#include <errno.h>  //errno  
#include <string.h>  //strerror()
#include <unistd.h>  //read()  write()
/*open*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#if 0
//头文件: /usr/include/unistd.h
/* Standard file descriptors.  */
#define STDIN_FILENO    0   /* Standard input.  */
#define STDOUT_FILENO   1   /* Standard output.  */
#define STDERR_FILENO   2   /* Standard error output.  */
#endif
//默认打开的三个文件：
//标准输入， 标准输出，标准错误输出
//标准输入：0 -- STDIN_FILENO
//标准输出：1 -- STDOUT_FILENO
//标准错误输出：2  -- STDERR_FILENO


int main(int argc, char *argv[])
{
    char caBuf[32] = {'\0'};
    //read:默认阻塞读终端，
    //     即若标准输入没有数据可读，则阻塞直到有数据到来
    //     阻塞即为等待数据的输入
    //     可以结合scanf()函数来理解
    int ret = read(STDIN_FILENO, caBuf, sizeof(caBuf));
    if (-1 == ret)
    {
        printf("read error:%s\n", strerror(errno));
    }   
    else
    {
        if (caBuf[31] != '\0')
        {
            caBuf[31] = '\0';
        }
        printf("%s\n", caBuf);
    }

    return 0;
}
  • readFromSTDIN_NoBlock
#include <stdio.h>
#include <errno.h>  //errno  
#include <string.h>  //strerror()
#include <unistd.h>  //read()  write()
/*open*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
//头文件:/usr/include/unistd.h
//默认打开的三个文件:
//标准输入,标准输出,标准错误输入
//标准输入:0---STDIN_FILENO
//标准输出:1---STDOUT_FILENO
//标准错误输入:2---STDERR_FILENO
int main(int argc, char *argv[])
{
    int fd=-1;
    fd=open("/dev/tty",O_RDWR | O_NONBLOCK);
    printf("fd=%d\n",fd);

    char caBuf[32]={'\0'};
    int ret=-1;
    //read:默认阻塞读终端
    //即若标准输入没有数据刻度,则阻塞直到有数据到来
    //阻塞即为等待数据的输入
    //可以结合scanf函数来理解
    while(1)
    {
        memset(caBuf,'\0',sizeof(caBuf));
        ret=read(fd,caBuf,sizeof(caBuf));
        if(-1==ret)
        {
            //EAGAIN:当设置非阻塞时,若没有数据可读,则出错
            //设置errno值为EAGAIN
            if(EAGAIN!=errno)
            {
            //  printf("errno=%d,%d\n",errno,EAGAIN);
                printf("read error:%s\n",strerror(errno));
                break;
            }
            printf("no data for reading\n");
            sleep(1);
            continue;
        }
        else
        {
            if(caBuf[31]!='\0')
            {
                caBuf[31]='\0';
            }
            printf("%s\n",caBuf);
        }
    }
    return 0;
}

eintr


#include <stdio.h>
#include <unistd.h>  //write()  read() sleep()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


int myOpen(const char *pathname)
{
    int fd  = -1;
    if (NULL != pathname)
    {
        fd = open(pathname, O_RDONLY | O_CREAT
                  , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (-1 == fd)
        {
            printf("open error: %s\n", strerror(errno));
        }
    }
    return fd;
}
int myRead(int fd, char *pData, int iTotalSize)
{
    //对形参的值进行有效性检查
    if (-1 != fd && NULL != pData && iTotalSize > 0)
    {
        int iLeft = iTotalSize;
        int iReaded = 0;
        int ret = -1;
        while (ret=read(fd,pData+iReaded,iLeft) && iLeft)
        {
            if (-1==ret)
            {
                //EINTR:当将要进行io操作时,被信号打断
                //则io操作失败,则将errno值设置为EINTR
                //这种情况下可以重新进行io操作
                if(EINTR==errno||EAGAIN ==errno)
                {
                    continue;
                }
                printf("read errno:%s\n",strerror(errno));
                break;
            }
            iLeft -= ret;
            iReaded += ret;
        }
    }
}
int main(void)
{
    int fd = -1;
    fd = myOpen("test.data");
    if (-1 != fd)
    {
        char caBuf[1000100] = {'\0'};
        myRead(fd, caBuf, sizeof(caBuf));
        close(fd);
    }   

    return 0;
}
  • 学生结构体,写入6个学生信息,打印1,3,6位同学
  • write.c

#include <stdio.h>
#include <unistd.h>  //write()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define NAME_LEN 32
typedef struct Student
{
    int iId;
    char caName[NAME_LEN];
    char cSex;
    float fScore;

}Student;

int myOpen(const char *pathname)
{
    int fd  = -1;
    if (NULL != pathname)
    {
        fd = open(pathname, O_WRONLY | O_CREAT | O_TRUNC
                  , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (-1 == fd)
        {
            printf("open error: %s\n", strerror(errno));
        }
    }
    return fd;
}

int main(void)
{
    int fd = -1;
    fd = myOpen("stu.info");
    if (-1 != fd)
    {
        Student stu[6] = {
                           {1001, "zhangsan", 'f', 99},
                           {1002, "lisi", 'm', 79},
                           {1003, "wangwu", 'f', 89},
                           {1004,"damazi",'f',69},
                           {1005,"xiaofang",'m',98},
                           {1006,"xiaoming",'f',88}
                         };
        int ret = -1;
        int i = 0;
        for (; i < 6; i++)
        {
            ret = write(fd, stu+i, sizeof(Student));
            if (-1 == ret)
            {
                printf("write error: %s\n", strerror(errno));
            }
            else
            {
                printf("write %d bytes to file\n", ret);
            }
        }
    }   

    return 0;
}
  • read1.c

#include <stdio.h>
#include <unistd.h>  //write()  read()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define NAME_LEN 32
typedef struct Student
{
    int iId;
    char caName[NAME_LEN];
    char cSex;
    float fScore;

}Student;

int myOpen(const char *pathname)
{
    int fd  = -1;
    if (NULL != pathname)
    {
        fd = open(pathname, O_RDONLY | O_CREAT
                  , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (-1 == fd)
        {
            printf("open error: %s\n", strerror(errno));
        }
    }
    return fd;
}

int main(void)
{
    int fd = -1;
    fd = myOpen("stu.info");
    if (-1 != fd)
    {
        int ret = -1;
        int i=0;
        Student stu;
            //将Student对象的空间都设置为'\0'
            memset(&stu, '\0', sizeof(Student));
            ret = read(fd, &stu, sizeof(Student));
            if(-1!=ret)
            {
                
                printf("id:%d, name:%s, sex:%c, score:%.1f\n"
                   , stu.iId, stu.caName
                   , stu.cSex, stu.fScore);
            }
            off_t offset=lseek(fd,2*sizeof(Student),SEEK_SET);
            if (-1!=offset)
            {   
                memset(&stu, '\0', sizeof(Student));        
                ret = read(fd, &stu, sizeof(Student));
                if(-1!=ret)
                {
                    printf("id:%d, name:%s, sex:%c, score:%.1f\n"
                       , stu.iId, stu.caName
                       , stu.cSex, stu.fScore);
                }
            }
            offset=lseek(fd,5*sizeof(Student),SEEK_SET);
            if (-1!=offset)
            {   
                memset(&stu, '\0', sizeof(Student));        
                ret = read(fd, &stu, sizeof(Student));
                if(-1!=ret)
                {
                    printf("id:%d, name:%s, sex:%c, score:%.1f\n"
                       , stu.iId, stu.caName
                       , stu.cSex, stu.fScore);
                }
            }
        close(fd);
    }   

    return 0;
}
  • read2.c(第2种方法)
#include <stdio.h>
#include <unistd.h>  //write()  read()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define NAME_LEN 32
typedef struct Student
{
    int iId;
    char caName[NAME_LEN];
    char cSex;
    float fScore;

}Student;

int myOpen(const char *pathname)
{
    int fd  = -1;
    if (NULL != pathname)
    {
        fd = open(pathname, O_RDONLY | O_CREAT
                  , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (-1 == fd)
        {
            printf("open error: %s\n", strerror(errno));
        }
    }
    return fd;
}

int main(void)
{
    int fd = -1;
    fd = myOpen("stu.info");
    if (-1 != fd)
    {
        int ret = -1;
        int i=0;
        Student stu;
        while(1)
        {
            //将Student对象的空间都设置为'\0'
            memset(&stu, '\0', sizeof(Student));
            ret = read(fd, &stu, sizeof(Student));
            if(-1!=ret)
            {
                
                printf("id:%d, name:%s, sex:%c, score:%.1f\n"
                   , stu.iId, stu.caName
                   , stu.cSex, stu.fScore);
            }
            off_t offset=lseek(fd,sizeof(stu),SEEK_CUR);
            if (-1!=offset)
            {   
                memset(&stu, '\0', sizeof(Student));        
                ret = read(fd, &stu, sizeof(Student));
                if(-1!=ret)
                {
                    printf("id:%d, name:%s, sex:%c, score:%.1f\n"
                       , stu.iId, stu.caName
                       , stu.cSex, stu.fScore);
                }
            }
            offset=lseek(fd,2*sizeof(stu),SEEK_CUR);
            if (-1!=offset)
            {   
                memset(&stu, '\0', sizeof(Student));        
                ret = read(fd, &stu, sizeof(Student));
                if(-1!=ret)
                {
                    printf("id:%d, name:%s, sex:%c, score:%.1f\n"
                       , stu.iId, stu.caName
                       , stu.cSex, stu.fScore);
                }
            }
            break;
        }
        close(fd);
    }   

    return 0;
}
  • 计算文件的大小
#include <stdio.h>
#include <unistd.h>  //write()  read() sleep()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc,char *argv[])
{
    int fd=-1;
    fd=open(argv[1],O_RDWR | O_CREAT,S_IRUSR | S_IWUSR | S_IRGRP);
    if(-1 == fd)
    {
        printf("open error:%s\n",strerror(errno));
        return -1;
    }
    //偏移参照位置
    //文件首部,当前位置,文件尾
    //返回值为距离文件首的偏移量
    //第一个参数:文件描述符
    //第二个参数:相对参照位置的偏移量
    //      当偏移为正数时,往参照位置后偏移
    //      当偏移为负数时,往参照位置前偏移
    //第三个参数:参照位置SEEK_SET
    //第三个参数:参照位置
    off_t offset = lseek(fd,0,SEEK_END);//返回值为距离文件头的偏移量
    if(-1==offset)
    {
        printf("lseek error:%s\n",strerror(errno));
    }
    else
    {
        printf("file size:%ld\n",offset);
    }
    return 0;
}
//./a.out test.data
//1234567890abcdefghijklmn
//file size=25
  • 将文件的某个位置上的插入数据(覆盖)
#include <stdio.h>
#include <unistd.h>  //write()  read() sleep()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc,char *argv[])
{
    int fd=-1;
    //当打开一个文件时,读写位置默认在文件首部
    fd=open(argv[1],O_RDWR | O_CREAT,S_IRUSR | S_IWUSR | S_IRGRP);
    if(-1 == fd)
    {
        printf("open error:%s\n",strerror(errno));
        return -1;
    }
    //偏移参照位置
    //文件首部,当前位置,文件尾
    //返回值为距离文件首的偏移量
    //第一个参数:文件描述符
    //第二个参数:相对参照位置的偏移量
    //      当偏移为正数时,往参照位置后偏移
    //      当偏移为负数时,往参照位置前偏移
    //第三个参数:参照位置SEEK_SET
    //第三个参数:参照位置
    off_t offset = lseek(fd,0,SEEK_END);//返回值为距离文件头的偏移量
    if(-1==offset)
    {
        printf("lseek error:%s\n",strerror(errno));
    }
    else
    {
        printf("file size:%ld\n",offset);
    }
    //将读写位置偏移到
    offset=lseek(fd,10,SEEK_SET);
    printf("offset=%ld\n",offset);
    char *iData="888";
    write(fd,iData,strlen(iData));
    close(fd);
    return 0;
}
//./a.out test.data
//原来的为:1234567890abcdefghijklmn
//1234567890888defghijklmn



#include <stdio.h>
#include <unistd.h>  //write()  read() sleep()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc,char *argv[])
{
    int fd=-1;
    //当打开一个文件时,读写位置默认在文件首部
    fd=open(argv[1],O_RDWR | O_CREAT,S_IRUSR | S_IWUSR | S_IRGRP);
    if(-1 == fd)
    {
        printf("open error:%s\n",strerror(errno));
        return -1;
    }
    //偏移参照位置
    //文件首部,当前位置,文件尾
    //返回值为距离文件首的偏移量
    //第一个参数:文件描述符
    //第二个参数:相对参照位置的偏移量
    //      当偏移为正数时,往参照位置后偏移
    //      当偏移为负数时,往参照位置前偏移
    //第三个参数:参照位置SEEK_SET
    //第三个参数:参照位置
    off_t offset = lseek(fd,0,SEEK_END);//返回值为距离文件头的偏移量
    if(-1==offset)
    {
        printf("lseek error:%s\n",strerror(errno));
    }
    else
    {
        printf("file size:%ld\n",offset);
    }
    //将读写位置偏移到第10位,输入888,将abc替换成了888
    offset=lseek(fd,10,SEEK_SET);
    printf("offset=%ld\n",offset);
    char *iData="888";
    write(fd,iData,strlen(iData));
    //往后5个位置插入666,将678替换为666
    lseek(fd,5,SEEK_SET);
    write(fd,"666",3);
    close(fd);
    return 0;
}
// ./a.out test.data
//原来的为:1234567890abcdefghijklmn
//1234566690888defghijklmn
  • 在一个文件插入数据,已追加的方式插入
#include <stdio.h>
#include <unistd.h>  //write()  read() sleep()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define PER_IO_BYTES 4096

int myOpen(const char *pathname)
{
    int fd  = -1;
    if (NULL != pathname)
    {

        fd = open(pathname, O_WRONLY | O_CREAT | O_APPEND
                  , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (-1 == fd)
        {
            printf("open error: %s\n", strerror(errno));
        }
    }
    return fd;
}

int main(void)
{
    int fd=-1;
    fd=myOpen("test.data");
    char caBuf[10]="helloworld";
    int ret=write(fd,caBuf,sizeof(caBuf));
    if(ret==-1)
    {
        printf("write error:%s\n",strerror(errno)); 
    }
    else
    {
        printf("write %d bytes to file\n",ret);
    }
    close(fd);
}

//helloworldhelloworldhelloworld

pwrite

#include <stdio.h>
#include <unistd.h>  //write()  read() sleep()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc,char *argv[])
{
    int fd=-1;
    //当打开一个文件时,读写位置默认在文件首部
    fd=open(argv[1],O_RDWR | O_CREAT,S_IRUSR | S_IWUSR | S_IRGRP);
    if(-1 == fd)
    {
        printf("open error:%s\n",strerror(errno));
        return -1;
    }
    //偏移参照位置
    //文件首部,当前位置,文件尾
    //返回值为距离文件首的偏移量
    //第一个参数:文件描述符
    //第二个参数:相对参照位置的偏移量
    //      当偏移为正数时,往参照位置后偏移
    //      当偏移为负数时,往参照位置前偏移
    //第三个参数:参照位置SEEK_SET
    //第三个参数:参照位置
    off_t offset = lseek(fd,0,SEEK_END);//返回值为距离文件头的偏移量
    if(-1==offset)
    {
        printf("lseek error:%s\n",strerror(errno));
    }
    else
    {
        printf("file size:%ld\n",offset);
    }
    //档一个程序存在多个运行分支的时候,并且每个运行分支都有可能操作文件时存在以下问题:
    //当A分支使用lseek设置读写位置完成时,
    //A分支的运行暂停,B分支开始运行,并且B分支对文件进行了读写操作,从而改变了A分支设置的读写位置
    //当B分支运行暂停.A分支重新接着往后运行时,若A分支要对文件进行读写,那么读写的位置并不是之前设置的位置,而是B分支运行后的读写位置,从而得不到预期结果
    
    //原子操作：操作部分，要么都执行，要么都不执行
    //问题解决方案:将A分支的的lseek和之后的读写操作合成原子操作
    // 1.将操作部分使用锁，锁住，合成原子操作
    // 2．调用pread()或者pwrite()函数来完成操作
    /*lseek(fd,-5,SEEK_END);
    write(fd,"666",3);*/
    char *pData="Hello World";
    ssize_t size=pwrite(fd,pData,strlen(pData),5);
    if(-1==size)
    {
        printf("pwrite error:%s\n",strerror(errno));
    }
    close(fd);
    return 0;
}
//原来为:1234567890
//现在为:12345Hello World

fsync

#include <stdio.h>
#include <unistd.h>  //write()  read() sleep()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
/*sync()
syncfs()
fsync()

*/
int myOpen(const char *pathname)
{
    int fd  = -1;
    if (NULL != pathname)
    {
        fd = open(pathname, O_WRONLY | O_CREAT
                  , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
        if (-1 == fd)
        {
            printf("open error: %s\n", strerror(errno));
        }
    }
    return fd;
}
int main()
{
    int fd = -1;
    fd = myOpen("test.data");
    if (-1 != fd)
    {
        char *pData="Hello World";
        write(fd, pData, strlen(pData));
        //将缓冲区的
        int ret=fsync(fd);
        if(-1==ret)
        {
            printf("fsync error:%s\n",strerror(errno));
        }
        close(fd);
    }   
    return 0;
}
//Hello World

pread

#include <stdio.h>
#include <unistd.h>  //write()  read() sleep()
#include <errno.h>   //errno
#include <string.h>  //strerror()
/*open()*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc,char *argv[])
{
    int fd=-1;
    //当打开一个文件时,读写位置默认在文件首部
    fd=open(argv[1],O_RDWR | O_CREAT,S_IRUSR | S_IWUSR | S_IRGRP);
    if(-1 == fd)
    {
        printf("open error:%s\n",strerror(errno));
        return -1;
    }
    //偏移参照位置
    //文件首部,当前位置,文件尾
    //返回值为距离文件首的偏移量
    //第一个参数:文件描述符
    //第二个参数:相对参照位置的偏移量
    //      当偏移为正数时,往参照位置后偏移
    //      当偏移为负数时,往参照位置前偏移
    //第三个参数:参照位置SEEK_SET
    //第三个参数:参照位置
    off_t offset = lseek(fd,0,SEEK_END);//返回值为距离文件头的偏移量
    if(-1==offset)
    {
        printf("lseek error:%s\n",strerror(errno));
    }
    else
    {
        printf("file size:%ld\n",offset);
    }
    //档一个程序存在多个运行分支的时候,并且每个运行分支都有可能操作文件时存在以下问题:
    //当A分支使用lseek设置读写位置完成时,
    //A分支的运行暂停,B分支开始运行,并且B分支对文件进行了读写操作,从而改变了A分支设置的读写位置
    //当B分支运行暂停.A分支重新接着往后运行时,若A分支要对文件进行读写,那么读写的位置并不是之前设置的位置,而是B分支运行后的读写位置,从而得不到预期结果
    
    //原子操作：操作部分，要么都执行，要么都不执行
    //问题解决方案:将A分支的的lseek和之后的读写操作合成原子操作
    // 方法1.将操作部分使用锁，锁住，合成原子操作
    // 方法2．调用pread()或者pwrite()函数来完成操作

    //pread()/pwrite():偏移到距离文件首部ｎ字节的地方进行读写操作

    char *pData="Hello World";
    //第四个参数：从文件首部开始的偏移量
    //第三个参数：要写入的字节数
    ssize_t size=pwrite(fd,pData,strlen(pData),5);
    if(-1==size)
    {
        printf("pwrite error:%s\n",strerror(errno));
    }
    char caBuf[32]={'\0'};
    size=pread(fd,caBuf,3,3);
    if(-1!=size)
    {
        printf("%s\n",caBuf);
    }
    close(fd);
    return 0;
}
//12345Hello World

相关文章

  • 系统编程-文件操作2

    作业 文件的拷贝 readFromSTDIN readFromSTDIN_NoBlock eintr 学生结构体,...

  • 进程线程-导读

    一：引出 进程线程与文件IO一起，一般也叫做系统编程，系统编程，顾名思义，就是与操作系统有关系的编程，那么系统编程...

  • 系统编程-文件操作

    系统调用 系统调用主要进行进程控制(系统调用是系统提供用户的一个接口) flag:O_RDONLY,O_WRONL...

  • 系统编程-------文件操作

    文件的操作 1、文件打开 使用open函数打开和创建函数 参数： pathname 待打开文件路径fla...

  • Python 学习笔记6 2018-04-13

    文件操作： 1，文件的读写操作 2，文件的各种系统操作 3，存储对象 1，文件的读写操作 读写数据： ...

  • 2018-02-11 mac 系统的中常见命令行教程

    mac 系统的中常见命令行教程 目录操作 文件操作 选择操作 安全操作 编程操作 进程操作 时间操作 网络与通信操...

  • Linux运维之道(14)——Linux文件系统管理

    @(Linux)[文件系统管理] 1. 文件系统 1.1 各个操作系统上的文件系统 Linux文件系统 ext2 ...

  • （五）Python File(文件)

    前言：文件系统是操作系统的重要组成部分，它规定了计算机对文件和目录进行操作处理的各种标准和机制。以此为基础，编程语...

  • 系统编程-文件操作3

    作业:在文件任意位置处插入数据 ACCESS(测试) 测试文件是否存在 测试文件是否有可读可写权限 测试文件是否有...

  • 系统编程-文件操作4

    exec(鸠占鹊巢) 查找文件:fins /usr execl 模拟一个终端,可以同时打开两个文件 模拟一个终端 ...

网友评论

      本文标题：系统编程-文件操作2

      本文链接：https://www.haomeiwen.com/subject/fsnxmttx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|系统编程-文件操作2|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！