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

C Zarządzanie plikami

Plik może być używany do przechowywania dużej ilości trwałych danych. Podobnie jak wiele innych języków, 'C' udostępnia następujące funkcje zarządzania plikami,

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”,

funkcjonować	cel
fopen()	Tworzenie pliku lub otwieranie istniejącego pliku
zamknąć ()	Zamykanie pliku
fprintf()	Zapisanie bloku danych do pliku
fscanf ()	Odczyt danych bloku z pliku
getc ()	Odczytuje pojedynczy znak z pliku
putc ()	Zapisuje pojedynczy znak do pliku
dostać ()	Odczytuje liczbę całkowitą z pliku
umieścić ()	Zapisanie liczby całkowitej do pliku
szukaj ()	Ustawia pozycję wskaźnika pliku do określonej lokalizacji
Fell ()	Zwraca bieżącą pozycję wskaźnika pliku
przewijanie do tyłu ()	Ustawia wskaźnik pliku na początku pliku

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śli plik jest już obecny w systemie, zostanie bezpośrednio otwarty za jego pomocą funkcjonować.

fp jest wskaźnikiem pliku, który wskazuje na plik typu.

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.

Tryb pliku	OPIS
r	Otwórz plik do odczytu. Jeśli plik jest w trybie odczytu, żadne dane nie zostaną usunięte, jeśli plik jest już obecny w systemie.
w	Otwórz plik do zapisu. Jeśli plik jest w trybie zapisu, tworzony jest nowy plik, jeśli w ogóle nie istnieje. Jeśli plik znajduje się już w systemie, wszystkie dane w nim zawarte są obcinane i otwierane w celu zapisu.
a	Otwórz plik w tryb dodawania. Jeśli plik jest w trybie dodawania, zostanie otwarty. Zawartość pliku nie ulega zmianie.
r+	otwarty do czytania i pisania od początku
w+	otwarty do odczytu i zapisu, nadpisując plik
a+	otwarty do odczytu i zapisu, dołączany do pliku

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

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);

Przykład:

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

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

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, wskaźnik_pliku): Zapisuje znak do pliku wskazanego przez file_pointer.
• fputs(str, wskaźnik_pliku): Zapisuje ciąg do pliku wskazanego przez file_pointer.
• fprintf(wskaźnik_pliku, str, listy_zmiennych): Wypisuje ciąg do pliku wskazanego przez file_pointer. Ciąg może opcjonalnie zawierać specyfikatory formatu i listę zmiennych listy_zmiennych.

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 plik, aż dotrze do symbolu następnego wiersza „\n”, który wskazuje, że zdanie zostało pomyślnie zapisane. Proces polega na pobraniu każdego znaku tablicy i zapisaniu go w 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 smyczki
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(wskaźnik_pliku): Zwraca następny znak z pliku wskazanego przez wskaźnik pliku. Po osiągnięciu końca pliku EOF jest odsyłany.
• fgets(bufor, n, wskaźnik_pliku): Odczytuje n-1 znaków z pliku i zapisuje ciąg w buforze, w którym znak NULL '\0' jest dodawany jako ostatni znak.
• fscanf(wskaźnik_pliku, specyfikatory_konwersji, adresy_zmiennych): Służy do analizowania i analizowania danych. Odczytuje znaki z pliku i przypisuje dane wejściowe do listy wskaźniki zmienne adresy_zmiennych przy użyciu specyfikatorów konwersji. Należy pamiętać, że podobnie jak w przypadku scanf, fscanf przestaje czytać ciąg znaków po napotkaniu spacji lub 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 ciąg „Learning C with Guru99”. Odczytujemy go przy użyciu funkcji fgets(), która odczytuje wiersz po wierszu, gdzie rozmiar bufora musi być wystarczający do obsłużenia całego wiersza.
2. Otwieramy ponownie plik, aby zresetować plik wskaźnikowy do punktu na początku pliku. Utwórz różne zmienne łańcuchowe, aby obsługiwać każde słowo osobno. Wydrukuj zmienne, aby zobaczyć ich zawartość. Funkcja fscanf() służy głównie do wyodrębniania i analizowania danych 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.

Podsumowanie

• Plik to miejsce w pamięci, w którym przechowywane są dane.
• Programowanie w języku C udostępnia różne funkcje umożliwiające obsługę pliku.
• Mechanizm manipulowania plikami nazywany jest zarządzaniem plikami.
• Przed wykonaniem na pliku operacji należy go otworzyć.
• Plik można otworzyć w trybie odczytu, zapisu lub dołączania.
• Funkcje Getc i Putc służą do odczytu i zapisu pojedynczego znaku.
• Funkcja fscanf() pozwala na odczyt i analizę danych z pliku
• Możemy przeczytać (używając getc funkcja) cały plik poprzez pętlę obejmującą cały plik, aż do napotkania EOF
• Zapis do pliku możemy wykonać już po stworzeniu jego nazwy, korzystając z funkcji fprintf() i musi mieć znak nowego wiersza na końcu ciągu tekstowego.