Stuck in the loop. Sterowanie. Marcin Makowski. 29 października Zak lad Chemii Teoretycznej UJ

Transkrypt

1 Sterowanie Zak lad Chemii Teoretycznej UJ 29 października 2007

2

3 arytmetyczne +, -, *, / % (dzielenie modulo) operatory sa lewostronnie l aczne priorytety: (*, /, %), (+, -) nie istnieje operator pot egowania

4 i relacje logiczne I relacji >, >=, <, <= == (równy),!= (różny od) logiczne! (negacja) && (koniunkcja) (alternatywa)

5 i relacje logiczne II Priorytety:!, operatory arytmetyczne, (>, >=, <, <=), (==,!=), &&, Koniec obliczania wartości wyrażenia logicznego nast epuje natychmiast po określeniu jego wyniku (?) i f ( i < s i z e && j!= 3) Numeryczna wartościa prawdziwego wyrażenia jest 1, fa lszywego 0 Operator negacji zamienia argument różny od zera na 0, argument równy zeru na 1 (?) i n t i ; i f (! i ) // oznacza to samo, co i f ( i == 0)

6 przypisania i n t i, j = 7 ; i = j ; // zwykle przypisanie, wartosc i s t a j e s i e rowna wartosci j i += j ; // i = i + j (+= to t e z o p e r a t o r p r z y p i s a n i a ) i *= j ; i = j ; i /= j ; i %= j ; Wyrażenie przypisania ma wartość: typem jest typ lewego argumentu wartościa jest przypisana wartość i n t c ; while ( ( c = getchar ( ) )!= EOF) // typ : int, wartosc : znak z wejsc ia

7 inkrementacji i dekrementacji i n t i ; double x ; i ++; // z w i e k s z a w a r t o s c z m i e n n e j i o 1 x ; // z m n i e j s z a w a r t o s c z m i e n n e j x o 1 Forma przedrostkowa i przyrostkowa ++i (zwi eksza wartość zmiennej i przed jej użyciem) i++ (zwi eksza wartość zmiennej i po jej użyciu) i n t i = 2, j = 2, k, l ; k = ++i ; // k b e d z i e rowne 3 l = j ++; // l b e d z i e rowne 2 Operator mozna zastosować tylko do zmiennej: i n t i = 2, j = 1 ; i ++; // poprawne ( i * j )++; // niepoprawne

8 if... Najprostszy model to zachowanie typu jeśli a jest prawda to wykonaj b... i f ( w y r a z e n i e ) i n s t r u k c j a ; // wykonana j e s l i w y r a z e n i e j e s t prawdziwe /* d a l s z e i n s t r u k c j e */ i f ( w y r a z e n i e ) { /* b l o k wykonany, j e s l i w y r a z e n i e j e s t prawdziwe */ /* d a l s z e i n s t r u k c j e */

