We/wy plików C: tworzenie, otwieranie, odczytywanie, zapisywanie i zamykanie pliku

C Zarządzanie plikami

Plik może służyć do przechowywania dużej ilości trwałych danych. Podobnie jak wiele innych języków, język C zapewnia następujące funkcje zarządzania plikami: Funkcje,

1. Utworzenie pliku
2. Otwieranie pliku
3. Czytanie pliku
4. Zapis do pliku
5. Zamykanie pliku

Poniżej przedstawiono najważniejsze funkcje zarządzania plikami dostępne w języku „C”,

Jak utworzyć plik

Kiedykolwiek chcesz pracować z plikiem, pierwszym krokiem jest utworzenie pliku. Plik to nic innego jak miejsce w pamięci, w którym przechowywane są dane.

Aby utworzyć plik w programie w języku „C”, należy użyć następującej składni:

FILE *fp;
fp = fopen ("file_name", "mode");

W powyższej składni plik jest strukturą danych zdefiniowaną w bibliotece standardowej.

fopen to standardowa funkcja używana do otwierania pliku.

• Jeśli pliku nie ma w systemie, zostaje on utworzony, a następnie otwarty.
• Jeżeli plik znajduje się już w systemie, to zostanie on bezpośrednio otwarty za pomocą tej funkcji.

fp to plik wskaźnik który wskazuje na typ pliku.

Za każdym razem, gdy otwierasz lub tworzysz plik, musisz określić, co zamierzasz z nim zrobić. Plik w programowaniu w języku „C” może być utworzony lub otwarty w celach odczytu/zapisu. Tryb służy do określenia, czy chcesz otworzyć plik w którymś z poniższych celów. Poniżej przedstawiono różne typy trybów w programowaniu w języku „C”, których można używać podczas pracy z plikiem.

W podanej składni nazwa pliku i tryb są określone jako smyczki dlatego zawsze muszą być ujęte w cudzysłów.

Na przykład:

#include <stdio.h>
int main() {
FILE *fp;
fp  = fopen ("data.txt", "w");
}

Wyjście:

Plik jest tworzony w tym samym folderze, w którym zapisałeś swój kod.

Możesz określić ścieżkę, w której chcesz utworzyć plik

#include <stdio.h>
int main() {
FILE *fp;
fp  = fopen ("D://data.txt", "w");
}

Jak zamknąć plik

Należy zawsze zamykać plik, gdy operacje na pliku się zakończą. Oznacza to, że zawartość i linki do pliku są zakończone. Zapobiega to przypadkowemu uszkodzeniu pliku.

'C' udostępnia funkcję fclose do wykonywania operacji zamykania pliku. Składnia fclose jest następująca:

fclose (file_pointer);

Na przykład:

FILE *fp;
fp  = fopen ("data.txt", "r");
fclose (fp);

Funkcja fclose przyjmuje wskaźnik pliku jako argument. Plik powiązany ze wskaźnikiem jest następnie zamykany za pomocą funkcji fclose. Zwraca ona wartość 0, jeśli zamknięcie zakończyło się pomyślnie, oraz EOF (koniec pliku), jeśli wystąpił błąd podczas zamykania pliku.

Po zamknięciu pliku tego samego wskaźnika pliku można używać także z innymi plikami.

W programowaniu w języku C pliki są automatycznie zamykane po zakończeniu działania programu. Dobrą praktyką programistyczną jest ręczne zamykanie pliku poprzez napisanie funkcji fclose.

Zapisywanie do pliku

W C, kiedy piszesz do pliku, należy jawnie dodać znaki nowego wiersza „\n”.

Biblioteka stdio oferuje funkcje niezbędne do zapisu do pliku:

• fputc(char, file_pointer): Zapisuje znak do pliku wskazywanego przez file_pointer.
• fputs(str, file_pointer): Zapisuje ciąg znaków do pliku wskazywanego przez file_pointer.
• fprintf(file_pointer, str, variable_lists): Drukuje ciąg znaków do pliku wskazywanego przez file_pointer. Ciąg znaków może opcjonalnie zawierać specyfikatory formatu i listę zmiennych variable_lists.

Poniższy program pokazuje jak wykonać zapis do pliku:

Funkcja fputc():

#include <stdio.h>
int main() {
        int i;
        FILE * fptr;
        char fn[50];
        char str[] = "Guru99 Rocks\n";
        fptr = fopen("fputc_test.txt", "w"); // "w" defines "writing mode"
        for (i = 0; str[i] != '\n'; i++) {
            /* write to file using fputc() function */
            fputc(str[i], fptr);
        }
        fclose(fptr);
        return 0;
    }

Wyjście:

Powyższy program zapisuje pojedynczy znak do pliku fputc_test.txt, aż dotrze do symbolu „\n” w kolejnym wierszu, który oznacza, że ​​zdanie zostało pomyślnie zapisane. Proces polega na zapisaniu każdego znaku z tablicy do pliku.

1. W powyższym programie utworzyliśmy i otworzyliśmy plik o nazwie fputc_test.txt w trybie zapisu i zadeklarowaliśmy nasz ciąg znaków, który zostanie zapisany do pliku.
2. Wykonujemy operację zapisu znak po znaku za pomocą pętli for i umieszczamy każdy znak w pliku, aż napotkamy znak „\n”, po czym zamykamy plik za pomocą funkcji fclose.

fputs() Funkcja:

#include <stdio.h>
int main() {
        FILE * fp;
        fp = fopen("fputs_test.txt", "w+");
        fputs("This is Guru99 Tutorial on fputs,", fp);
        fputs("We don't need to use for loop\n", fp);
        fputs("Easier than fputc function\n", fp);
        fclose(fp);
        return (0);
    }

Wyjście:

1. W powyższym programie utworzyliśmy i otworzyliśmy w trybie zapisu plik o nazwie fputs_test.txt.
2. Po wykonaniu operacji zapisu za pomocą funkcji fputs() poprzez zapisanie trzech różnych ciągów znaków
3. Następnie plik jest zamykany za pomocą funkcji fclose.

Funkcja fprintf():

#include <stdio.h>
    int main() {
        FILE *fptr;
        fptr = fopen("fprintf_test.txt", "w"); // "w" defines "writing mode"
        /* write to file */
        fprintf(fptr, "Learning C with Guru99\n");
        fclose(fptr);
        return 0;
    }

Wyjście:

1. W powyższym programie utworzyliśmy i otworzyliśmy w trybie zapisu plik o nazwie fprintf_test.txt.
2. Po wykonaniu operacji zapisu za pomocą funkcji fprintf() poprzez zapisanie ciągu znaków, plik jest zamykany za pomocą funkcji fclose.

Odczyt danych z pliku

Istnieją trzy różne funkcje przeznaczone do odczytu danych z pliku

• fgetc(file_pointer): Zwraca kolejny znak z pliku wskazywanego przez wskaźnik pliku. Po osiągnięciu końca pliku, odsyłany jest znacznik EOF.
• fgets(buffer, n, file_pointer): Odczytuje n-1 znaków z pliku i zapisuje ciąg w buforze, w którym jako ostatni znak dodawany jest znak NULL '\0'.
• fscanf(file_pointer, conversion_specifiers, variable_adresses): Służy do parsowania i analizy danych. Odczytuje znaki z pliku i przypisuje dane wejściowe do listy wskaźników zmiennych variable_adresses za pomocą specyfikatorów konwersji. Należy pamiętać, że podobnie jak w przypadku scanf, fscanf zatrzymuje odczyt ciągu znaków po napotkaniu spacji lub znaku nowej linii.

Poniższy program demonstruje odczytywanie pliku fputs_test.txt za pomocą odpowiednio funkcji fgets(), fscanf() i fgetc():

#include <stdio.h>
int main() {
        FILE * file_pointer;
        char buffer[30], c;

        file_pointer = fopen("fprintf_test.txt", "r");
        printf("----read a line----\n");
        fgets(buffer, 50, file_pointer);
        printf("%s\n", buffer);

        printf("----read and parse data----\n");
        file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer
        char str1[10], str2[2], str3[20], str4[2];
        fscanf(file_pointer, "%s %s %s %s", str1, str2, str3, str4);
        printf("Read String1 |%s|\n", str1);
        printf("Read String2 |%s|\n", str2);
        printf("Read String3 |%s|\n", str3);
        printf("Read String4 |%s|\n", str4);

        printf("----read the entire file----\n");

        file_pointer = fopen("fprintf_test.txt", "r"); //reset the pointer
        while ((c = getc(file_pointer)) != EOF) printf("%c", c);

        fclose(file_pointer);
        return 0;
    }

Wynik:

----read a line----
Learning C with Guru99

----read and parse data----
Read String1 |Learning|
Read String2 |C|
Read String3 |with|
Read String4 |Guru99|
----read the entire file----
Learning C with Guru99

1. W powyższym programie otworzyliśmy plik o nazwie „fprintf_test.txt”, który został wcześniej napisany przy użyciu funkcji fprintf() i zawiera „Nauka języka C z GuruCiąg 99”. Odczytujemy go za pomocą funkcji fgets(), która odczytuje wiersz po wierszu, przy czym rozmiar bufora musi być wystarczający do obsłużenia całego wiersza.
2. Otwieramy ponownie plik, aby zresetować wskaźnik do początku pliku. Tworzymy różne zmienne łańcuchowe, aby obsługiwać każde słowo osobno. Wypisujemy zmienne, aby zobaczyć ich zawartość. Funkcja fscanf() służy głównie do…tract i analizuje dane z pliku.
3. Otwórz ponownie plik, aby zresetować plik wskaźnikowy tak, aby wskazywał początek pliku. Odczytuj dane i drukuj je z pliku znak po znaku, używając funkcji getc() aż do napotkania instrukcji EOF
4. Po wykonaniu operacji odczytu pliku przy użyciu różnych wariantów, ponownie zamknęliśmy plik korzystając z funkcji fclose.

Interaktywny odczyt i zapis plików za pomocą getc i putc

Są to najprostsze operacje na plikach. Getc oznacza get character, a putc oznacza put character. Te dwie funkcje są używane do obsługi tylko jednego znaku na raz.

Poniższy program demonstruje funkcje obsługi plików w programowaniu w języku 'C':

#include <stdio.h>
int main() {
        FILE * fp;
        char c;
        printf("File Handling\n");
        //open a file
        fp = fopen("demo.txt", "w");
        //writing operation
        while ((c = getchar()) != EOF) {
            putc(c, fp);
        }
        //close file
        fclose(fp);
        printf("Data Entered:\n");
        //reading
        fp = fopen("demo.txt", "r");
        while ((c = getc(fp)) != EOF) {
            printf("%c", c);
        }
        fclose(fp);
        return 0;
    }

Wyjście:

1. W powyższym programie utworzyliśmy i otworzyliśmy w trybie zapisu plik o nazwie demo.
2. Po wykonaniu operacji zapisu plik jest zamykany za pomocą funkcji fclose.
3. Ponownie otworzyliśmy plik, który teraz zawiera dane w trybie odczytu. Pętla while będzie wykonywana, dopóki nie zostanie znaleziony koniec pliku. Po znalezieniu końca pliku operacja zostanie zakończona, a dane zostaną wyświetlone za pomocą funkcji printf.
4. Po wykonaniu operacji odczytu plik jest ponownie zamykany za pomocą funkcji fclose.

FAQ