Programowanie Proceduralne

Transkrypt

Funkcje
czyli jak programować proceduralne.
1
Struktura programu w C
/∗ Dyr ekt y wy p r e p r o c e s o r a ∗/
# include < s t d i o . h>
# define PI 3 . 1 4 1 5
/∗ Zmienne g l o b a l n e ∗/
float g = 2 . 5 ;
float kwadrat ( float x )
{
return x∗x ;
}
/∗ D e f i n i c j e f u n k c j i ∗/
/∗ F u n k c j a glowna ∗/
int main ( )
{
float x , y ;
/∗ Zmienne l o k a l n e ∗/
x = PI ∗ g ;
y = kwadrat ( x ) ;
/∗ I n s t r u k c j e ∗/
return 0 ;
}
2
Funkcje = podprogramy
Podprogram
wydzielony fragment programu (kodu) zawierający instrukcje do
wielokrotnego użytku
• Dekompozycja złożonego problemu na prostsze
• Przejrzystość
• Unikanie powtórzeń kodu
• Uniwersalność - jak najmniejszy związek z konkretnym kodem
• Biblioteki funkcji
• Nic za darmo - wywołanie funkcji to dodatkowy koszt czasu i
pamięci
• Rekurencja(Rekurencja(Rekurencja(Rekurencja(...))))
3
Anatomia funkcji
Deklaracja funkcji (prototyp)
Zapowiedź użycia funkcji - określenie nazwy funkcji, typów
argumetów i typu wartości zwracanej
typ identyfikator(typ arg1, typ arg2, ... );
Definicja funkcji
Deklaracja parametrów i instrukcje podprogramu (ciało funkcji).
typ identyfikator(typ arg1, typ arg2, ... )
{
deklaracje zmiennych lokalnych
instrukcje
return wartość;
}
4
Przykłady deklaracji
Deklaracje
Wywołanie
float sin ( float x ) ;
y = sin ( x ) ;
float pierwiastek ( float x ) ;
y = pierwiastek ( 5 . 0 ) ;
void wypiszmenu ( void ) ;
wypiszmenu ( ) ;
int random ( void ) ;
i = random ( ) ;
int nwd ( int a , int b ) ;
i = nwd ( 1 4 4 , a + 1 ) ;
char getchar ( void ) ;
z = getchar ( ) ;
int fff ( int z , char z , float a ) ;
i = fff ( 3 , ’A ’ , 3 . 1 4 ) ;
5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
int nwd ( int a , int b )
{
int c ;
while ( b != 0 )
{
c = a % b;
a = b;
b = c;
}
return a ;
}
int main ( )
{
int a , b ;
printf ( " Podaj dwie liczby calkowite : " ) ;
scanf ( "%d %d" , &a , &b ) ;
printf ( " NWD (%d ,% d) = %d\n" , a , b , nwd ( a , b ) ) ;
return 0 ;
}
euclid3.c
6
Parametry formalne i aktualne funkcji
Parametry formalne
{
int c ;
...
}
Parametry aktualne
float x , y ;
int a=1 , b=2 , c ;
x = sin ( 1 ) ;
c = nwd ( 1 4 4 , b ) ;
y = sin ( x ∗ nwd (1+a , nwd ( 1 0 0 , b ) ) ) ;
W języku C argumenty są przekazywane wyłącznie przez wartość.
7
Funkcje a procedury
Funkcja bez wartości zwracanej - procedura
void wypisz ( int n )
{
while ( n>0 )
{
printf ( " Programowaie proceduralne \n" ) ;
n = n − 1;
}
}
Funkcja z wartością zwracaną
int silnia ( int n )
{
int i =2; x =1;
while ( i <= n )
{
x = x ∗ i;
i = i + 1;
}
return x ;
}
8
Instrukcja return
• return przerywa działanie funkcji i zwraca wartość z funkcji
• Może pojawić się w dowolnym miejscu wewnątrz funkcji
int jest_pierwsza ( int n )
{
int i =2;
while ( i<n )
{
if ( n % i == 0 ) return 0 ;
i = i + 1;
}
return 1 ;
}
Wartość zwracana jest podstawiona w miejsce wywołania
if ( jest_pierwsza ( a ) ) printf ( "%d jest pierwsza \n" , a ) ;
9
Deklaracja i definicja funkcji c.d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/∗ D e k l a r a c j a f u n k c j i ∗/
int jest_pierwsza ( int n ) ;
int main ( )
{
int n , i =1;
printf ( "n = " ) ;
scanf ( "%d" , &n ) ;
while ( i<=n )
{
if ( jest_pierwsza ( i ) == 1 ) printf ( "%d\n" , i ) ;
i++;
}
return 0 ;
}
W momencie
kompilacji musi być
znana przynajmniej
deklaracja funkcji
(jej nazwa i typy
argumentów).
/∗ D e f i n i c j a f u n k c j i ∗/
int jest_pierwsza ( int n )
{
int i =2;
while ( i<=n/i )
{
if ( n % i == 0 ) return 0 ;
i = i + 1;
}
return 1 ;
}
pierwsza2.c
10
Pamięć programu
Sterta
pamięć dostępna do alokacji
zmienne lokalne funkcji wkładane
na stos przy wywołaniu funkcji
Dane
Kod
program
adresy pamięci
Stos
stałe oraz zmienne globalne i
statyczne inicjowane przy
uruchomieniu
tekst programu
tylko do odczytu
11
Zmienne na stosie
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
int c ;
while ( b != 0 )
{
c = a % b;
a = b;
b = c;
}
return a ;
}
int main ( )
{
int a , b , c ;
a = 233;
b = 144;
c = nwd ( a , b ) ;
return 0 ;
}
Sterta
Stos
Dane
Kod
12
Zmienne na stosie
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
int c ;
while ( b != 0 )
{
c = a % b;
a = b;
b = c;
}
return a ;
}
int main ( )
{
int a , b , c ;
a = 233;
b = 144;
c = nwd ( a , b ) ;
return 0 ;
}
Sterta
Stos
main()
a
b
c
return
?
?
?
?
Dane
Kod
13
Zmienne na stosie
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
int c ;
while ( b != 0 )
{
c = a % b;
a = b;
b = c;
}
return a ;
}
int main ( )
{
int a , b , c ;
a = 233;
b = 144;
c = nwd ( a , b ) ;
return 0 ;
}
Sterta
Stos
main()
a
b
c
return
233
144
?
?
Dane
Kod
14
Zmienne na stosie
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
int c ;
while ( b != 0 )
{
c = a % b;
a = b;
b = c;
}
return a ;
}
int main ( )
{
int a , b , c ;
a = 233;
b = 144;
c = nwd ( a , b ) ;
return 0 ;
}
Sterta
Stos
nwd(233,144)
a
b
c
return
233
144
?
?
main()
a
b
c
return
233
144
?
?
Dane
Kod
15
Zmienne na stosie
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
int c ;
while ( b != 0 )
{
c = a % b;
a = b;
b = c;
}
return a ;
}
int main ( )
{
int a , b , c ;
a = 233;
b = 144;
c = nwd ( a , b ) ;
return 0 ;
}
Sterta
Stos
nwd(233,144)
a
b
c
return
1
0
0
1
main()
a
b
c
return
233
144
?
?
Dane
Kod
16
Zmienne na stosie
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
int c ;
while ( b != 0 )
{
c = a % b;
a = b;
b = c;
}
return a ;
}
int main ( )
{
int a , b , c ;
a = 233;
b = 144;
c = nwd ( a , b ) ;
return 0 ;
}
Sterta
Stos
main()
a
b
c
return
233
144
1
?
Dane
Kod
17
Zmienne na stosie
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
int c ;
while ( b != 0 )
{
c = a % b;
a = b;
b = c;
}
return a ;
}
int main ( )
{
int a , b , c ;
a = 233;
b = 144;
c = nwd ( a , b ) ;
return 0 ;
}
Sterta
Stos
main()
a
b
c
return
233
144
1
0
Dane
Kod
18
Zmienne na stosie
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
int c ;
while ( b != 0 )
{
c = a % b;
a = b;
b = c;
}
return a ;
}
int main ( )
{
int a , b , c ;
a = 233;
b = 144;
c = nwd ( a , b ) ;
return 0 ;
}
Sterta
Stos
Dane
Kod
19
Zasięg zmiennych: globalne i lokalne
Zmienna globalna
dostępna dla wszystkich funkcji programu. Zmienna istnieje przez cały
czas działania programu. Deklaracja zmiennej nie znajduje się
wewnątrz żadnej funkcji.
int a ;
void funkcja ( )
{
a = a + 1;
}
Zmienna lokalna (automatyczna)
wewnętrzna zmienna funkcji. Czas życia ograniczony czasem działania
funkcji.
void funkcja ( int a )
{
a = a + 1;
}
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Sterta
# include<s t d i o . h>
int globalna = 0 ;
void f ( void )
{
int lokalna = 0 ;
globalna = globalna + 1 ;
lokalna = lokalna + 1 ;
}
int main ( )
{
int lokalna = 1 3 ;
f () ;
Stos
Dane
globalna
0
return 0 ;
}
Kod
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Sterta
int globalna = 0 ;
void f ( void )
{
int lokalna = 0 ;
}
int main ( )
{
int lokalna = 1 3 ;
f () ;
Stos
main()
lokalna
return
?
?
Dane
globalna
0
return 0 ;
}
Kod
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Sterta
int globalna = 0 ;
void f ( void )
{
int lokalna = 0 ;
}
int main ( )
{
int lokalna = 1 3 ;
f () ;
Stos
main()
lokalna
return
13
?
Dane
globalna
1
return 0 ;
}
Kod
23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Sterta
Stos
int globalna = 0 ;
void f ( void )
{
int lokalna = 0 ;
}
int main ( )
{
int lokalna = 1 3 ;
f () ;
f()
lokalna
0
main()
lokalna
return
13
?
Dane
globalna
1
return 0 ;
}
Kod
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Sterta
Stos
int globalna = 0 ;
void f ( void )
{
int lokalna = 0 ;
}
int main ( )
{
int lokalna = 1 3 ;
f () ;
f()
lokalna
1
main()
lokalna
return
13
?
Dane
globalna
2
return 0 ;
}
Kod
25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Sterta
int globalna = 0 ;
void f ( void )
{
int lokalna = 0 ;
}
int main ( )
{
int lokalna = 1 3 ;
f () ;
Stos
main()
lokalna
return
13
?
Dane
globalna
2
return 0 ;
}
Kod
26
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Sterta
int globalna = 0 ;
void f ( void )
{
int lokalna = 0 ;
}
int main ( )
{
int lokalna = 1 3 ;
f () ;
Stos
main()
lokalna
return
13
0
Dane
globalna
2
return 0 ;
}
Kod
27
Programowanie proceduralne
W programowaniu proceduralnym
nie używamy zmiennych globalnych!
int x=1 , y =1;
Do
br
ze
Źl
int main ( )
{
f () ;
zzz ( ) ;
pewna_funkcja ( ) ;
e
int main ( )
{
int x=1 , y =1;
y = f (x , 10 , x ∗ 2) ;
zzz ( ) ;
x = pewna_funkcja ( x ) ;
printf ( "%d %d\n" , x , y ) ;
}
printf ( "%d %d\n" , x , y ) ;
}
28
Biblioteki standardowe
<assert.h>
<ctype.h>
<float.h>
<limits.h>
<signal.h>
<stddef.h>
<stdio.h>
<math.h>
<stdlib.h>
<string.h>
<time.h>
Asercje - diagnostyka kodu
Klasyfikacja znaków
Ograniczenia typów zmiennopozycyjnych
Ograniczenia typów całkowitych
Obsługa sygnałów
Standardowe definicje (makra)
Operacje wejścia/wyjścia
Funkcje matematyczne
Zestaw podstawowych narzędzi, np. rand()
Obsługa łańcuchów znakowych
Funkcje obsługi czasu
WikiBook: spis plików nagłówkowych biblioteki standardowej
WikiBook: indeks alfabetyczny funkcji z biblioteki standardowej
29
Biblioteka matematyczna
sin
cos
asin
acos
sinh
cosh
exp
ceil
floor
sqrt
pow
log
log10
fabs
fmod
HUGE_VAL
tan
atan
tanh
funkcje trygonometryczne
funkcje hiperboliczne
f. eksponencjalna ex
zaokrąglenia: sufit, podłoga
√
pierwiastek x
potęga xy
logarytm naturalny ln(x) = loge x
logarytm dziesiętny log10 x
wartość bezwzględna |x|
reszta z dzielenia (zmiennoprzecinkowe)
bardzo duża wartość double
Uwaga: korzystając z kompilatora GCC należy dodać opcję -lm
gcc -lm euclid.c
30
Przykład: wzór Herona
Problem: pole trójkąta dla danych długości boków a, b i c.
a
b
c
Wzór Herona (60 n.e.)
S=
q
p(p − a)(p − b)(p − c)
gdzie
1
p = (a + b + c)
2
W jakiej sytuacji wyrażenie pod pierwiastkiem jest mniejsze od 0 ?
31
Przykład: pole trójkąta
1
2
3
4
5
6
7
8
9
10
11
12
13
# include <math . h>
/∗ F u n k c j a wyznacza p o l e t r o j k a t a z wzoru Heroana .
∗ Argumenty a , b i c t o d l u g o s c i bokow .
∗ J e z e l i boki a , b , i c n i e tworza t r o j k a t a
∗ z w r a c a n a j e s t w a r t o s c −1. ∗/
float heron ( float a , float b , float c )
{
float p = ( a+b+c ) / 2 ;
p = p ∗ ( p−a ) ∗ ( p−b ) ∗ ( p−c ) ;
if ( p<0) return −1;
return sqrt ( p ) ;
}
heron2.c
32
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int main ( )
{
float a , b , c , pole ;
printf ( " Podaj dlugosci bokow trojkata : a , b , c > 0\ n" ) ;
scanf ( "%f%f%f" ,&a ,&b ,& c ) ;
if ( a <= 0 | | b <= 0 | | c<=0 )
{
printf ( " Zle dane : wartosci musza byc dodatnie .\ n" ) ;
return 1 ;
}
pole = heron ( a , b , c ) ;
if ( pole < 0 )
{
printf ( " Zle dane : to nie sa boki trojkata \n" ) ;
return 2 ;
}
printf ( " Pole wynosi : %f\n" , pole ) ;
return 0 ;
}
heron2.c
33
Rekurencja
Funkcje mogą wywoływć same siebie - funkcje rekurencyjne.
void funkcja ( )
{
/∗ c i a l o f u n k c j i ∗/
funkcja ( ) ;
}
int main ( )
{
funkcja ( ) ;
}
34
n! = 1 · 2 · 3 · . . . · n = n · (n − 1)!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Sterta
Stos
{
if ( n<=1 ) return 1 ;
return n ∗ silnia ( n−1) ;
}
int main ( )
{
int x , n =3;
x = silnia ( n ) ;
printf ( "%d !=% d\n" , n , x ) ;
return 0 ;
}
Dane
Kod
35
Sterta
Stos
n! = 1 · 2 · 3 · . . . · n = n · (n − 1)!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
}
int main ( )
{
int x , n =3;
x = silnia ( n ) ;
printf ( "%d !=% d\n" , n , x ) ;
return 0 ;
}
main()
n
x
3
?
Dane
Kod
36
Sterta
Stos
n! = 1 · 2 · 3 · . . . · n = n · (n − 1)!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
}
int main ( )
{
int x , n =3;
x = silnia ( n ) ;
printf ( "%d !=% d\n" , n , x ) ;
return 0 ;
}
silnia(3)
n
return
3
?
main()
n
x
3
?
Dane
Kod
37
Sterta
Stos
n! = 1 · 2 · 3 · . . . · n = n · (n − 1)!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
}
int main ( )
{
int x , n =3;
x = silnia ( n ) ;
printf ( "%d !=% d\n" , n , x ) ;
return 0 ;
}
silnia(3)
n
return
3
?
3 ∗ silnia(2)
main()
n
x
3
?
Dane
Kod
38
Sterta
Stos
n! = 1 · 2 · 3 · . . . · n = n · (n − 1)!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
}
silnia(2)
n
return
int main ( )
{
int x , n =3;
x = silnia ( n ) ;
printf ( "%d !=% d\n" , n , x ) ;
return 0 ;
}
3
?
n
return
2
?
silnia(3)
3 ∗ silnia(2)
main()
n
x
3
?
Dane
Kod
39
Sterta
Stos
n! = 1 · 2 · 3 · . . . · n = n · (n − 1)!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
}
silnia(2)
n
return
int main ( )
{
int x , n =3;
x = silnia ( n ) ;
printf ( "%d !=% d\n" , n , x ) ;
return 0 ;
}
3
?
n
return
2
?
2 ∗ silnia(1)
silnia(3)
3 ∗ silnia(2)
main()
n
x
3
?
Dane
Kod
40
Sterta
Stos
n! = 1 · 2 · 3 · . . . · n = n · (n − 1)!
silnia(1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
n
return
1
1
{
}
silnia(2)
n
return
int main ( )
{
int x , n =3;
x = silnia ( n ) ;
printf ( "%d !=% d\n" , n , x ) ;
return 0 ;
}
3
?
n
return
2
?
2 ∗ silnia(1)
silnia(3)
3 ∗ silnia(2)
main()
n
x
3
?
Dane
Kod
41
Sterta
Stos
n! = 1 · 2 · 3 · . . . · n = n · (n − 1)!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
}
silnia(2)
n
return
int main ( )
{
int x , n =3;
x = silnia ( n ) ;
printf ( "%d !=% d\n" , n , x ) ;
return 0 ;
}
3
?
n
return
2
2
2 ∗ silnia(1)
silnia(3)
3 ∗ silnia(2)
main()
n
x
3
?
Dane
Kod
42
Sterta
Stos
n! = 1 · 2 · 3 · . . . · n = n · (n − 1)!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
}
int main ( )
{
int x , n =3;
x = silnia ( n ) ;
printf ( "%d !=% d\n" , n , x ) ;
return 0 ;
}
silnia(3)
n
return
3
6
3 ∗ silnia(2)
main()
n
x
3
?
Dane
Kod
43
Sterta
Stos
n! = 1 · 2 · 3 · . . . · n = n · (n − 1)!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{
}
int main ( )
{
int x , n =3;
x = silnia ( n ) ;
printf ( "%d !=% d\n" , n , x ) ;
return 0 ;
}
main()
n
x
3
6
Dane
Kod
44
Zadanie o rozmnażaniu królików
Problem: zadanie o rozmnażaniu się królików.
Populacja królików rozmnaża się wg. poniższych zasad:
• rozpoczynamy od pojedynczej pary nowonarodzonych
królików,
• króliki stają się płodne po upływie miesiąca życia,
• każda płodna para wydaje na świat parę królików co miesiąc,
• króliki nigdy nie umierają.
Ile par królików będzie w populacji po n miesiącach?
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, . . . ,
45
Przykład: ciąg Fibinacciego
Ciąg Fibinacciego
Fn =


 0
