» Funkcje «

Funkcje
Funkcje są jednym z ważniejszych elementów każdego języka programowania. Umożliwiają pogrupowanie instrukcji w poszczególne grupy dzięki czemu nie musimy powtarzać tego samego fragmentu kodu wielokrotnie. Dodatkową zaletą funkcji jest to, że możemy przesłać do jej wnętrza jakieś wartości dzięki czemu każde wykonanie funkcji może zwrócić inną wartość. Podstawowa struktura każdej funkcji wygląda następująco:
int Nazwa_funkcji(int x, int y)
{
int z = x + y;
return z;
}
Na samum początku określamy typ danych, który ma zostać zwrócony za pomocą wyrażenia return. W naszym przypadku jest to int co oznacza, że funkcja zwróci całkowitą wartość liczbową. Parametr ten może przyjmować także wartość void co oznacza, że funkcja nie zwróci żadnego parametru. Dalej następuje określenie nazwy funkcji pod którą będzie występować. W nawiasie podajemy parametry, które mają być przekazane do funkcji. Wewnątrz nawiasów {} znajduje się całe ciało funkcji, w którym mogą znajdować się różne polecenia. Wnętrze funkcji jest zakończone słówkiem return, o którym mówiliśmy przy pierwszych częściach tego kursy, jednak jeszcze raz przypomnę, służy ono do zwrócenia wartości do programu. Może zauważyłeś już uwagę, że cały czas używałeś funkcji, choć może nie zdawałeś sobie zbytnio z tego sprawy. Była to funkcja mail().
Uwaga !!!
Aby można było odróżnić nazwy funkcji od zmiennych
ich nawy zakończone są nawiasami ()
Stwórzmy teraz prosty programik wykorzystujący funkcje, jego działanie omówię później.
#include
#include
#pragma hdrstop

int suma(int x, int y);

int main()
{
cout << endl << suma(31,1489);
cout << endl << suma(4123,123);
cout << endl << suma(32,12);
getch();
return 0;
}

int suma(int x, int y)
{
int z = x + y;
return z;
}
//-----------------------------------------------------
Całe ciało funkcji znajduje się dopiero po głównej funkcji programu, czyli mail() Należało jednak zadeklarować naszą funkcję zaraz przed nią:
int suma(int x, int y);
Co prawda można było także całą funkcję umieścić w miejscu jej deklaracji, jednak sposób, który wykorzystałem w powyższym przykładzie jest częściej stosowany.

Pliki

Czym jest plik, to chyba wie każdy, jednak nasuwa się pytanie jak obsługiwać pliki z poziomu własnego programu napisanego w C/C++? Tym problemem właśnie zajmiemy się w tym rozdziale.

Każdy program w C w momencie uruchomienia ma otwarte 3 pliki:

- stdin - plik będący standardowym wejściem (tylko do odczytu);
- stdout - plik będący standardowym wyjściem (tylko do zapisu);
- stderr - plik będący standardowym strumieniem błędów (tylko do zapisu);

Będące standardowo monitorem i klawiaturą, jednak nas interesują pliki przechowywane na dyskach.

Wyróżniamy dwa typy plików:
- tekstowe
- binarne
Różnica między nimi jest taka, że w plikach tekstowych przechowywane są tylko i wyłącznie znaki zapisane w kodzie ASCII, natomiast w plikach binarnych zawartość jest dowolna i informacje są tam zapisane bit po bicie w odpowiedniej kolejności. Na początek zadeklarujmy sobie zmienną plikową:

FILE *plik;

Jak zauważyłeś, zmienna ta jest wskaźnikiem typu FILE (zwróć uwagę na wielkość liter!). Pliki otwieramy funkcja fopen(), której parametrami są ścieżka dostępu i nazwa pliku, a drugim parametrem jest tryb otwarcia. Wyróżniamy kilka trybów:

- r - plik tekstowy otwarty do pisania
- w - plik tekstowy otwarty do zapisu
- a - plik tekstowy otwarty do dodawania zawartości
- rb - plik binarny otwarty do czytania
- wb - plik binarny otwarty do zapisu
- ab - plik binarny otwarty do dodawania zawartości.

