Linux系統編程:簡單文件IO操作

使用Linux的文件API，經常看見一個東西，叫做文件描述符.

什么是文件描述符?

(1)文件描述符其實實質是一個數字，這個數字在一個進程中表示一個特定的含義，當我們open打開一個文件時，操作系統在內存中構建了一些數據結構來表示這個動態文件，然后返回給應用程序一個數字作為文件描述符，這個數字就和我們內存中維護這個動態文件的這些數據結構掛鈎綁定上了，以后我們應用程序如果要操作這一個動態文件，只需要用這個文件描述符進行區分。

(2)文件描述符就是用來區分一個程序打開的多個文件的。

(3)文件描述符的作用域就是當前進程，出了當前進程這個文件描述符就沒有意義了

(4)文件描述符fd的合法范圍是0或者一個正數，不可能是一個負數

(5)open返回的fd必須記錄好，以后向這個文件的所有操作都要靠這個fd去對應這個文件，最后關閉文件時也需要fd去指定關閉這個文件。如果在我們關閉文件前fd丟了，那么這個文件就沒法關閉了也沒法讀寫了

1）打開與讀取文件

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

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

    int fd = -1; //文件描述符

    //打開文件
    fd = open( "ghostwu.txt", O_RDWR );

    if ( -1 == fd ) {
        printf("文件打開失敗\n");
    }else {
        printf("文件打開成功，fd=%d\n", fd );
    }

    //讀取文件
    int count = 0;
    char buf[20];
    count = read( fd, buf, 50 );
    if ( -1 == count ) {
        printf("文件讀取失敗\n");
    }else {
        printf("文件讀取成功，實際讀取的字節數目為:%d\n內容為%s\n", count, buf );
    }

    //關閉文件
    close( fd );

    return 0;
}

需要在當前目錄下存在ghostwu.txt這個文件，否則打開的時候失敗，這里涉及2個api

int open(const char *pathname, int flags);

open非常簡單，第一個參數就是文件路徑， 第二個是文件模式，在man手冊中還提供了其他幾種方式。

ssize_t read(int fd, void *buf, size_t count);

第一個參數為文件描述符，就是open返回的那個值

第二個參數buf用來存儲從文件中讀取的內容

第三個參數，表示希望從文件中讀取的內容( 注：這個count數字可以隨便給，最終以返回的實際數目(read的返回值)為准

2)打開與寫入文件

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

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

    int fd = -1; //文件描述符

    //打開文件
    fd = open( "ghostwu.txt", O_RDWR );

    if ( -1 == fd ) {
        printf("文件打開失敗\n");
    }else {
        printf("文件打開成功，fd=%d\n", fd );
    }

    //寫文件
    char buf[] = "I love Linux, Linux is very very good!!!";
    int count = 0;
    count = write( fd, buf, strlen( buf ) );
    if ( -1 == count ) {
        printf("文件寫入失敗\n");
    }else {
        printf("文件寫入成功，實際寫入的字節數目為:%d\n", count);
    }

    //關閉文件
    close( fd );

    return 0;
}

ssize_t write(int fd, const void *buf, size_t count);

第一個參數為文件描述符，就是open返回的那個值

第二個參數buf用來存儲寫入的內容

第三個參數，表示希望寫入的文件大小

3)open的一些flag參數

1,只讀與只寫權限

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

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

    int fd = -1; //文件描述符

    //打開文件, O_RDONLY:只讀權限，打開之后的文件只能讀取，不能寫入
    //打開文件, O_WRONLY:只寫權限，打開之后的文件只能寫入，不能讀取
    // fd = open( "ghostwu.txt", O_RDONLY );
    fd = open( "ghostwu.txt", O_WRONLY );

    if ( -1 == fd ) {
        printf("文件打開失敗\n");
    }else {
        printf("文件打開成功，fd=%d\n", fd );
    }

    //讀取文件
    int count = 0;
    char buf[41];
    count = read( fd, buf, 38 );
    if ( -1 == count ) {
        printf("文件讀取失敗\n");
    }else {
        printf("文件讀取成功，實際讀取的字節數目為:%d\n內容為%s\n", count, buf );
    }

    //關閉文件
    close( fd );

    return 0;
}