1

 F
n−1 + Fn−2
dla n = 0
dla n = 1
dla n > 1
46
Rekurencja
1
2
3
4
5
6
int fibonacci ( int n )
{
if ( n==0 ) return 1 ;
if ( n==1 ) return 1 ;
return fibonacci ( n−1) + fibonacci ( n −2);
}
fib1.c
Iteracja
1
2
3
4
5
6
7
8
9
10
11
12
13
int fibonacci ( int n )
{
int f=1 , fp =1 , k ;
while ( n>1 )
{
k = f + fp ;
fp = f ;
f = k;
n−−;
}
return f ;
}
fib2.c
47
Podsumowanie
• Zmienne globalne mają zasięg całego pliku, zmienne lokalne
istnieją tylko wewnątrz funkcji
• Programowanie proceduralne: funkcje nie powinny kożystać ze
zmiennych globalnych
• Deklaracja funkcji określa nazwę funkcji, typy argumentów i
typ wartości zwracanej
• Definicja funkcji to deklaracja + ciało funkcji
• Funkcja przed użyciem musi być przynajmniej zadeklarowana
• return zwraca pojedynczą wartość z funkcji
• Pytanie: jak zwrócić z funkcji więcej wartości?
Np. funkcja wyznaczająca miejsca zerowe paraboli.
48
Literatura dodatkowa
David Griffiths, Dawn Griffiths „Rusz głową! C.”, Helion,
Gliwice, 2013.
„Kurs programowania w C”, WikiBooks,
http://pl.wikibooks.org/wiki/C
„C Reference”, http://en.cppreference.com/w/c
49

Programowanie Proceduralne

Transkrypt

Podobne dokumenty

zestaw 7 1/2

język programowania C++

Na diagramie pominięto mniej ważne pola i metody (w

Pętle - zszwg.edu.pl

PODSTAWY PROGRAMOWANIA ĆWICZENIE NR 4 Funkcje

Numer 7 - rumia.edu.pl

Pętla for - zadania

INTENCJE MSZALNE od 21 do 27 listopada 2016 r.

np. f(2

Temat: Rekurencja – wywołujemy samych siebie. Rekurencja to