Dodatkowo istnieją kombinacje z trybów z dodanym plusem na końcu np. "r+" otwierające pliki w trybie modyfikacji - czyli możliwy jest zapis i odczyt równocześnie.

Przykład instrukcji otwierającej plik tekstowy do zapisu z dyskietki A:

#include <stdio.h>
main()
{
FILE *plik;
Plik=fopen("a:\\text.txt","w");
}

Po każdym użyciu pliku, należy go zamknąć, oczywiście po zakończeniu programu, plik zamknie się samoczynnie, jednak w trakcie działania programu, może zdarzyć się sytuacja, w której musimy działać na tym samym pliku w różnych trybach. Pliki zamyka się funkcją fclose(), przykład;

fclose(plik);

Ok. problem otwierania i zamykania plików mamy za sobą. Teraz pora na zapisywanie informacji do stworzonego pliku. Można to wykonać na naprawdę wiele sposobów. Można zapisywać do pliku pojedyncze znaki lub całe łańcuchy. Problem zapisu i odczytu z plików ograniczymy tylko i wyłącznie do plików tekstowych, gdyż w plikach binarnych robi się to analogicznie.

1. wprowadzanie danych znak po znaku:

Operację tę będziemy wykonywać za pomocą funkcji fputc(). Przykład:

#include <stdio.h>
#include <conio.h>
main()
{
FILE *plik;
char znak;

plik=fopen("a:\\plik.txt","w");
do
{
znak=getch();
fputc(znak,plik);
}
while(znak!=65);
fclose(plik);
}

Przeanalizujmy to krok po kroku. Na wstępnie zadeklarowaliśmy zmienną plikową oraz zmienną znak typu char, potrzebną do odczytywania danych z klawiatury. Następna linia otwiera plik o nazwie "plik.txt" na dyskietce do zapisu danych. I tu widzimy pętlę, będzie ona się powtarzać, dopóki nie zostanie wciśnięta duża litera A (kod 65 odpowiada właśnie dużej literze A w kodzie ASCII). W pętli pojawia się nowa funkcja - getch(), jest ona odpowiedzialna za pobranie znaku z klawiatury bez czekania na potwierdzenie klawiszem ENTER, jak to jest w przypadku funkcji scanf(). Czyli wystarczy wcisnąć jakiś klawisz i funkcja getch() przypisze go do zmiennej znak. Kolejna linia zapisuje pobrany wcześniej znak do pliku za pomocą wcześniej wspomnianej funkcji fputc(). Za pętlą zamykamy plik. Jasne? Mam nadzieję, że tak. W skrócie można jeszcze napisać że program pobiera znak z klawiatury i od razu zapisuje go pliku; skompiluj ten program i sprawdź jego działanie.

2. wprowadzenie łańcucha znaków do pliku.

Powyższy przykład pokazuje jak zapisywać pojedyncze znaki do pliku, jednak, jeżeli będziemy chcieli wprowadzić cały wyraz użyjemy funkcji fprintf() - wygląda znajomo prawda? Spójrz na przykład:

#include <stdio.h>
#include <conio.h>
main()
{
FILE *plik;
char wyraz[10];

plik=fopen("a:\\plik.txt","w");
scanf("%s",&wyraz);
fprintf(plik,"%s",wyraz);

fclose(plik);
}

Jak widać, pobieramy wyraz z klawiatury za pomocą funkcji scanf() a następnie zapisujemy go do pliku funkcją fprintf(). Różni się ona od standardowego printf() tym, że posiada jeszcze jeden parametr - zmienną plikową na początku.
No tak, problem zapisu mamy już za sobą, teraz przydałoby się nauczyć odczytywać z pliku. Wykonamy to również na dwa sposoby: pobieranie zawartości znak po znaku oraz pobieranie łańcuchów. Jednak zanim do tego dojdziemy musimy wiedzieć, że odczyt z pliku nie może trwać wiecznie, czyli musimy nauczyć się sprawdzać koniec pliku. Wykonuje się to na dwa sposoby, albo poprzez stała EOF lub funkcję feof(), ja opiszę tę drugą. Funkcja feof() sprawdza czy nastąpił koniec pliku jak już wcześniej się dowiedziałeś, jednak jak ją zaimplementować? Stwórzmy pętlę:

do
{
.....
.....
}
while(!feof(plik));

Pętla będzie się powtarzać aż do momentu nastąpienia końca pliku (dopuki nie koniec pliku - dosłowne tłumaczenie warunku końca pętli).
Dlaczego sprawdzamy koniec pliku? Ponieważ gdybyśmy to ominęli to: albo program nie odczytałby wszystkich danych z pliku lub wygenerował błędy, lub nawet się zawiesił, gdyż próbowałby czytać poza plikiem. Dobrze, przejdźmy więc do czytania:

1. odczyt znak po znaku:

Wykonamy to podobnie do zapisu znak po znaku, spójrz na przykład:

#include <stdio.h>
#include <conio.h>
main()
{
FILE *plik;
char znak;

plik=fopen("a:\\plik.txt","r");
do
{
znak=fgetc(plik);
printf("%c",znak);
}
while(!feof(plik));
}

Do odczytu znaku z pliku służy funkcja fgetc(), której parametrem jest wskaźnik do pliku.

2. odczytanie łańcucha znaków z pliku

Powyższy przykład prezentuje odczyt znak po znaku, jednak jak zrobić aby odczytywać łańcuchy? Wykonamy do na dwa sposoby, funkcją fscanf() oraz fgets().
Funkcję fscanf() używa się podobnie jak funkcji scanf(), z tą różnicą , że dodatkowym parametrem jest wskaźnik do pliku, przykład:

#include <stdio.h>

main()
{
FILE *plik;
char slowo[10];

plik=fopen("a:\\plik.txt","r");
do
{
fscanf(plik,"%s",&slowo);
printf("%s",slowo);
}
while(!feof(plik));
fclose(plik);
}

Ten rodzaj pobierania łańcucha znaków ma pewną wadę - mianowicie opuszcza wszystkie spacje!!!, tworząc przy tym nieczytelny napis. Dlatego też częściej używa się funkcji fgets(), przykład:

#include <stdio.h>
main()
{
FILE *plik;
Char wyraz[20];
Plik=fopen("a:\\plik.txt","r");
Do
{
fgets(wyraz,20,plik);
printf("%s",wyraz);
}
while(!feof(plik));
fclose(plik);
}

Funkcja fgets() posiada trzy parametry, pierwszy z nich określa zmienną, pod jaką ma być wczytywany łańcuch znaków, drugi jego długość, oraz trzeci zmienną plikową. O co chodzi z tą długością? Otóż musimy podać kompilatorowi ilość znaków łańcuchu jaki pobieramy, jeżeli w pliku mamy napis składający się z 10 znaków a jako długość określimy 20, to ostatnie znaki zostaną powielone.

Ok., przebrnęliśmy przez zapis i odczyt danych z pliku. Chcę teraz w tym miejscu nadmienić, dość istotna sprawę. Wyobraź sobie, że plik jest zbudowany z komórek określonej pojemności (jest to umowny zapis, z którym może nie zgodzić się większość programistów - wprowadzam to jednak w celu łatwiejszego zrozumienia tematu), ułożonych szeregowo. Gdy zapisujemy jakieś dane, to umieszczane są one w tych komórkach. Po otwarciu pliku wskaźnik pliku umieszczony jest na początku - czyli wskazuje na pierwszą komórkę. W trakcie odczytu czy też zapisu, wskaźnik ten przemieszcza się - podczas zapisu wskazuje, następną wolną komórkę w szeregu, w trakcie odczytu - aktualnie jeszcze nie odczytaną komórkę.
Gdy chcemy cofnąć nasz wskaźnik z powrotem do początku pliku musimy użyć funkcji rewind().
Gdy chcemy pobrać aktualną pozycję wskaźnika użyjemy funkcji fgetpos(), natomiast gdy chcemy ustawić położenia wskaźnika funkcji fsetpos(), lub fseek(). Teraz nie będę wyjaśniał składni i działania tych funkcji - dostępne to jest w dodatku B niniejszego kursu.

Mam nadzieję, że wszystko jest jasne, jeżeli jednak nie to proponuję sięgnąć do HELPA kompilatora. W rozdziale tym nauczyłeś, się praktycznie większości niezbędnych ci rzeczy pozwalających swobodne korzystanie z plików.