2,清空與追加

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

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

    int fd = -1; //文件描述符

    //打開文件
    //在O_RDWR模式下，對於一個已經存在的文件，且有內容，那么寫入文件會覆蓋對應大小的源文件內容【不是完全覆蓋】
    // fd = open( "ghostwu.txt", O_RDWR );
    //在具有寫入權限的文件中，使用O_TRUNC　會先把原來的內容清除，再寫入新的內容
    // fd = open( "ghostwu.txt", O_RDWR | O_TRUNC );
    //在具有寫入權限的文件中，使用O_APPEND　會把新內容追加到原來內容的后面
    // fd = open( "ghostwu.txt", O_RDWR | O_APPEND );

    //在具有寫入權限的文件中，使用O_APPEND和O_TRUNC　O_TRUNC起作用，會把原來的內容清除，再寫入新的內容
    fd = open( "ghostwu.txt", O_RDWR | O_APPEND | O_TRUNC );

    if ( -1 == fd ) {
        printf("文件打開失敗\n");
        return -1;
    }else {
        printf("文件打開成功，fd=%d\n", fd );
    }

    //寫文件
    char buf[] = "new content";
    int count = 0;
    count = write( fd, buf, strlen( buf ) );
    if ( -1 == count ) {
        printf("文件寫入失敗\n");
        return -1;
    }else {
        printf("文件寫入成功，實際寫入的字節數目為:%d\n", count);
    }

    //關閉文件
    close( fd );

    return 0;
}

3,文件存在已否，創建文件與設置權限

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

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

    int fd = -1;

    // fd = open( "ghostwu.txt", O_RDWR | O_CREAT | O_EXCL );

    /*
        文件不存在:
            創建這個文件　並打開成功
        文件存在:
            再次運行時(文件已經創建成功，存在了)，　這時打開失敗
    */
    // fd = open( "ghostwu.txt", O_RDWR | O_CREAT );

    fd = open( "ghostwu.txt", O_RDWR | O_CREAT | O_EXCL, 666 );

    if( -1 == fd ) {
        printf("文件打開失敗,錯誤號:%d\n", errno );
        perror( "open" );
        return -1;
    }else {
        printf("文件打開成功\n");
    }

    close( fd );

    return 0;
}

上面用到了一個函數perror，errno和perror：

1)errno就是error number，意思就是錯誤號碼。linux系統中對各種常見錯誤做了個編號，當函數執行錯誤時，函數會返回一個特定的errno編號來告訴我們這個函數到底哪里錯了

2)errno是由操作系統來維護的一個全局變量，操作系統內部函數都可以通過設置errno來告訴上層調用者究竟剛才發生了一個什么錯誤

3)errno本身實質是一個int類型的數字，每個數字編號對應一種錯誤。當我們只看errno時只能得到一個錯誤編號數字，並不知道具體錯在哪里，所以：linux系統提供了一個函數perror（意思print error），perror函數內部會讀取errno並且將這個不好認的數字直接給轉成對應的錯誤信息字符串，然后打印出來

4,lseek用來移動文件內部指針

簡單應用：統計文件大小

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

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

    if ( argc != 2 ) {
        printf("usage:%s %s\n", argv[0], "filename");
        return -1;
    }

    int fd = -1;

    fd = open( argv[1], O_RDWR );

    if( -1 == fd ) {
        printf("文件打開失敗,錯誤號:%d\n", errno );
        perror( "open" );
        return -1;
    }else {
        printf("文件打開成功\n");
    }

    //把指針移動到文件末尾，就是文件的大小
    int count = lseek( fd, 0, SEEK_END );

    printf("文件大小為%d\n", count);

    close( fd );
    return 0;
}

------------------------------------------分割線------------------------------------------