9 if... else zdefiniujmy dodatkowo specyficzne zachowanie w innym przypadku... i f ( w y r a z e n i e ) { /* b l o k wykonany, j e s l i w y r a z e n i e j e s t prawdziwe */ e l s e { /* b l o k wykonany, j e s l i w y r a z e n i e j e s t n i e p r a w d z i w e */ /* d a l s z e i n s t r u k c j e */ i f ( a == b ) p r i n t f ( a j e s t rowne b\n ) ; e l s e p r i n t f ( a n i e j e s t rowne b\n ) ;

10 if... else... else if i skomplikujmy sytuacj e bardziej... i f ( w y r a z e n i e ) { /* b l o k wykonany, j e s l i w y r a z e n i e j e s t prawdziwe */ e l s e i f ( w y r a z e n i e 1 ) { /* blok wykonany, j e s l i wyrazenie j e s t nieprawdziwe i wyrazenie 1 j e s t prawdziwe */ e l s e i f ( w y r a z e n i e 2 ) { /* b l o k wykonany, j e s l i w y r a z e n i e i w y r a z e n i e 1 sa n i e p r a w d z i w e a w y r a z e n i e 2 j e s t pra e l s e { /* b l o k wykonany w p o z o s t a l y c h przypadkach */ /* d a l s z e i n s t r u k c j e */ i f ( a > 0) b = a ; e l s e i f ( a == 0) b = 1 ; e l s e b = 1 / a ;

11 Niejednoznaczne else Gdy w serii zagnieżdżonych instrukcji if nie wszystkie posiadaja cześć else pojawia sie niejednoznaczność przypisania pary if-else. Definicja jezyka rozstrzyga to przypisujac else do najbliższej instrukcji if nie zawierajacej cześci else. i f ( a > 0) i f ( a > b ) c = a ; e l s e // z w i a z a n y z i f ( a > b ) c = b ; i f ( a > 0) { i f ( a > b ) c = a ; e l s e // z w i a z a n y z i f ( a > 0) c = b ;

12 Wyrażenia warunkowe wyr1? wyr2 : wyr3 Obliczane jest wyr1. Jesli jego wartość jest różna od 0 (wyr1 jest prawdziwe), to obliczane jest wyr2 i jego wartość staje sie wartościa ca lego wyrażenia warunkowego. W przeciwnym wypadku obliczane jest wyr3 i to jego wartość staje sie wartościa ca lego wyrażenia warunkowego. i f ( a!= 0) b = 1 / a ; e l s e b = 0 ; b = ( a!= 0)? 1 / a : 0 ; // d o k l a d n i e rownowazne powyzszemu // a = ( 1)ˆb a = ( b & 1)? 1 : 1 ;

13 switch... Decyzje moge podejmować wyliczajac wszystkie możliwości... s w i t c h ( w y r a z e n i e ) { case wyr1 : /* punkt w e j s c i a, j e s l i w y r a z e n i e == wyr1, wyr1 musi byc wyrazeniem s t a l y m */ case wyr2 : /* punkt w e j s c i a, j e s l i w y r a z e n i e == wyr2, wyr2 musi byc wyrazeniem s t a l y m */ default : /* punkt we js cia dla pozostalych przypadkach */ s w i t c h ( d z i e c i ) { case 0 : break ; /* brak d z i e c i c z y l i brak u l g i */ case 1 : podatek = podatek ( podatek / 100 * 2 ) ; /* u l g a 2% */ break ; case 2 : podatek = podatek ( podatek / 100 * 5 ) ; /* u l g a 5%*/ break ; default : podatek = podatek ( podatek / 100 * 1 0 ) ; /* u l g a 10% */ break ;

14 switch + enum switch i enum czesto ida w parze... switch ( k i e r u n e k ) { case W GORE: y++; break ; case W DOL: y ; break ; case W PRAWO: x++; break ; case W LEWO: x ; break ; // n i e k o n i e c z n y

15 while... w h i l e ( warunek ) { /* i n s t r u k c j e wykonywane w p e t l i j a k d l u g o warunek j e s t prawdziwy */ /* d a l s z e i n s t r u k c j e */ Program wypisujacy kwadraty kolejnych liczb od 1 do 10 móg lby wygladać tak... #i n c l u d e <s t d i o. h> i n t main ( ) { i n t a = 1 ; w h i l e ( a < 11) { /* d o p o k i a j e s t m n i e j s z e od 11 */ p r i n t f ( %d\n, a*a ) ; /* wypisujemy kwadrat a */ ++a ; /* zwiekszamy a o j e d e n */ r e t u r n 0 ;

16 do... while do { /* i n s t r u k c j e do wykonania w p e t l i */ w h i l e ( warunek ) ; /* d a l s z e i n s t r u k c j e */ Tym razem wypisujemy używajac tegoż typu petli... #i n c l u d e <s t d i o. h> i n t main ( ) { i n t a = 1 ; do { p r i n t f ( %d\n, a * a ) ; ++a ; w h i l e ( a < 1 1 ) ; r e t u r n 0 ;

17 for... f o r ( w y r a z e n i e 1 ; w y r a z e n i e 2 ; w y r a z e n i e 3 ) { /* i n s t r u k c j e do wykonania w p e t l i */ /* d a l s z e i n s t r u k c j e */ wyrazenie1: inicjalizacje, wykonywane przed wejściem do petli wyrazenie2: warunek, którego prawdziwość jest sprawdzana przed każda iteracja wyrazenie3: wykonywane po każdej iteracji #i n c l u d e <s t d i o. h> i n t main ( ) { i n t a ; f o r ( a = 1 ; a < 11; ++a ) p r i n t f ( %d\n, a * a ) ; r e t u r n 0 ;

18 Operator przecinkowy i wyrażenie przecinkowe Para wyrażeń oddzielona przecinkami. Obliczane od lewej do prawej strony. Typem i wartościa wyrażenia jest typ i wartość prawego argumentu. #i n c l u d e <s t d i o. h> i n t main ( ) { i n t i, j, n = 2 0 ; f o r ( i = 0, j = n ; i < j ; i ++, j ) p r i n t f ( %d %d\n, i, j ) ; r e t u r n 0 ;

19 break i continue Instrukcja break powoduje zakończenie najbardziej zagnieżdżonej p etli lub instrukcji switch, w której wyst epuje. i n t a ; f o r ( a = 1 ; a!= 9 ; ++a ) { i f ( a == 5) break ; p r i n t f ( %d\n, a ) ; Instrukcja continue powoduje zakończenie bieżacej iteracji petli. f o r ( i = 0 ; i < 100 ; ++i ) { p r i n t f ( Poczatek \n ) ; i f ( i > 40) c o n t i n u e ; p r i n t f ( Koniec \n ) ;

20 Etykiety i goto etykieta ma taka postać jak nazwa zmiennej i jest zakonczona dwukropkiem, jej zasiegiem jest ca la funkcja do miejsc wskazanych przez etykiety można bezwarunkowo przenosić sterowanie (instrukcja skoku goto) e t y k i e t a : /* i n s t r u k c j e */ goto e t y k i e t a ; Dlaczego używanie goto jest równie z le jak podk ladanie nogi staruszkom? Odpowiedź: i n t i, j ; f o r ( i = 0 ; i < 10; ++i ) f o r ( j = i ; j < i + 10; ++j ) i f ( i j % 3 == 2) goto koniec ; koniec : /* d a l s z a c z e s c programu */