to get the file

Laboratorium nr 3
Instrukcja
laboratoryjna
3
1)
1/6
Język C
Temat: Funkcje, parametry linii poleceń, typ wyliczeniowy.
Przygotował: mgr inż. Maciej Lasota
Parametry linii poleceń.
Język C oprócz wprowadzania danych za pomocą odpowiednich funkcji biblioteki
standardowej (scanf, sscanf, getchar, getc, gets itp.) umożliwia również tworzenie
programów, w których dane wprowadzane są z linii poleceń (podczas wywoływania
programu) przez użytkownika. Wprowadzanie danych z linii poleceń polega na podaniu listy
argumentów po nazwie programu podczas wywoływania. Obsługa parametrów wymaga
stworzenia odpowiedniej funkcji głównej „main”. Przykład takiej funkcji został przedstawiony
poniżej:
int main(int argc, char *argv[])
{
...
return(0);
}
*argv[ ] – jest to parametr, który jest wskaźnikiem na tablicę znakową zawierającą
wszystkie argumenty wprowadzane z linii poleceń. Pierwszym elementem tablicy argv[0] jest
zawsze nazwa programu.
argc – jest to parametr, który zawiera liczbę całkowitą. Liczba ta określa ilość
przekazywanych argumentów do programu z linii poleceń. Zarazem argc jest indeksem
tablicy argv[ ].
Laboratorium nr 3
2/6
Przykład:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int a,b,wynik;
if(argc != 3)
{
printf("Program dodaje dwie liczby,
podaj dwa parametry !!!\n");
exit(1);
}
a = atoi(argv[1]); //konwersja na liczbe calkowita
b = atoi(argv[2]); //konwersja na liczbe calkowita
printf("Nazwa programu: %s\n",argv[0]);
printf("Parametr A: %d\n",a);
printf("Parametr B: %d\n",b);
wynik = (a+b);
printf("Wynik dodawania: %d\n",wynik);
return (0);
}
2)
Funkcje.
Funkcje umożliwiają podzielenie oraz pogrupowanie często wykonywanego kodu
źródłowego (instrukcji programu) na mniejsze moduły (bloki), które mogą być wielokrotnie
wykorzystywane w programie. Zadaniem funkcji zazwyczaj jest wykonywanie określonych
operacji oraz zwracanie lub też nie określonej wartości. Często ukrywają one w sobie
szczegóły pewnych operacji przed innymi częściami programu, w których znajomość tych
szczegółów jest zbędna lub niewskazana. Wykorzystywanie funkcji w programie daje
większą przejrzystość kodu oraz łatwiejsze wprowadzanie zmian.
Funkcja główna jest to podstawowa funkcja, od której zaczyna działanie każdy
program napisany w języku C. Funkcja ta musi występować w każdym pliku źródłowym, który
kompilujemy i który później będziemy wykonywać jako program (nie dotyczy plików
źródłowych kompilowanych jako moduły). W języku C funkcją główną jest funkcja „main”.
Może ona zwracać określona wartość lub nie zwracać żadnej wartości, wszystkie pozostałe
zdefiniowane funkcje zawsze wywołujemy z wnętrza funkcji „main”.
Laboratorium nr 3
3/6
Deklaracja funkcji w języku C wygląda następująco:
[typ danych funkcji] [nazwa funkcji]([parametry funkcji])
{
[deklaracja zmiennych lokalnych]
instrukcja1;
instrukcja2;
...
[zwracana wartość];
}
Parametry funkcji są to zmienne przekazywane, do ciała funkcji w celu wykonania na
nich operacji (działań). W języku C wszystkie parametry przekazywane są przez wartość,
oznacza to że operujemy jedynie na kopiach zmiennych, a nie na oryginalnych zmiennych.
Zmienne lokalne funkcji są to zmienne widoczne tylko w obrębie danego bloku (ciała
funkcji), tworzone są w momencie inicjowania (wywoływania) i niszczona w momencie
kończenia funkcji. Kolejne wywołanie tej samej funkcji tworzy nowe instancje zmiennych.
Zasięg nazw jest ta cześć programu, wewnątrz której można daną nazwę zmiennej
stosować. W przypadku zmiennych lokalnych funkcji zasięg nazw ogranicza się jedynie do
danego bloku instrukcji (ciała funkcji). Zmienne lokalne o tej samej nazwie, które występują w
różnych funkcjach nie są ze sobą powiązane w żaden sposób.
Przykład:
#include <stdio.h>
#include <stdlib.h>
int warunek(int a, int b)
{
if(a > b)
{
return (1);
}
if(a < b)
{
return (2);
}
return (0);
}
Laboratorium nr 3
4/6
int main(void)
{
int x,y;
printf("Podaj liczbe calkowita \"x\": ");
scanf("%d",&x);
printf("Podaj liczbe calkowita \"y\": ");
scanf("%d",&y);
if(warunek(x,y) == 1)
{
printf("Liczba %d jest
} else if(warunek(x,y)
{
printf("Liczba %d jest
} else
{
printf("Liczba %d jest
}
wieksza od liczby %d\n",x,y);
== 2)
mniejsza od liczby %d\n",x,y);
rowna liczbie %d\n",x,y);
return (0);
}
Przykład:
#include <stdio.h>
#include <stdlib.h>
float suma(float a, float b)
{
return(a+b);
}
float roznica(float a, float b)
{
return(a-b);
}
float iloczyn(float a, float b)
{
return(a*b);
}
float iloraz(float a, float b)
{
return(a/b);
}
Laboratorium nr 3
5/6
int main(int argc, char *argv[])
{
float x,y;
if(argc != 3)
{
printf("Blad!, wywolanie programu: %s [liczba1]
[liczba2]\n",argv[0]);
exit(0);
}
x = atof(argv[1]);
y = atof(argv[2]);
printf("SUMA liczb: %.2f + %.2f = %.4f\n",x,y,suma(x,y));
printf("ROZNICA liczb: %.2f - %.2f = %.4f\n",x,y,roznica(x,y));
printf("ILOCZYN liczb: %.2f * %.2f = %.4f\n",x,y,iloczyn(x,y));
printf("ILORAZ liczb: %.2f / %.2f = %.4f\n",x,y,iloraz(x,y));
return (0);
}
3)
Rekurencja.
Rekurencja lub też rekursja ma miejsce wtedy, gdy dana funkcja w sposób pośredni
lub bezpośredni wywołuje samą siebie. W różnych językach programowania funkcja, która
wywołuje samą siebie nazywana jest funkcją rekurencyjną.
Funkcja rekurencyjna musi spełniać dwa podstawowe założenia:
•
musi posiadać koniec,
•
musi zmniejszać stopień złożoności obliczanego problemu.
Definicja silni spełnia obie zasady rekurencji. Po pierwsze, posiada koniec (określony
warunkiem n = 0). Po drugie, upraszcza początkowy problem, ponieważ obliczenie wartości
wyrażeni (n – 1) jest prostsze niż obliczenie wyrażenia (n).
Przykład:
int silnia(int liczba)
{
if(liczba == 0) return(1);
return(liczba * silnia(liczba-1));
}
Laboratorium nr 3
4)
6/6
Typ wyliczeniowy.
Typ wyliczeniowy „enum” w języku C został stworzony dla zmiennych, które
przechowują tylko ograniczony zbiór wartości. Dostęp do tych wartości odbywa się poprzez
nazwę tzw. etykietę. Język C implementuje typ wyliczeniowy „enum” jako zgodny z typem
całkowitym, dlatego też, poprawnym sposobem przydzielenie wartości do zmiennej jest
podanie numeru określonej etykiety. Ogólna postać instrukcji „enum” jest następująca:
enum nazwa_typu { etykieta1, etykieta2, ... } nazwa_zmiennej;