一、同一個進程，多次打開同一個文件，然后讀出內容的結果是： 分別讀【我們使用open兩次打開同一個文件時，fd1和fd2所對應的文件指針是不同的2個獨立的指針】

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>

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

    int fd1 = -1;
    int fd2 = -1;
    char buf1[20] = {0};
    char buf2[20] = {0};
    int count1 = 0;
    int count2 = 0;

    fd1 = open( "ghostwu.txt", O_RDWR );

    if ( -1 == fd1 ) {
        printf("文件打開失敗\n");
        perror( "open" );
        return -1;
    }else {
        printf("文件打開成功，fd1=%d\n", fd1);
    }

    count1 = read( fd1, buf1, 5 );
    if ( -1 == count1 ) {
        printf( "文件讀取失敗\n" );
        perror( "read" );
    }else {
        printf( "文件讀取成功，讀取的內容是%s\n", buf1 );
    }

    fd2 = open( "ghostwu.txt", O_RDWR );

    if ( -1 == fd1 ) {
        printf("文件打開失敗\n");
        perror( "open" );
        return -1;
    }else {
        printf("文件打開成功，fd2=%d\n", fd1);
    }

    count2 = read( fd2, buf2, 10 );
    if ( -1 == count2 ) {
        printf( "文件讀取失敗\n" );
        perror( "read" );
    }else {
        printf( "文件讀取成功，讀取的內容是%s\n", buf2 );
    }

    close( fd1 );
    close( fd2 );

    return 0;
}

 二、同一個進程，多次打開同一個文件，然后寫入內容的結果是： 分別寫，當使用O_APPEND，就是接着寫

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>

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

    int fd1 = -1;
    int fd2 = -1;
    char buf1[] = "ghost";
    char buf2[] = "wu";
    int count1 = 0;
    int count2 = 0;

    fd1 = open( "ghostwu.txt", O_RDWR );

    if ( -1 == fd1 ) {
        printf("文件打開失敗\n");
        perror( "open" );
        return -1;
    }else {
        printf("文件打開成功，fd1=%d\n", fd1);
    }

    count1 = write( fd1, buf1, strlen( buf1 ) );
    if ( -1 == count1 ) {
        printf( "文件寫入失敗\n" );
        perror( "write" );
    }else {
        printf( "文件寫入成功，寫入的內容是%s\n", buf1 );
    }

    fd2 = open( "ghostwu.txt", O_RDWR );

    if ( -1 == fd1 ) {
        printf("文件打開失敗\n");
        perror( "open" );
        return -1;
    }else {
        printf("文件打開成功，fd2=%d\n", fd1);
    }

    count2 = write( fd2, buf2, strlen( buf2 ) );
    if ( -1 == count2 ) {
        printf( "文件寫入失敗\n" );
        perror( "write" );
    }else {
        printf( "文件寫入成功，寫入的內容是%s\n", buf2 );
    }

    close( fd1 );
    close( fd2 );

    return 0;
}

 

上面代碼保持不變，再寫入的時候加入flag標志：

fd1 = open( "ghostwu.txt", O_RDWR | O_APPEND );

fd2 = open( "ghostwu.txt", O_RDWR | O_APPEND );

三、 dup后的fd和原來打開文件的fd指向的是同一個文件，同時對這個文件寫入時，是接着寫

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

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

    int fd1 = -1;
    int fd2 = -1;

    fd1 = open( "ghostwu.txt", O_RDWR );

    if ( -1 == fd1 ) {
        perror( "open" );
        return -1;
    }else {
        printf("文件打開成功:fd=%d\n", fd1);
    }

    //dup后的文件，同時write　是接着寫入
    fd2 = dup( fd1 );
    printf("文件dup成功:fd=%d\n", fd2);

    //分別向fd1和fd2指向的文件寫入

    char buf1[] = "ghost";
    char buf2[] = "wu";

    int count1 = -1, count2 = -1;

    while ( 1 ) {
        count1 = write( fd1, buf1, strlen( buf1 ) );
        if ( -1 == count1 ) {
            perror( "buf1->write" );
            return -1;
        }else {
            printf("buf1->文件寫入成功\n");
        }

        sleep( 1 );

        count2 = write( fd2, buf2, strlen( buf2 ) );
        if ( -1 == count2 ) {
            perror( "buf2->write" );
            return -1;
        }else {
            printf("buf2->文件寫入成功\n");
        }
    }

    close( fd1 );
    close( fd2 );
    return 0;
}

 

在linux系統中,內核占用了0、1、2這三個fd，當我們運行一個程序得到一個進程時，內部就默認已經打開了3個文件，

對應的fd就是0、1、2。分別叫stdin、stdout、stderr。也就是標准輸入、標准輸出、標准錯誤。接下來，我們把標准輸出關閉，printf就不會輸出，如果用dup復制原來的fd，那么新dup出來的fd就是1(對應標准輸出)

之后標准輸出的內容都會被寫入到原來fd對應的那個文件

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

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

    int fd = -1;

    fd = open( "ghostwu2.txt", O_RDWR );
    if ( -1 == fd ) {
        perror( "open" );
        return -1;
    }else {
        printf( "文件打開成功fd=%d\n", fd );
    }

    //fd=0　對應stdin  fd=1 對應 stdout  fd=2 對應stderror
    close( 1 ); //關閉fd=1的標准輸出之后，printf輸出看不見

    int newFd = -1;

    newFd = dup( fd ); //newFd一定是1, 因為分配后的fd從最小的沒被占用的開始
    char buf[3];
    sprintf( buf, "%d", newFd ); //newFd轉字符串型
    printf( "這是一段輸出,由於newFd和fd關聯到標准輸出(newFd=1),會被寫入到文件\n" );
    write( fd, buf, 1 );

    return 0;
}