w C Zak lad Chemii Teoretycznej UJ 30 listopada 2006
1 2 3
Inicjalizacja zmiennych Zmienne jednowymiarowe można inicjować przy ich definicji. #include <math. h> i n t x = 1 ; l o n g day = 1000L * 60L * 60L * 24L ; double y = 2. 0 ; double z = s q r t ( y * y ) ; Zmienne zewnetrzne i statyczne moga być inicjalizowane tylko wyrażeniem sta lym. #include <math. h> double x = 2 ; s t a t i c double y = x * x ; // b l a d Dotyczy to również każdej inicjalizacji wymagajacej użycia nawiasów klamrowych (C99 usuwa takie ograniczenie). double x = 2. 0 ; double y [ ] = { 2. 0, 2. 0 * 2. 0 ; // poprawne double z [ ] = {x, x * x ; // blad w C89, poprawne w C99
typedef Plan typedef specyfikator typu nazwa S luży do stworzenia nowej nazwy dla jakiegoś typu. Nazwa ta b edzie mog la być używana we wszystkich miejscach, w których użylibyśmy oryginalnego specyfikatora typu. t y p e d e f double zarobki ; t y p e d e f char * Napis ; t y p e d e f Napis m i e s i a c e [ 3 ] ; //?? z a r o b k i a ; z a r o b k i *b [ 1 0 ] ; Napis c = a l a ; m i e s i a c e l a t o, j e s i e n = { w r z e s i e n, p a z d z i e r n i k, l i s t o p a d ;
sizeof Plan operator jednoargumentowy sk ladnia: sizeof (nazwa typu) sizeof (obiekt) sizeof obiekt zwraca wartość typu ca lkowitego bez znaku odpowiadajac a rozmiarowi obiektu (zmiennej danego typu) wyliczany na etapie kompilacji, wyjatek stanowi użycie do tablic o dynamicznym rozmiarze (C99)
Jeszcze o sizeof Plan i n t a ; double b [ 3 ] ; s i z e o f ( f l o a t ) ; s i z e o f a ; s i z e o f ( b ) ; // r o z m i a r t a b l i c y (w b a j t a c h, n i e w l i c z b i e elementow ) s i z e o f ( b [ 0 ] ) ; // r o z m i a r elementu i n t n o e l e m e n t s = s i z e o f ( b ) / s i z e o f ( b [ 0 ] ) ; size t: typ danych definiowany w bibliotece standardowej, tak aby odpowiada l typowi zwracanemu przez operator sizeof
Podzia l programu na funkcje Każdy program w C zawiera przynajmniej jedna funkcje, która jest funkcja main. Po co w ogóle wydzielać inne fragmenty jako funkcje? przejrzystość, jeśli pewien ciag operacji tworzy logiczna ca lość, wyodrebnienie go jako funkcji u latwia zrozumienie treści programu i poprawia jego strukture wygoda, jeśli pewien ciag operacji jest powtarzany wielokrotnie na różniacych sie od siebie wartościami argumentach, wyodrebnienie go w postaci funkcji pozwala uniknać powtarzania prawie identycznego kodu przenośność i możliwość wielokrotnego wykorzystania, funkcje można skompilować do osobnych plików (czy stworzyć biblioteki) i do l aczać do tworzonych programów w razie potrzeby
Definicja funkcji Plan /* t y p z w r a c a n e j w a r t o s c i nazwa ( l i s t a d e k l a r a c j i a r g u m e n t o w ) {......... */ i n t mojabs ( i n t a ) { r e t u r n ( a < 0? a : a ) ;
Deklaracje funkcji Użycie funkcji wymaga jej wcześniejszego zadeklarowania. Deklaracj e stanowi również sama definicja funkcji. // w e r s j a p i e r w s z a #i n c l u d e <s t d i o. h> i n t min ( i n t a, i n t b ) { // d e f i n i c j a p e l n i r o l e d e k l a r a c j i r e t u r n ( a < b? a : b ) ; i n t main ( ) { i n t x = 2, y = 4 ; p r i n t f ( %d, min ( x, y ) ) ; r e t u r n 0 ;
Deklaracje funkcji II /* d e k l a r a c j a : t y p z w r a c a n e j w a r t o s c i n a z w a f u n k c j i ( l i s t a t y p o w a r g u m e n t o w z o p c j o n a l n y m i n a z w a m i ) */ // w e r s j a druga #i n c l u d e <s t d i o. h> i n t min ( i n t, i n t ) ; // d e k l a r a c j a i n t main ( ) { i n t x = 2, y = 4 ; p r i n t f ( %d, min ( x, y ) ) ; r e t u r n 0 ; i n t min ( i n t a, i n t b ) { r e t u r n ( a < b? a : b ) ;
Specjalne deklaracje /* funkcja o konkretnej, a l e nieznanej w momencie deklarowania l i c z b i e i t y p i e argumentow */ i n t f o o ( ) ; /* f u n k c j a o z e r o w e j l i c z b i e argumentow */ i n t f o o ( v o i d ) ; /* p i e r w s z y argument f u n k c j i j e s t typu c h a r *, moga t e z p o j a w i c s i e i n n e argumenty o nieznanym a p r i o r i t y p i e i l i c z b i e */ i n t p r i n t f ( char *,... ) ; Standardy wcześniejsze niz C99 dopuszczaja domyślna deklaracje. /* min nie zadeklarowane, domyslna d e k l a r a c j a ma p o s t a c i n t min ( ) ; */ i n t main ( ) { i n t x = 2, y = 4 ; p r i n t f ( %d, min ( x, y ) ) ; r e t u r n 0 ;
Deklarowanie funkcji jako inline Deklarowanie funkcji jako inline jest sugestia dla kompilatora, żeby zastapi l w kodzie wywo lania funkcji jej rozwiniet a treścia. #i n c l u d e <s t d i o. h> i n l i n e i n t min ( i n t, i n t ) ; // d e k l a r a c j a f u n k c j i typu i n l i n e i n t main ( ) { i n t x = 2, y = 4 ; p r i n t f ( %d, min ( x, y ) ) ; r e t u r n 0 ; i n t min ( i n t a, i n t b ) { r e t u r n ( a < b? a : b ) ; /* Funkcja main po r o z w i n i e c i u */ i n t main ( ) { i n t x = 2, y = 4 ; p r i n t f ( %d, ( x < y? x : y ) ) ; r e t u r n 0 ;
Przekazywanie argumentów do funkcji Argumenty sa przekazywane do funkcji zawsze przez wartość. Oznacza to, że w momencie wywo lania tworzone sa lokalne kopie przekazanych zmiennych(obiektów), które sa używane wewnatrz funkcji. v o i d swap ( i n t a, i n t b ) { i n t tmp = a ; a = b ; b = tmp ; v o i d s w a p c o r r e c t e d ( i n t *a, i n t *b ) { i n t tmp = *a ; *a = *b ; *b = tmp ; i n t main ( ) { i n t x = 2, y = 4 ; swap ( x, y ) ; p r i n t f ( %d %d, x, y ) ; // w y p i s z e : 2 4 s w a p c o r r e c t e d ( x, y ) ; p r i n t f ( %d %d, x, y ) ; // w y p i s z e : 4 2 r e t u r n 0 ;
Użycie zmiennych zewn etrznych w celu przekazania argumentów Pewnym sposobem przekazania argumentów do funkcji jest użycie zmiennych zewn etrznych. i n t x = 2, y = 4 ; v o i d swap ( ) { i n t tmp = x ; x = y ; y = tmp ; i n t main ( ) { swap ( ) ; r e t u r n 0 ; Stanowi to zazwyczaj również świetny sposób na uczynienie kodu mniej odpornym na b l edy.
Wejście i wyjście z funkcji Wejście do funkcji nastepuje w chwili napotkania instrukcji nazwa funkcji(lista argumentów). Wyjście z funkcji nastepuje w momencie napotkania instrukcji return wyrazenie; badź nawiasu klamrowego ja kończacego. Funkcja zadeklarowana jako zwracajaca wartość powinna we wszystkich punktach wyjścia być zaopatrzona w instrukcje return wyrazenie; (wymóg od standardu C99). double min ( double a, double b ) { r e t u r n ( a < b? a : b ) ; double min ( double a, double b ) { i f ( a < b ) r e t u r n a ; e l s e r e t u r n b ; v o i d swap ( double *a, double *b ) { i n t tmp = *a ; *a = *b ; *b = tmp ; r e t u r n 0 ; // b l a d
Rekurencja Plan Funkcja rekurencyjna, to taka, która bezpośrednio lub pośrednio wywo luje sama siebie. // n! unsigned long s i l n i a ( i n t n ) { i f ( n > 1) r e t u r n n * s i l n i a ( n 1 ) ; r e t u r n n ; // n a j w i e k s z y wspolny d z i e l n i k i n t nwd ( i n t m, i n t n ) { i f (! n ) r e t u r n n ; r e t u r n nwd ( n, m % n ) ; Rekurencyjnie czy iteracyjnie? krótszy i prostszy kod zazwyczaj mniej efektywne wykonanie
Definiowanie Plan typ zwracanej wartości ( nazwa wskaźnika)(lista typow argumentow) Funkcja, podobnie jak zmienna, musi mieć swoje określone miejsce w pamieci. Jeśli tak to z funkcja kojarzony jest adres, i nie ma przeszkód, żeby wskazywa l na nia wskaźnik. Typ wskaźnika na funkcje jest określony przez typ zwracanej wartości i liste typów argumentów.
Jak ich używać? Plan v o i d m y i n t f u n c ( i n t x ) { p r i n t f ( %d\n, x ) ; i n t main ( ) { v o i d (* f o o ) ( i n t ) ; f o o = &m y i n t f u n c ; // p r z y p i s a n i e a d r e s u do w s k a z n i k a foo = my int func ; // mozna i tak f o o ( 2 ) ; // wywolujemy tak (* f o o ) ( 2 ) ; // a l b o tak r e t u r n 0 ;
Po co ich używać? /* b i b l i o t e c z n a f u n k c j a s o r t u j a c a */ v o i d q s o r t ( v o i d * f i e l d, s i z e t nelements, s i z e t sizeofanelement, i n t (* cmpfunc ) ( c o n s t v o i d *, c o n s t v o i d * ) ) ; v o i d q s o r t (..., i n t (* cmpfunc ) ( c o n s t v o i d *, c o n s t v o i d *)) { /* sortowanie uwaga item1, item2 sa typu void* */ i n t b i g g e r = cmpfunc ( item1, item2 ) ; // c a l l b a c k /* u z y c i e wyniku */
Na bia lym koniu Plan #i n c l u d e < s t d l i b. h> // q s o r t #i n c l u d e <s t d i o. h> // p r i n t f i n t CmpFunc ( const void * a, const void * b ) { c o n s t i n t * a = a ; c o n s t i n t * b = b ; i f (* a > *b ) r e t u r n 1 ; e l s e i f (* a == *b ) r e t u r n 0 ; e l s e r e t u r n 1; i n t main ( ) { i n t f i e l d [ 1 0 0 ] ; for ( i n t i = 0 ; i < 1 0 0 ; i ++) f i e l d [ i ] = i % 7 ; q s o r t ( f i e l d, /* l i c z b a elementow */ 100, /* r o z m i a r elementu */ s i z e o f ( f i e l d [ 0 ] ), /* w s k a z n i k na f u n k c j e porownujaca */ CmpFunc ) ; for ( i n t i = 0 ; i < 1 0 0 ; i ++) p r i n t f ( e l e m e n t #%d to %d\n, i +1, f i e l d [ i ] ) ; r e t u r n 0 ;