Rozdział 1 Obsługa plików W językach C pliki powiązane są ze strumieniami i pracuje się na nich podobnie jak na innych strumieniach. W języku C do operacji na plikach służą funkcje z biblioteki stdio.h, a wśród nich między innymi: fopen, fclose, fwrite, fread, fprintf, fscanf, feof i fseek. Aby zacząć operować na pliku należy go otworzyć, zaś po zakończeniu pracy należy plik zamknąć. Otwierając plik należy określić w jakim celu plik jest otwierany (do czytania, do pisania etc.) oraz czy plik ma być otwarty w trybie binarnym (czyli jako ciąg bajtów) czy tekstowym. 1.1 Wstęp Program wykonujący operację na plikach powinien zachować schemat działania zapewniający poprawną pracę: 1. Otwarcie pliku w odpowiednim trybie (do zapisu, odczytu, zapisu i odczytu) - Operację otwarcia pliku wykonujemy za pomocą funkcji fopen. Funkcja ta posiada dwa parametry: pierwszy - nazwę pliku (właściwie: ścieżkę do pliku w postaci napisu np. "plik.txt", "/etc/fstab", "C: \\CONFIG.SYS",), drugi - tryb otwarcia pliku (również napis). Jeżeli operacja otwarcia powiodła się funkcja zwraca uchwyt do pliku wykorzystywany później w operacjach zapisu, odczytu i zamknięcia pliku. Jeżeli wystąpił błąd otwarcia pliku funkcja zwraca wartość N U LL. Tryb otwarcia pliku podajemy w postaci łańcucha tekstowego składającego się z odpowiednich składowych. Łańcuchy tekstowe identyfikujące tryb otwarcia przedstawione zostały poniżej: r otwarcie pliku w trybie tekstowym do odczytu rb otwarcie pliku w trybie binarnym do odczytu w otwarcie pliku w trybie tekstowym do zapisu wb otwarcie pliku w trybie binarnym do zapisu otwarcie pliku w trybie tekstowym, w celu a dopisania na koniec pliku otwarcie pliku w trybie binarnym, w celu ab dopisania na koniec pliku r+ otwarcie pliku w trybie tekstowym, zarówno do pisania i czytania rb+ otwarcie pliku w trybie binarnym, zarówno do pisania i czytania w+ otwarcie pliku w trybie tekstowym, zarówno do pisania i czytania wb+ otwarcie pliku w trybie binarnym, zarówno do pisania i czytania a+ otwarcie pliku w trybie tekstowym, zarówno do czytania i dopisywania na koniec pliku ab+ otwarcie pliku w trybie binarnym, zarówno do czytania i dopisywania na koniec pliku 1
Przykłady: (a) Poniższy fragment kodu otworzy w bieżącym katalogu plik tekstowy o nazwie raport.txt w trybie do zapisu: 1 FILE out ; out = fopen ( " r a p o r t. t x t ", "w" ) ; (b) Poniższy fragment kodu otworzy plik binarny (ciąg bajtów) o nazwie plik.bin w miejsu /home/student/desktop/plik.bin do zapisu i odczytu istniejącego pliku - jeżeli plik nie istnieje funkcja zwróci NULL: 1 FILE out ; out = fopen ( "/home/ student / Desktop / p l i k. bin ", " rb+" ) ; Tryb binarny otwarcia pliku (do zapisu i/lub odczytu) oznacza, że po otworzeniu takiego pliku w edytorze tekstu możemy zobaczyć tzw. krzaki. Ich zawartość to po prostu odbitka surowych danych zapisanych w pamięci programu, który je utworzył, bez jakiegokolwiek przetwarzania na formę odczytywalną przez człowieka. W pliku binarnym poszczególne bajty mają dowolne wartości, niekoniecznie są interpretowalne jako znaki alfanumeryczne. Taki plik jest zazwyczaj nieczytelny dla człowieka po otwarciu w podstawowym edytorze tekstu. Struktura informacji w plikach binarnych jest ściśle określona przez oprogramowanie, które zapisuje tego typu pliki (np. określoną strukturę ma plik MS Word, MS Excel itp.). Programista chcący odczytać i właściwie zinterpretować w swoim programie dane z pliku binarnego, powinien znać jego strukturę. Tryb tekstowy otwarcia pliku (do zapisu i/lub odczytu) poszczególne bajty w pliku można zinterpretować jako dane alfanumeryczne (znaki), zapisane przy pomocy określonego kodowania (np. ASCII). Jak pamiętamy, funkcja f open zwraca uchwyt do otwartego pliku, jeśli czynność się powiodła. W przeciwnym razie zwracana jest wartość N U LL. W celu zabezpieczenia programu przed niewłaściwym działaniem (odwołaniem do zerowego uchwytu) należy sprawdzić poprawność otwarcia pliku, np.: 1 FILE f ; f = fopen ( "program. c ", " r " ) ; 3 i f (! f ) { 4 perror ( " fopen " ) ; 5 exit ( 1 ) ; 6 } lub: 1 FILE f ; f = fopen ( "program. c ", " r " ) ; 3 i f ( f == NULL ) 5 fprintf ( stderr, " Nie mozna otworzyc p l i k u. \ n" ) ; 6 exit ( 1 ) ; } lub:
1 FILE f ; f = fopen ( "program. c ", " r " ) ; 3 i f ( f == NULL ) 5 perror ( " fopen " ) ; 6 exit ( 1 ) ; }. Wykonanie operacji zapisu lub odczytu - W zależności od rodzaju danych (tekstowe, binarne) używamy różnych funkcji: (a) Odczyt formatowany (plik tekstowy): 1 i n t fscanf ( in, "%s ", bufor ) ; in - uchwyt do pliku otwartego do odczytu (plik, z którego chcemy wczytać dane) %s - typ danych, jakie chcemy wczytać z pliku - tu napis (specyfikatory typów są tu identyczne jak w funkcji scanf) bufor - bufor (tablica) do której chcemy wpisać dane wczytane z pliku funkcja zwraca liczbę znaków, którą udało jej się przeczytać z pliku Używając funkcji fscanf możemy wczytywać dane do tablicy, liczby całkowitej, zmiennoprzecinkowej, czy znaku. Przykład: Załóżmy, że nasz plik wygląda jak poniżej: 1 We are in 01 Aby wczytać z niego poszczególne wartości możemy użyć funkcji fscanf, i wczytywać kolejno napis (We), napis (are), napis (in) oraz liczbę (01): #i n c l u d e <s t d l i b. h> 3 4 i n t main ( ) 5 { 6 char str1 [ 1 0 ], str [ 1 0 ], str3 [ 1 0 ] ; i n t year ; 8 FILE fp ; 10 fp = fopen ( " f i l e. t x t ", " r " ) ; 11 fscanf ( fp, "%s %s %s %d", str1, str, str3, &year ) ; 1 13 printf ( "Wczytany n a p i s 1 % s \ n", str1 ) ; 14 printf ( "Wczytany n a p i s % s \ n", str ) ; 15 printf ( "Wczytany n a p i s 3 % s \ n", str3 ) ; 16 printf ( "Wczytana l i c z b a %d \ n", year ) ; 1 18 fclose ( fp ) ; 1 3
0 r e t u r n 0 ; 1 } (b) Odczyt całej linii/łańcucha znakowego tekstu z pliku (odczy pliku liniami): 1 char fgets ( bufor, 100, in ) ; in - uchwyt do pliku otwartego do odczytu (plik, z którego chcemy wczytać dane) 100 - ile maksymalnie znaków możemy wczytać bufor - bufor (tablica) do której chcemy wpisać dane wczytane z pliku funkcja zwraca NULL, jeśli plik się skończy Przykład: Załóżmy, że nasz plik wygląda jak poniżej: 1 We are in 01 Aby wczytać z niego całą linię, możemy użyć funkcji fgets: #i n c l u d e <s t d l i b. h> 3 4 i n t main ( ) 5 { 6 char bufor [ 1 0 1 ] ; FILE fp ; 8 fp = fopen ( " f i l e. t x t ", " r " ) ; 10 fgets ( bufor, 100, fp ) ; 11 1 printf ( " Odczytana l i n i a : % s \ n", bufor ) ; 13 14 fclose ( fp ) ; 15 16 r e t u r n 0 ; 1 } (c) Odczyt pojedynczego znaku tekstu z pliku (odczyt pliku znakami): 1 i n t fgetc ( in ) ; in - uchwyt do pliku otwartego do odczytu (plik, z którego chcemy wczytać dane) jeśli wykonanie zakończyło się poprawnie, to zwraca przeczytany znak po przekształceniu go na typ int jeśli wystąpił błąd lub został przeczytany znacznik końca pliku, to zwraca wartość EOF 4
Przykład: Załóżmy, że nasz plik wygląda jak poniżej: 1 We are in 01 Wczytajmy za pomocą funkcji fgetc 6 znaków z pliku do tablicy (zamiast tabicy, możemy np. użyć 6 zmiennych): #i n c l u d e <s t d l i b. h> 3 4 i n t main ( ) 5 { 6 char bufor [ 6 ] ; FILE fp ; 8 i n t i ; 10 fp = fopen ( " f i l e. t x t ", " r " ) ; 11 1 bufor [ 0 ] = fgetc ( fp ) ; 13 bufor [ 1 ] = fgetc ( fp ) ; 14 bufor [ ] = fgetc ( fp ) ; 15 bufor [ 3 ] = fgetc ( fp ) ; 16 bufor [ 4 ] = fgetc ( fp ) ; 1 bufor [ 5 ] = fgetc ( fp ) ; 18 1 printf ( " Odczytane znaki : % s \ n", bufor ) ; 0 printf ( " Odczytane znaki : \ n\n" ) ; 1 f o r ( i=0; i <6; i++) 3 printf ( "%c \n", bufor [ i ] ) ; 4 5 fclose ( fp ) ; 6 r e t u r n 0 ; 8 } (d) Zapis formatowany danych do pliku (plik tekstowy): 1 i n t fprintf ( out, "%d", n ) ; i n t fprintf ( out, "%d", 104) ; out - uchwyt do pliku otwartego do zapisu (plik, do którego chcemy wpisać dane) %d - typ danych, jakie chcemy zapisać do pliku - tu liczba całkowita (specyfikatory typów są tu identyczne jak w funkcji printf) n - liczba, którą chcemy wpisać do pliku 5
Przykład: Załóżmy, że do pliku chcemy wpisać liczbę całkowitą, zmiennoprzecinkową i tekst (napis) 1 01 3. 140000 3 Programowanie w jezyku C. Zapiszemy te dane do pliku za pomocą funkcji fprintf : 5 FILE fp ; 6 i n t n = 0 1 ; 8 char text [ ] = " Programowanie w jezyku C. \ n" ; double pi = 3. 1 4 ; 10 11 fp = fopen ( " m y f i l e. t x t ", "w" ) ; 1 13 fprintf ( fp, "%d\n", n ) ; 14 fprintf ( fp, "%l f \n", pi ) ; 15 fprintf ( fp, "%s \n", text ) ; 16 1 fclose ( fp ) ; 18 1 r e t u r n 0 ; 0 } (e) Zapis całej linii/łańcucha znakowego tekstu do pliku: 1 i n t fputs ( " This i s c programming. ", out ) ; i n t fputs ( bufor, out ) ; out - uchwyt do pliku otwartego do zapisu (plik, do którego chcemy wpisać dane) bufor - tablica znaków (napis), którą chcemy wpisać do pliku Przykład: Załóżmy, że do pliku chcemy wpisać tekst (napis): 1 This is c programming. This is a system programming language. 3 We are programming in C in 01 year. 4 Today is 6. 0 1. 0 1 W celu zapisania całej linii do pliku, użyjemy funkcji fputs: 6
5 FILE fp ; 6 fp = fopen ( " f i l e. t x t ", "w+" ) ; 8 fputs ( " This i s c programming. \ n", fp ) ; 10 fputs ( " This i s a system programming language. \ n", fp ) ; 11 fputs ( "We are programming i n C i n 01 year. \ n", fp ) ; 1 fputs ( "Today i s 6. 0 1. 0 1 ", fp ) ; 13 14 fclose ( fp ) ; 15 16 r e t u r n ( 0 ) ; 1 } (f) Zapis pojedynczego znaku tekstu do pliku (zapis pliku znakami): 1 i n t fputc ( ch, out ) ; i n t fputc ( ' \n ', out ) ; 3 i n t fputc ( ' a ', out ) ; out - uchwyt do pliku otwartego do zapisu (plik, do którego chcemy wpisać dane) ch - znak, który chcemy wpisać do pliku Przykład: Załóżmy, że chcemy wpisać do pliku cały alfabet (wielkie i małe litery), wpisując je do pliku po jednym znaku (użyjemy funkcji fputc): 5 FILE fp ; 6 i n t ch ; 8 fp = fopen ( " a l f a b e t. t x t ", "w+" ) ; 10 f o r ( ch = 65 ; ch <= 0 ; ch++ ) 11 fputc ( ch, fp ) ; 1 13 fputc ( ' \n ', fp ) ; 14 15 f o r ( ch = ; ch <= 1 ; ch++ ) 16 fputc ( ch, fp ) ; 1 18 fclose ( fp ) ; 1 0 r e t u r n ( 0 ) ; 1 }
i n t main ( ) 3 { 4 FILE fp ; 5 i n t ch ; 6 fp = fopen ( " a l f a b e t. t x t ", "w+" ) ; 8 f o r ( ch = ' a ' ; ch <= ' z ' ; ch++ ) 10 fputc ( ch, fp ) ; 11 1 fputc ( ' \n ', fp ) ; 13 14 f o r ( ch = 'A ' ; ch <= 'Z ' ; ch++ ) 15 fputc ( ch, fp ) ; 16 1 fclose ( fp ) ; 18 1 r e t u r n ( 0 ) ; 0 } (g) Odczyt binarny : 1 size_t fread ( void p, size_t s, size_t n, FILE stream ) ; 3 fread(&d, s i z e o f ( f l o a t ), 1, plik ) ; 4 fread ( tab, s i z e o f ( tab ), 1, plik ) ; &d1 - wskaźnik do zmiennej, którą chcemy odczytać z pliku sizeof(float) - rozmiar elementu do odczytu 1 - ilość elementów do odczytu plik - uchwyt do pliku otwartego do zapisu (plik, z którego chcemy odczytać dane binarne) Poniższy program odczytuje w trybie binarnym z pliku pojedynczą zmienną typu f loat oraz całą tablicę liczb zmiennoprzecinkowych: i n t main ( ) 3 { 4 f l o a t d, tab [ 5 ] ; 5 i n t i ; 6 FILE plik=fopen ( " data. bin ", " rb " ) ; 8 fread(&d, s i z e o f ( f l o a t ), 1, plik ) ; 10 fread ( tab, s i z e o f ( tab ), 1, plik ) ; 11 fclose ( plik ) ; 1 13 printf ( "d = %1. f \n", d ) ; 14 15 f o r ( i=0;i <5;i++) 16 printf ( "%1. f ", tab [ i ] ) ; 1 18 r e t u r n 0 ; 1 } 8
(h) Zapis binarny : 1 size_t fwrite ( c o n s t void p, size_t s, size_t n, FILE stream ) ; 3 fwrite(&d1, s i z e o f ( f l o a t ), 1, plik ) ; 4 fwrite ( tab, s i z e o f ( f l o a t ), 5, plik ) ; &d1 - wskaźnik do zmiennej, którą chcemy zapisać do pliku sizeof(float) - rozmiar elementu do zapisu 1 - ilość elementów do zapisu plik - uchwyt do pliku otwartego do zapisu (plik, do którego chcemy wpisać dane binarne) Poniższy program zapisuje w trybie binarnym do pliku pojedynczą zmienną typu f loat oraz całą tablicę liczb zmiennoprzecinkowych: 5 f l o a t d1 = 1. 5 ; 6 f l o a t tab1 [ 5 ] = { 1. 0,. 0, 3. 0, 4. 0, 5. 0 } ; 8 FILE plik1=fopen ( " data. bin ", "wb" ) ; 10 fwrite(&d1, s i z e o f ( f l o a t ), 1, plik1 ) ; 11 fwrite ( tab1, s i z e o f ( f l o a t ), 5, plik1 ) ; 1 13 fclose ( plik1 ) ; 14 15 r e t u r n 0 ; 16 } 3. Zamknięcie otwartego pliku - Plik zamykany jest funkcją f close. Funkcja f close zwraca zero jeśli zamknięcie pliku było pomyślne lub EOF w przypadku wystąpienia błędu: 1 fclose ( plik ) ; plik - uchwyt do otwartego pliku, który chcemy zamknąć
#i n c l u d e <s t d l i b. h> 5 FILE plik ; 6 plik = fopen ( " p l i k. t x t ", "a+" ) ; 8 i f ( plik == NULL ) { 10 printf ( " Blad o t w a r c i a p l i k u. \ n" ) ; 11 exit ( 1) ; 1 } 13 14 / p r z e t w a r z a n i e p l i k u / 15 16 fclose ( plik ) ; 1 18 r e t u r n 0 ; 1 } 4. Sprawdzenie, czy plik się skończył - Funkcja f eof testuje strumień ma ustawiony znacznik oznaczający koniec pliku, a nie czy nastąpił sam koniec pliku. Oznacza to że taki identyfikator jest ustawiany przez inną funkcję - funkcję która odczytuje dane. Można przyjąć, że ta funkcja czyta wszystkie dane, ale w momencie napotkania końca pliku ustawia znacznik EOF na strumieniu. Funkcja zwraca wartość niezerową jeżeli wcześniej napotkano koniec pliku tekstowego (tzn. jeżeli poprzedzająca operacja przeczytała znacznik końca pliku). 1. Czytanie pliku liniami 5 FILE fp ; 6 char buffer [ 5 5 ] ; 8 fp = fopen ( " a l f a b e t. t x t ", " r " ) ; 10 w h i l e ( fgets ( buffer, 55, fp )!= NULL ) 11 { 1 printf ( "%s \n", buffer ) ; 13 } 14 15 fclose ( fp ) ; 16 1 r e t u r n ( 0 ) ; 18 } 10
1.3 Czytanie pliku znak po znaku 5 FILE fp ; 6 char c ; 8 fp = fopen ( " a l f a b e t. t x t ", " r " ) ; 10 w h i l e ( ( c = fgetc ( fp ) )!= EOF ) 11 { 1 printf ( "%c ", c ) ; 13 } 14 15 fclose ( fp ) ; 16 1 r e t u r n ( 0 ) ; 18 } 1.4 Czytanie pliku za pomocą fscanf 5 FILE fp ; 6 char bufor [ 1 0 4 ] ; 8 fp = fopen ( " U n t i t l e d 3. c ", " r " ) ; 10 w h i l e ( fscanf ( fp, "%s ", bufor ) ) 11 { 1 printf ( "%s \n", bufor ) ; 13 14 i f ( feof ( fp ) ) 15 break ; 16 } 1 18 fclose ( fp ) ; 1 0 r e t u r n 0 ; 1 } 11
5 FILE fp ; 6 char bufor [ 1 0 4 ] ; 8 fp = fopen ( " U n t i t l e d 3. c ", " r " ) ; 10 w h i l e (! feof ( fp ) ) 11 { 1 i f ( fscanf ( fp, "%s ", bufor )!= 1) 13 break ; 14 15 printf ( "%s \n", bufor ) ; 16 } 1 18 fclose ( fp ) ; 1 0 r e t u r n 0 ; 1 } 1.5 Parametry / argumenty uruchomienia programu Do programu można przekazać dane nie tylko wczytując je z klawiatury, ale również za pomocą argumentów wywołania, podawanych podczas uruchomienia programu. Aby korzystanie z argumentów wywołania było możliwe, funkcja main programu powinna być zdefiniowana z nagłówkiem: 1 i n t main ( i n t argc, char argv ) { 3 / / 4 } lub, równoważnie: 1 i n t main ( i n t argc, char argv [ ] ) { 3 / / 4 } Pierwszy parametr, o zwyczajowej nazwie argc, jest liczbą argumentów podanych podczas wywołania programu. Pierwszym z tych argumentów, o numerze 0, jest zawsze nazwa wywoływanego programu. Tak więc argc jest zawsze co najmniej jeden. Zmienna argv wygląda trochę tajemniczo, ale tak naprawdę jest tablicą napisów zawierających kolejne argumenty wywołania: argv[0], argv[1],..., argv[argc 1], indeksowanie rozpoczyna się od zera, dlatego ostatnią wartścią indeksu jest argc 1 a nie argc. Skompiluj poniższy program (gcc plik.c -o plik), i wywołaj go z różnymi argumentami (lub bez):./plik./plik 1 3./plik aaa 1 sdx./plik programowanie w c./plik programowanie w c jest fajne 1
i n t main ( i n t argc, char argv ) 3 { 4 i n t i ; 5 6 printf ( "Nazwa programu : \ t%s \n", argv [ 0 ] ) ; printf ( " I l o s c argumentow programu : \ t%d\n", argc ) ; 8 10 f o r ( i = 1 ; i < argc ; i++) 11 printf ( "Argumentem nr %d j e s t %s \n", i, argv [ i ] ) ; 1 } Załóżmy, że chcemy do programu przekazać nazwę pliku (za pomocą argumentów wywołania programu). Następnie mamy plik o takiej nazwie otworzyć, przeczytać, i wypisać jego zawartość na ekranie: 3 i n t main ( i n t argc, char argv ) 5 FILE plik ; 6 char c ; 8 plik = fopen ( argv [ 1 ], " r " ) ; 10 i f ( plik == NULL ) 11 { 1 printf ( "Brak p l i k u! \ n" ) ; 13 r e t u r n 1; 14 } 15 16 w h i l e ( ( c = fgetc ( plik ) )!= EOF ) 1 { 18 printf ( "%c ", c ) ; 1 } 0 1 fclose ( plik ) ; 3 r e t u r n 0 ; 4 } 13
1.6 Zadania do wykonania Zadanie 0 Napisz program, który zapyta użytkownika o nazwę pliku, a następnie otworzy ten plik do odczytu i wyświetli całą jego zawartość na ekranie. Zadanie 1 Napisz program, który policzy znaki w pliku (parametr programu). Zadanie Napisz program, który policzy linie w pliku (parametr programu). Zadanie 3 Napisz program, który policzy słowa w pliku (parametr programu). Zadanie 4 Napisz program, który wpisuje do pliku (parametr programu) 40 znaków w wierszach 5-cio znakowych. Zadanie 5 Napisz program, który wyświetla na ekranie liczbę wystąpień cyfr, małych i wielkich liter w podanym pliku (parametr programu). Zadanie 6 Napisz program, który zlicza zapisane linijki w istniejącym pliku (parametr programu) i zapisuje ich liczbę do innego pliku (drugi parametr programu). Zadanie Napisz program, który kopiuje plik tekstowy (pierwszy parametr programu) do drugiego pliku (drugi parametr programu). Zadanie 8 Napisz program, który kopiuje plik tekstowy (pierwszy parametr programu) do drugiego pliku (drugi parametr programu) w ten sposób, że każdy ciąg spacji redukuje do jednej i na końcu pliku podaje liczbę usuniętych spacji. Zadanie Napisz program, który wczytuje liczby z pliku i oblicza ich sumę oraz średnią. Zadanie 10 Napisz program, który kopiując podany plik (parametr programu) do innego pliku (drugi parametr programu), zamienia małą literę na wielką, a wielką na małą (inne znaki tj. cyfry, kropki itp. kopiowane są bez zmian). Zadanie 11 Napisz program, który sprawdzi i wypisze stosowną informację, czy podany plik (parametr programu) jest taki sam, jak inny plik (drugi parametr programu). Zadanie 1 Napisz funkcje, która dostaje jako argument ścieżkę dostepu do pliku tekstowego i wypisuje na standardowym wyjściu zawartość pliku z pominieciem białych znaków. Zadanie 13 Napisz funkcje, która dostaje jako argumenty ścieżkę dostepu do pliku tekstowego oraz znak c i zwraca jako wartość liczbe wystąpień znaku c w podanym w argumencie pliku. Zadanie 14 Napisz funkcje, która dostaje jako argumenty ścieżki dostepu do dwóch plików i dopisuje zawartość pierwszego pliku na koniec drugiego pliku. Zadanie 15 Napisz program, który zapisze do pliku (parametr programu) n linii wczytanych od użytkownika. Zadanie 16 Napisz program, który kopiując podany plik (parametr programu) do innego pliku (drugi parametr programu), łamie wiersze, które mają więcej niż 50 znaków (łącznie ze spacjami). Znaki powyżej 50-tego przenoszone są do nowej linii (dodatkowy wiersz). Wiersze krótsze kopiowane są bez zmian. 14
Zadanie 1 Napisz program, który otwiera dwa pliki o nazwach podanych w wierszu poleceń. Jeśli argumentów nie podano, wówczas nazwy plików mają być pobrane od użytkownika. Program powinien wyświetlać wiersze z obu plików naprzemienne, to znaczy: 1-szą linię z pierwszego pliku, 1-szą linię z drugiego pliku, -gą linię z pierwszego pliku, -gą linię z drugiego pliku, itd., aż do momentu, wyświetlenia ostatniego wiersza pliku zawierającego większą liczbę wierszy. Zadanie 18 Napisz program, który przyjmuje argumenty wiersza poleceń. Pierwszy z argumentów jest znakiem, drugi nazwą pliku. Program powinien wyświetlić na ekranie tylko te wiersze pliku wejściowego, które zawierają dany znak. Zakładamy, że każdy wiersz w pliku kończy się znakiem przejścia do nowej linii. Przyjmujemy, że żaden wiersz nie przekracza długości 56 znaków. Zadanie 1 W pliku dane.txt znajdują się w kolejnych wierszach losowe liczby. Do pliku a.txt wpisz ilość liczb parzystych znajdujących się w pliku dane.txt w następującej postaci: Liczb parzystych jest [ilość liczb]. Do pliku b.txt skopiuj wszystkie liczby z pliku dane.txt, w których cyfra dziesiątek jest równa lub 0. Do pliku c.txt skopiuj wszystkie liczby, które są kwadratami liczb całkowitych, np. taką liczbą jest liczba 5, ponieważ 55 = 15. Zadanie 0 Napisz funkcję, która jako parametry pobiera nazwę pliku do odczytu, nazwę pliku do zapisu oraz napisy, n1 oraz n (tablice znaków). Zadaniem funkcji jest przepisanie pliku wejściowego do wyjściowego w taki sposób, że każde wystąpienie napisu n1 w pliku wejściowym ma zostać zamienione na napis n w pliku wyjściowym. Przykład: Wywołanie funkcji: zadanie0("we.txt", "wy.txt", "piwo", "programowanie"); - chcemy zamienić każde wystąpienie słowa piwo słowem programowanie: Plik we.txt: lubie piwo Plik wy.txt: lubie programowanie 15