Funkcje
Program w języku C jest ciągiem funkcji. Funkcje mogą siebie nawzajem wywoływać, natomiast nie wolno zagnieżdżać jednej funkcji w drugiej.
Kolejność funkcji jest dowolna.
O istnieniu funkcji kompilator informowany jest przez jej prototyp umieszczony na początku programu poniżej funkcji nagłówkowych.
Prototyp funkcji zawiera: typ funkcji, jej nazwę oraz w nawiasach typ parametrów. Prototyp zakończony jest średnikiem. np.:
int potega (int,int);
Nagłówek funkcji składa się z typu funkcji, nazwy i listy parametrów ujętej w nawiasach. Nie stawiamy za nim średnika, natomiast w nawiasach klamrowych umieszczamy ciało funkcji czyli instrukcję. Ostatnią instrukcją ciała funkcji jest instrukcja return po której wstawia się zwracany przez funkcje wynik. Jeżeli funkcja nie zwraca wyniku return można pominąć.
Przykład nagłówka:
int potega(int podstawa, int wykładnik)
Funkcję wywołuje się przez jej nazwę w nawiasie wpisując parametry aktualne tego samego typu i w tej samej kolejności jak w nagłówku.
Przykład wywołania funkcji potega:
int a,b,c;
a=2;b=8;
c=potega(a,b);
Zadeklarowane zmienne a i b kopiowane są do parametrów podstawa i wykładnik zadeklarowanych w nagłówku.
#include <stdio.h>
#include <conio.h>
long fib(long);
void main(void)
{
long n;
printf("Podaj n\n");
scanf("%ld",&n);
printf("%ld\n",fib(n));
return;
}
long fib(long n)
{
long i, y1, y2, y;
if((n==0)|| (n==1)) return (1);
y1=1;
y2=1;
for(i=2;i<=n;i++)
{
y=y1+y2;
y1=y2;
y2=y;
}
return y;
}
Program pozwala na obliczenie objętości jednej z wybranych brył.
#include <stdio.h>
#include <math.h>
#define pi 3.141593
double stozek();
double walec();
double prostopad();
void main(void)
{
char s;
printf("Podaj figure\nmozna wybrac:\n");
printf("stozek (s)\twalec (w)\t);
printf("prostopadloscian (p)\n");
scanf("%c",&c);
switch (s)
{
case 's':
printf("V=%5.1f\n",stozek());
break;
case 'w':
printf("V=%5.1f\n",walec());
break;
case 'p':
printf("V=%5.1f\n",prostopad());
break;
}
}
double stozek()
{
double r,h;
printf("Podaj promien i wysokosc\n");
scanf("%lf%lf",&r,&h);
return pi*r*r*h/3;
}
double walec()
{
double r,h;
printf("Podaj promien i wysokosc\n");
scanf("%lf%lf",&r,&h);
return pi*r*r*h;
}
double prostopad()
{
double a,b,c;
printf("Podaj dlugosci krawedzi\n");
scanf("%lf%lf%lf",&a,&b,&c);
return a*b*c;
}
#include <stdio.h>
#include <conio.h>
long fib(long n);
void main(void)
{
long n;
printf("Podaj n\n");
scanf("%ld",&n);
printf("%ld\n",fib(n));
return;
}
long fib(long n)
{
if (n<2)
return (n<2);
else
return fib(n-1)+fib(n-2);
}
Program oblicza dla wczytywanej z klawiatury liczby n wartości silnia, pierwiastek kwadratowy i pierwiastek sześcienny.
#include <stdio.h>
#include <math.h>
double silnia(double);
double pierwkw(double);
double pierwsz(double);
void main()
{
double n;
printf("Podaj wartosc n\n");
scanf("%lf",&n);
printf("silnia=%19.1f\t\n",silnia(n));
printf("pierwiastek kw.=%10.3f\t\n",pierwkw(n));
printf("pierwiasteksz.=%10.3f\t\n",pierwsz(n));
}
double pierwkw(double n)
{double xn,xs,eps;
xs=1;
do
{
xn=(xs*xs+n)/(2*xs);
eps=fabs((xn-xs)/xn);
xs=xn;
}
while(eps>0.0001);
return xn;
}double pierwsz(double n)
{
double xn,xs,eps;
xs=1;
do
{
xn=(2*xs*xs*xs+n)/(3*xs*xs);
eps=fabs((xn-xs)/xn);
xs=xn;
}
while(eps>0.0001);
return xn;
}
double silnia(double n)
{
if (n<=1) return 1;
else return n*silnia(n-1);
}
Zakres widoczności zadeklarowanych zmiennych
Zadeklarowane zmienne wewnątrz bloku (tj. pomiędzy nawiasami { i } ) mają zakres widoczności dotyczący tylko tego bloku i nazywane są zmiennymi lokalnymi. Wyjątek stanowią zmienne zadeklarowane tuż poniżej plików nagłówkowych - "widziane" one są we wszystkich fragmentach programu i noszą nazwę zmiennych globalnych.
#include <stdio.h>
int a;
float gburek (float, float);
main ()
{
float b;
........................;
........................;
{
int c;
........................;
........................;
}
...............................:
}
float gburek (float x, float y)
{
int d
..........................;
..........................;
..........................;
}
Strzałkami zaznaczone zostały obszary widoczności zmiennych: a można używać w całym programie ( i w main i w gburku a ma jedną i tę samą wartość zapewne nadaną w main) Zmienna b jest znana tylko w main, c tylko w jego fragmencie, a d jest znane tylko w funkcji gburek. Oznacza to między innymi, że poza obszarem ważności można wprowadzać zmienne o tych samych nazwach, które będą oznaczały coś zupełnie innego.
Wartość funkcji i parametry
Do funkcji dane przekazywane są przez parametry.
Przepływ informacji w drugą stronę (tj. od funkcji do miejsca jej wywołania) można realizować na dwa sposoby:
przez wartość funkcji
W miejsce, gdzie została wywołana funkcja poprzez swoją nazwę podstawiana jest wartość występująca w funkcji po instrukcji return. W ten sposób przekazana może być przez funkcję tylko jedna wartość.
Przykład:
d=2;
k=10;
............................;
a = potega(d,k);
............................;
............................;
}
long potega(int a, int n)
{
int wynik=a;
while (n > 1)
{
wynik=wynik*a;
n -- ;
}
return (wynik);
}
przez parametry
Drugi sposób przekazywania informacji od funkcji to przekazanie do funkcji adresów argumentów (wskaźniki do nich) zamiast ich wartości. W ten sposób zmiana parametrów wewnątrz funkcji jest "zauważana" w bloku funkcję tę wywołującą. Tą metodą można przekazać od funkcji szereg wartości.
Przykłady
(1)_
#include <stdio.h>
int przyk(double *,double*);
void main()
{
double *a,*b,c,d;
int i;
a=&c;
b=&d;
c=15.1;
d=5.3;
printf("c=%5.1f d=%5.1f\n\n",c,d);
printf("a=%5.1f b=%5.1f\n\n",*a,*b);
i=przyk(a,b);
printf("i=%d c=%5.1f d=%5.1f\n\n",i,c,d);
printf(" a=%5.1f b=%5.1f\n\n",*a,*b);
return;
}
int przyk(double *a,double *b)
{
int k;
k=*a+*b;
*a=221.2;
*b=1.1;
return k;
}
(2)
#include <stdio.h>
void przyk(double *);
void main()
{
double d;
d=25.4;
printf("d=%5.1f\n\n",d);
przyk(&d);
printf("d=%5.1f\n\n",d);
return;
}
void przyk(double *c)
{
*c=1.1;
return;
}
INFORMATYKA WYKŁAD 4 Temat: Język C 8
dla n mniejszego od 2 ta instrukcja zwraca "prawdę" czyli 1
Liczby Fibonacciego obliczane z wykorzystaniem rekurencji
Ciało funkcji fib(long n). W zależności od wartości n
funkcja zwraca 1 lub obliczoną wartość y- stąd dwie instrukcje return.
Nagłówek funkcji fib()
funkcja main() jedyna, która nie posiada prototypu. Ponieważ jest typu void ("pusty")
instrukcja return jest niekonieczna
prototyp funkcji fib(long)
pliki nagłówkowe
Liczby Fibonacciego - są to liczby, z których każda kolejna jest równa sumie dwóch poprzednich.
fn = fn-1 + fn-2
f0=1 i f1=1
to są tzw. formalne parametry
funkcji
parametry aktualne
funkcji
wartości parametrów aktualnych d i k są przekopiowywane
do parametrów formalnych a i n.
Parametr n zmienia się w funkcji z 10 na 1,
ale nie ma to wpływu na wartość k
otrzymany wynik: 1024
jest podstawiany w
to miejsce
wywołanie funkcji fib(n)
Przekazywanie
informacji od funkcji
poprzez wskaźniki
Wyszukiwarka