Programowanie w języku C. Szybki start

2,291 views

Published on

Błyskawiczny kurs programowania aplikacji w języku C

Język C, mimo prawie 30-letniej historii, cieszy się niesłabnącą popularnością wśród programistów. Wszyscy jego użytkownicy cenią w nim prostą i czytelną składnię, niewielki i łatwy do zapamiętania zakres słów kluczowych oraz duże możliwości, dzięki którym za pomocą C można rozwiązać niemal każde zagadnienie programistyczne. Zewnętrzne biblioteki, dostępne w sieci oraz dołączane do najpopularniejszych narzędzi programistycznych, dodatkowo rozszerzają możliwości C.

Książka "Programowanie w języku C. Szybki start" to podręcznik dla tych, którzy chcą poznać C w praktyce i nie chcą przebijać się przez dziesiątki stron opisów teoretycznych. Każde zagadnienie -- od najprostszych, związanych ze strukturą programu i zasadami kompilacji aż do złożonych typów danych i obsługi plików zewnętrznych -- jest przedstawione w postaci bogato ilustrowanej sekwencji czynności. Wykonując kolejne przykłady z książki, poznasz wszystkie podstawowe wiadomości o programowaniu w języku C.

* Struktura programu w języku C
* Typy danych
* Sterowanie działaniem programu
* Korzystanie ze standardowego wejścia i wyjścia
* Deklarowanie i stosowanie funkcji
* Dyrektywy preprocesora
* Wskaźniki i zarządzanie pamięcią
* Obsługa plików
* Złożone typy danych

Poznaj zalety i możliwości najpopularniejszego języka programowania.

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
2,291
On SlideShare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
18
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Programowanie w języku C. Szybki start

  1. 1. IDZ DO PRZYK£ADOWY ROZDZIA£ SPIS TRE CI Programowanie w jêzyku C. Szybki start KATALOG KSI¥¯EK Autorzy: Larry Ullman, Marc Liyanage T³umaczenie: Rafa³ Joñca KATALOG ONLINE ISBN: 83-7361-808-2 Tytu³ orygina³u: C Programming : Visual ZAMÓW DRUKOWANY KATALOG QuickStart Guide (Visual Quickstart Guides) Format: B5, stron: 400 TWÓJ KOSZYK DODAJ DO KOSZYKA B³yskawiczny kurs programowania aplikacji w jêzyku C Jêzyk C, mimo prawie 30-letniej historii, cieszy siê nies³abn¹c¹ popularno ci¹ w ród programistów. Wszyscy jego u¿ytkownicy ceni¹ w nim prost¹ i czyteln¹ sk³adniê, CENNIK I INFORMACJE niewielki i ³atwy do zapamiêtania zakres s³ów kluczowych oraz du¿e mo¿liwo ci, dziêki którym za pomoc¹ C mo¿na rozwi¹zaæ niemal ka¿de zagadnienie ZAMÓW INFORMACJE programistyczne. Zewnêtrzne biblioteki, dostêpne w sieci oraz do³¹czane do O NOWO CIACH najpopularniejszych narzêdzi programistycznych, dodatkowo rozszerzaj¹ mo¿liwo ci C. Ksi¹¿ka „Programowanie w jêzyku C. Szybki start” to podrêcznik dla tych, którzy ZAMÓW CENNIK chc¹ poznaæ C w praktyce i nie chc¹ przebijaæ siê przez dziesi¹tki stron opisów teoretycznych. Ka¿de zagadnienie — od najprostszych, zwi¹zanych ze struktur¹ programu i zasadami kompilacji a¿ do z³o¿onych typów danych i obs³ugi plików CZYTELNIA zewnêtrznych — jest przedstawione w postaci bogato ilustrowanej sekwencji czynno ci. Wykonuj¹c kolejne przyk³ady z ksi¹¿ki, poznasz wszystkie podstawowe wiadomo ci FRAGMENTY KSI¥¯EK ONLINE o programowaniu w jêzyku C. • Struktura programu w jêzyku C • Typy danych • Sterowanie dzia³aniem programu • Korzystanie ze standardowego wej cia i wyj cia • Deklarowanie i stosowanie funkcji • Dyrektywy preprocesora • Wska niki i zarz¹dzanie pamiêci¹ • Obs³uga plików • Z³o¿one typy danych Wydawnictwo Helion Poznaj zalety i mo¿liwo ci najpopularniejszego jêzyka programowania ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl
  2. 2. Spis treści Spis treści Wprowadzenie 9 Dlaczego właśnie język C?........................................................................10 Sposób działania języka C.........................................................................11 Co będzie potrzebne? ................................................................................12 O ksią ce ...................................................................................................13 Uzyskanie pomocy ....................................................................................15 Rozdział 1. Zaczynamy przygodę z językiem C 17 Składnia podstawowa................................................................................18 Wyświetlanie tekstu ..................................................................................21 Kompilacja i uruchomienie programu.......................................................23 Unikanie zamknięcia aplikacji ..................................................................28 Dodanie komentarzy do kodu źródłowego................................................30 Spis treści Stosowanie białych znaków ......................................................................33 Rozdział 2. Typy danych 35 Poprawna składnia zmiennych ..................................................................36 Przypisanie wartości do zmiennej .............................................................40 Wyświetlanie zmiennych ..........................................................................41 Znaki..........................................................................................................44 Ciągi znaków.............................................................................................46 Stałe...........................................................................................................48 Rozdział 3. Liczby 51 Wybór odpowiedniego typu danych numerycznych .................................52 Operacje arytmetyczne ..............................................................................55 Operatory inkrementacji i dekrementacji ..................................................60 Kolejność wykonywania operatorów ........................................................63 Przepełnienie i niedomiar..........................................................................66 Konwersja zmiennych ...............................................................................70 Rozdział 4. Struktury sterujące 73 Instrukcja warunkowa if............................................................................74 Operatory logiczne i porównania.................................................................77 Klauzule else i else if ................................................................................81 5
  3. 3. Spis treści Operator trójargumentowy ........................................................................84 Instrukcja switch .......................................................................................87 Pętla while .................................................................................................90 Pętla for .....................................................................................................94 Rozdział 5. Standardowe wejście i wyjście 97 Pobranie pojedynczego znaku ...................................................................98 Pobranie całego słowa.............................................................................103 Odczyt danych liczbowych .....................................................................107 Odczyt wielu wartości.............................................................................111 Walidacja otrzymanych danych ..............................................................116 Zaawansowane wykorzystanie funkcji printf() .......................................120 Rozdział 6. Tablice 123 Wprowadzenie do tablic..........................................................................124 Przypisywanie wartości do tablicy ..........................................................126 Dostęp do wartości tablicy ......................................................................131 Definiowanie tablic za pomocą stałych...................................................134 Przechodzenie przez elementy tablicy w pętli.........................................136 Spis treści Tablice znaków .......................................................................................139 Tablice wielowymiarowe ........................................................................144 Rozdział 7. Tworzenie własnych funkcji 149 Tworzenie prostych funkcji.....................................................................150 Funkcje przyjmujące argumenty ..............................................................154 Tworzenie funkcji zwracającej wartość ..................................................159 Tworzenie funkcji typu inline .................................................................165 Rekurencja...............................................................................................168 Zasięg zmiennych....................................................................................172 Rozdział 8. Preprocesor języka C 177 Wprowadzenie do preprocesora języka C ...............................................178 Wykorzystanie stałych ............................................................................185 Makra przypominające funkcje ................................................................188 Makra jako funkcje i przyjmowanie argumentów...................................191 Tworzenie i dołączanie plików nagłówkowych ......................................196 Dołączanie plików nagłówkowych..........................................................200 Tworzenie warunków ..............................................................................203 6
  4. 4. Spis treści Rozdział 9. Wskaźniki 207 Program w pamięci komputera .................................................................208 Operator pobrania adresu zmiennej.........................................................210 Przechowywanie i pobieranie adresów ze zmiennych wskaźnikowych....214 Inne spojrzenie na zmienne wskaźnikowe ..............................................218 Dereferencja zmiennych wskaźnikowych ...............................................220 Przekazanie adresu do funkcji.................................................................224 Tablice, wskaźniki i arytmetyka wskaźnikowa .......................................228 Tablice wskaźników ................................................................................233 Rozdział 10. Zarządzanie pamięcią 239 Pamięć statyczna i dynamiczna ................................................................240 Rzutowanie typów...................................................................................245 Alokacja tablic o rozmiarze dynamicznym .............................................249 Zmiana rozmiaru bloku pamięci...............................................................253 Zwracanie pamięci z funkcji ...................................................................262 Zapobieganie wyciekom pamięci ..............................................................268 Rozdział 11. Ciągi znaków 271 Spis treści Podstawowa składnia wskaźników na ciągi znaków...............................272 Znajdowanie długości ciągu znaków.......................................................277 Łączenie ciągów znaków (konkatenacja)................................................281 Porównywanie ciągów znaków ...............................................................285 Kopiowanie ciągów znaków ...................................................................291 Sortowanie ciągów znaków.....................................................................296 Rozdział 12. Tworzenie napisów i plansz tytułowych 303 Otwarcie i zamknięcie pliku....................................................................304 Zapis danych do pliku .............................................................................310 Odczyt danych z plików ..........................................................................317 Przetwarzanie danych odczytanych z pliku.............................................321 Zapis danych binarnych...........................................................................323 Odczyt plików binarnych ........................................................................329 Poruszanie się po pliku binarnym............................................................332 Rozdział 13. Stosowanie efektów 337 Wprowadzenie do struktur ......................................................................338 Konstrukcja typedef ................................................................................345 Tablice struktur .......................................................................................350 Wprowadzenie do list..............................................................................356 7
  5. 5. Spis treści Dodatek A Instalacja i obsługa narzędzi programistycznych 369 Dev-C++ dla systemu Windows .............................................................370 Korzystanie ze środowiska Dev-C++......................................................372 Aplikacja Xcode z systemu Mac OS X ...................................................375 Narzędzia dostępne w systemach uniksowych........................................377 Znajdowanie błędów za pomocą programu uruchomieniowego GDB ...378 Inne narzędzia .........................................................................................380 Dodatek B Materiały dodatkowe 381 Witryny internetowe................................................................................382 Tabele ......................................................................................................384 Skorowidz 387 Spis treści 8
  6. 6. 4 Struktury sterujące Struktury sterujące Choć przykłady przedstawione do tej pory korzystały ze zmiennych, przeprowadzały obliczenia i wyświetlały wyniki, brakowało im dynamicznej natury prawdziwego programowania. Jednym z kluczowych elementów prawdziwych aplikacji jest ich elastyczność zapewniaqna przez struktury sterujące takie jak pętle i instrukcje warunkowe. Najczęściej stosowaną strukturą sterującą jest warunek KH (jeśli) i jego odmiany: KHGNUG, KHGNUGKH oraz KHGNUGKHGNUG. Rozdział rozpoczniemy od omówienia właśnie tego warunku. W tym czasie natkniemy się na nowe operatory języka C (poza ju wymienionym operatorami arytmetycznymi i przypisania). Następnie Struktury sterujące przejdziemy do dwóch pozostałych instrukcji warunkowych — operatora trójargumentowego i konstrukcji UYKVEJ. Na końcu rozdziału zajmiemy się dwoma typowymi rodzajami pętli: YJKNG i HQT. Po przeczytaniu tego rozdziału będziesz potrafił pisać bardziej funkcjonalne aplikację w języku C. 73
  7. 7. Rozdział 4. Instrukcja warunkowa if Warunki to struktury sterujące pozwalające na rozgałęzianie przebiegu programu, czyli uzale nianie jego działania od ró nych parametrów. Ze wszystkich rodzajów rozgałęzień najczęściej stosuje się instrukcję KH. Jej składnia jest bardzo prosta: KH YCTWPGM ] KPUVTWMELG _ Warunek umieszcza się wewnątrz nawiasów okrągłych, a instrukcje, które mają zostać wykonane, wewnątrz nawiasów klamrowych. Jeśli warunek jest prawdziwy, instrukcje zostaną wykonane. W przeciwnym razie zostaną pominięte. W język C najprostszą reprezentacją fałszu jest wartość 0. Wszystko inne traktowane jest jako Instrukcja warunkowa if prawda. KH ] RTKPVH 6GP YCTWPGM CYUG LGUV RTCYFKY[ RTKPVH 6Q LGUV MQNGLPC KPUVTWMELC _ W wyniku prawdziwości warunku wykonana mo e zostać dowolną liczba instrukcji. Je eli warunek dotyczy tylko jednej instrukcji, mo na pominąć nawiasy klamrowe. Oto przykład: KH RTKPVH 6GP YCTWPGM CYUG LGUV åRTCYFKY[ Kolejny przykład zobrazuje, w jaki sposób korzystać z warunków w języku C. 74
  8. 8. Struktury sterujące Listing 4.1. Podstawowa instrukcja warunkowa Aby utworzyć warunek if: sprawdza, czy zmienna test ma wartość ró ną od 0 1. Utwórz nowy dokument w edytorze tekstu lub IDE. /* if.c - listing 4.1 */ 2. Dodaj początkowy komentarz i kod (patrz KPENWFG UVFKQJ listing 4.1). KPV OCKP XQKF ] /* if.c - listing 4.1 */ KPENWFG UVFKQJ KPV VGUV // Zmienna będąca warunkiem. KPV OCKP XQKF ] // Wyświetlenie tekstu wprowadzenia. 3. Zadeklaruj i zainicjalizuj zmienną. RTKPVH 6GUVQYCPG OKGPPGL VGUVP KPV VGUV // Sprawdzenie wartości zmiennej i wyświetlenie Zmienna test jest liczbą całkowitą (równie åtekstu (jeśli test = 0, tekst się nie wyświetli). dobrze mogłaby być typu WPUKIPGF UJQTV KPV, KH VGUV ] RTKPVH
  9. 9. OKGPPC VGUV CYKGTC jeśli chcielibyśmy być minimalistami). Posłu y åYCTVQ è FP VGUV nam ona jako element warunku w strukturze _ sterującej. 4. Dodanie komunikatu początkowego. Instrukcja warunkowa if IGVEJCT /* Zatrzymaj, a u ytkownik naciśnie åklawisz Enter lub Return. */ RTKPVH 6GUVQYCPG OKGPPGL VGUVP TGVWTP Komunikat ten zapewni odpowiedni kontekst dla dowolnego kolejnego tekstu. Gwarantuje, _ e aplikacja wyświetli jakiś tekst niezale nie od spełnienia warunku (w przeciwnym razie przy fałszywym warunku tekst nie zostałby wyświetlony). 5. Zdefiniuj warunek KH. KH VGUV ] RTKPVH
  10. 10. OKGPPC VGUV CYKGTC YCTVQ è å FP VGUV _ Jeśli warunek jest prawdziwy, zostanie wyświetlony dodatkowy tekst wraz z wartością zmiennej VGUV. Tak sytuacja wystąpi, gdy zmienna VGUV będzie zawierała wartość ró ną od 0. W przeciwnym razie (VGUV ) instrukcja RTKPVH w ogóle nie zostanie wykonana. 75
  11. 11. Rozdział 4. 6. Dokończ funkcję OCKP . IGVEJCT TGVWTP _ Rysunek 4.1. Jeśli zmienna test ma wartość ró ną 7. Zapisz projekt w pliku if.c. od 0, zostanie wyświetlony dodatkowy komunikat 8. Skompiluj i sprawdź poprawność kompilacji. 9. Uruchom aplikację (patrz rysunek 4.1). 10. Aby sprawdzić działanie aplikacji dla zmiennej VGUV równej 0, ponownie skompiluj aplikację, Rysunek 4.2. Jeśli zmienna test ma wartość ustawiając VGUV na 0 (patrz rysunek 4.2). równą 0, pojawi się tylko jeden komunikat W tym przypadku warunek jest fałszywy, więc druga instrukcja RTKPVH nie zostanie wykonana. Wskazówki Tworzenie instrukcji warunkowej dla jednego Instrukcja warunkowa if polecenia bez stosowania nawiasów klamrowych jest co prawda w pełni poprawne, ale mo e prowadzić do błędów, jeśli w przyszłości będzie się dokonywać modyfikacji warunku. Choć to rozwiązanie jest bardzo kuszące i mo na się na nie natknąć, przeglądając kod napisany przez inne osoby, nie warto go stosować. Standard C99 wprowadza nowy typ danej o nazwie A$QQN — wartość logiczna. Zmienne tego typu zawsze będą posiadały wartość 0 (fałsz) lub 1 (prawda). Wpisanie do zmiennej jakiejkolwiek wartości ró nej od 0 spowoduje zamianę tej zmiennej na wartość 1. Środowisko Dev-C++ w wersji 4. nie obsługuje typu A$QQN. Jest on dostępny dopiero w wersji beta Dev-C++ 5. Dodatkowo standard C99 definiuje plik stdbool.h, który zawiera deklarację trzech słów kluczowych: DQQN (odpowiednik A$QQN), VTWG (odpowiednik liczby 1) oraz HCNUG (odpowiednik liczby 0). Czyni to kod języka C lepiej przenośnym do języka C++. 76
  12. 12. Struktury sterujące Tabela 4.1. Operatory logiczne i porównania bardzo często występują w warunkach i innych Operatory logiczne strukturach sterujących i porównania Operatory logiczne i porównania Korzystanie z prostych zmiennych Operator Znaczenie (jak w poprzednim przykładzie) raczej nie większy od pozwoli nikomu zajść daleko w programowaniu mniejszy od w języku C. Aby móc tworzyć bardziej mniejszy od lub równy zaawansowane instrukcje warunkowe, trzeba większy od lub równy wykorzystać operatory porównania i logiczne równy (patrz tabela 4.1). ró ny od Operatory porównania wykorzystuje się dla iloczyn logiczny (and) wartości liczbowych, na przykład by wskazać, ^^ suma logiczna (or) czy dana wartość jest wy sza od innej. negacja (not) Wykorzystanie wartości takiego wyra enia (prawda lub fałsz), pozwala konstruować bardziej przydatne instrukcje warunkowe. Operatory logiczne i porównania KH YKGM ] RTKPVH /CU Y[UVCTECLæEæ NKEDú NCV åD[ OÎE I QUQYCè _ Operatory logiczne bardzo często stosuje się w połączeniu z nawiasami, aby utworzyć bardziej zło one warunki, na przykład zakresy. KH YKGM YKGM ] RTKPVH 7YCIC PCUVQNCVGM _ Szczególną uwagę nale y zwracać na operator równości (). Jednym z najczęstszych błędów popełnianych przez programistów (tak e tych wprawionych) jest przypadkowe stosowanie w miejscu operatora równości operatora przypisania (). KH O ] Programista w rzeczywistości chciał sprawdzić, czy wartość zmiennej O jest równa 190 (chciał napisać O ), co mo e, ale nie musi być prawdą. Niestety, brak jednego znaku powoduje, i przedstawiony warunek zawsze będzie prawdziwy (zmienna przyjmie wartość 190, więc będzie ró na od 0, co przeło y się na prawdziwość warunku). W kolejnym przykładzie wykorzystamy operatory do wyświetlenia ró nych tekstów w zale ności od średniej ocen studenta. 77
  13. 13. Rozdział 4. Aby wykorzystać operatory logiczne Listing 4.2. Dzięki operatorom logicznym i porównania: i porównania mo liwe jest jednoczesne sprawdzanie kilku warunków 1. Utwórz nowy dokument w edytorze tekstu lub IDE. /* srednia.c - listing 4.2 */ 2. Dodaj początkowy komentarz i kod KPENWFG UVFKQJ (patrz listing 4.2). /* srednia.c - listing 4.1 */ KPV OCKP XQKF ] KPENWFG UVFKQJ KPV OCKP XQKF ] HNQCV UTGFPKC // Średnia ocen studenta. 3. Zadeklaruj i zainicjalizuj zmienną. // Sprawdzenie, czy przysługuje stypendium (średnia åco najmniej 4.0). HNQCV UTGFPKC KH UTGFPKC ] Zmienna UTGFPKC przechowuje średnią ocen RTKPVH 1VT[OWLGU UV[RGPFKWO åC Y[PKMK Y PCWEG RQPKGYC OCU studenta. Na początku zostanie ustawiona å TGFPKæ H P UTGFPKC na wartość . _ Operatory logiczne i porównania 4. Sprawdź, czy studentowi nale y się stypendium // Sprawdzenie, czy przysługuje ksią ka za wyniki. za wyniki w nauce. KH UTGFPKC UTGFPKC KH UTGFPKC ] ] RTKPVH 1VT[OWLGU UV[RGPFKWO C Y[PKMK RTKPVH 1VT[OWLGU MUKæ Mú RQPKGYC åY PCWEG RQPKGYC OCU TGFPKæ H P OCU TGFPKæ H P UTGFPKC åUTGFPKC _ _ // Sprawdzenie, czy przysługuje pochwała za wyniki. Jeśli wartość UTGFPKC jest wy sza lub równa , KH UTGFPKC UTGFPKC ] wykonujemy instrukcję wyświetlenia tekstu RTKPVH 1VT[OWLGU RQEJYC ú RQPKGYC na ekranie. Je eli średnia jest mniejsza, åOCU TGFPKæ H P UTGFPKC _ pomijamy instrukcję RTKPVH . 5. Sprawdzenie, czy średnia kwalifikuje się IGVEJCT /* Zatrzymaj, a u ytkownik naciśnie åklawisz Enter lub Return. */ do otrzymania ksią ki. KH UTGFPKC UTGFPKC ] TGVWTP RTKPVH 1VT[OWLGU MUKæ Mú RQPKGYC OCU å TGFPKæ H P UTGFPKC _ _ 78
  14. 14. Struktury sterujące Korzystając z operatorów logicznych i porównania, sprawdzamy, czy student osiągnął średnią większą od 3,9, ale jednocześnie nie Rysunek 4.3. W zale ności od zawartości zmiennej przekroczył średniej 4,0. Z powodu zastosowania srednia na ekranie pojawiają się ró ne komunikaty operatora iloczynu logicznego ( ), aby cały warunek był prawdziwy, oba warunki składowe muszą zwrócić wartość prawdy. Jeśli średnia jest mniejsza od 3,9 lub te równa albo większa od 4,0, instrukcja z warunku nie zostanie wykonana. 6. Sprawdzenie, czy student kwalifikuje się do otrzymania pochwały. KH UTGFPKC UTGFPKC ] RTKPVH 1VT[OWLGU RQEJYC ú RQPKGYC åOCU TGFPKæ H P UTGFPKC _ Operatory logiczne i porównania Ostatni z warunków działa dokładnie tak samo jak poprzedni, ale korzysta z innych wartości w trakcie testów. 7. Dokończ funkcję OCKP . IGVEJCT TGVWTP _ 8. Zapisz program w pliku srednia.c. 9. Skompiluj i sprawdź poprawność kompilacji (ewentualnie popraw błędy). 10. Uruchom aplikację (patrz rysunek 4.3). 11. Dla porównania zmień wartość zmiennej UTGFPKC i ponownie skompiluj program (patrz rysunek 4.4). Rysunek 4.4. Zastosowanie innej wartości srednia powoduje uzyskanie innego wyniku 79
  15. 15. Rozdział 4. Wskazówki Dalszy ciąg kolejności Sposób, w jaki został napisany przykład, powoduje, e dla UTGFPKGL mniejszej od 3,75 operatorów nie zostanie wyświetlony aden komunikat. Podobnie jak operatory arytmetyczne Poprawimy tę kwestię w następnym przykładzie. tak e operatory logiczne i porównania Mo na te dodać kolejny warunek, który mają swoją ściśle określoną kolejność wykonywania. Na przykład operatory , , wyświetli komunikat dla wartości mniejszej i mają wy szy priorytet ni od 3,75. operatory i . Pamiętaj, aby nigdy nie sprawdzać równości Jeśli uwzględnić wszystkie poznane do tej dwóch zmiennych typu HNQCV lub FQWDNG. pory operatory, operatory porównania Z racji takiego, a nie innego sposobu mają większy priorytet ni operator reprezentacji liczb zmiennoprzecinkowych przypisania (), ale ni szy priorytet w komputerze, dwie wartości wydające się ni operatory arytmetyczne. być identycznymi mogą w rzeczywistości Co więcej, operator negacji ( ) ma większy ró nić się na jednej pozycji. Co więcej, liczba priorytet ni mno enie i dzielenie, całkowita 2 mo e nie być równa liczbie natomiast operatory iloczynu i sumy Operatory logiczne i porównania zmiennoprzecinkowej 2,0. logicznej ( i ^^) mają większy priorytet ni operator przypisania (), ale ni szy Niektórzy programiści zalecają odwracanie priorytet ni operatory porównań. wartości w warunku wykorzystującym równość, Poza tym operator jest wa niejszy gdy jednym ze sprawdzanych elementów jest od operatora ^^. stała. Oto przykład: Pogmatwane? Na pewno. Mo na KH IQFKP[ ] zapamiętać kolejność wykonywania wszystkich operatorów (pełna lista Zaletą takiego rozwiązania jest to, e gdy priorytetów operatorów znajduje się przypadkowo opuścimy jeden ze znaków w dodatku B) lub te po prostu stosować równości, kompilator zgłosi błąd (poniewa nawiasy. nie mo na przypisać zmiennej do konkretnej wartości). Aby sprawdzić, czy dwa ciągi znaków są identyczne, u ywa się specjalnej funkcji UVTEOR . Funkcja ta zwraca liczbę ró nic między obu sprawdzanymi tekstami. Jeśli zwróconą wartością jest 0, oba teksty są identyczne. KH UVTEOR O O ] Więcej informacji na ten temat znajduje się w rozdziale 11., „Ciągi znaków”. 80
  16. 16. Struktury sterujące Klauzule else i else if Instrukcja warunkowa KH jest bardzo u yteczna, ale mo e zostać wzbogacona o dodatkowe elementy za pomocą klauzul GNUG i GNUG KH. Składnia konstrukcji KHGNUG jest następująca: KH YCTWPGM ] /* Zrób coś. */ _ GNUG ] /* W przeciwnym razie wykonaj to. */ _ Zauwa , e instrukcje z klauzuli GNUG zostaną Rysunek 4.5. Diagram przedstawia wykonane tylko wtedy, gdy główny warunek nie działanie warunku if-else będzie prawdziwy. Innymi słowy, klauzula GNUG działa jak odpowiedź domyślna (patrz rysunek 4.5). Klauzula GNUG KH jest bardziej rozbudowana, gdy pozwala dodatkowo sprawdzić kolejny warunek, jeśli okazało się, e pierwszy warunek nie był prawdziwy (patrz rysunek 4.6). Klauzule else i else if KH YCTWPGM ] /* Zrób coś. */ _ GNUG KH YCTWPGM ] /* Zrób coś innego. */ _ Liczba klauzul GNUG KH jest nieograniczona. Często łączy się klauzule GNUG KH i GNUG. Wa ne Rysunek 4.6. Diagram przedstawia działanie jest tylko, by klauzula GNUG byłą ostatnia (gdy warunku if-else if (elementów else if mo e być nieskończenie du o) jest rozwiązaniem domyślnym). Zmodyfikujmy wcześniejszy przykład z ocenami, aby uwzględniał nowe instrukcje. 81
  17. 17. Rozdział 4. Aby skorzystać z klauzul else i else if: Listing 4.3. Korzystając z klauzul else i else if, zmodyfikowaliśmy wcześniejszy przykład 1. Otwórz plik srednia.c (listing 4.2) w edytorze ze średnią ocen tekstu lub środowisku IDE. 2. Usuń wszystkie istniejące warunki /* srednia2.c - listing 4.3 - przeróbka listingu 4.2 (patrz listing 4.3). å (srednia.c) */ Trzy osobne warunki KH zostaną zastąpione KPENWFG UVFKQJ jedną du ą konstrukcją KHGNUG KHGNUG KHGNUG, więc nie będą ju potrzebne. KPV OCKP XQKF ] 3. Utwórz główną pętlę. HNQCV UTGFPKC // Średnia ocen studenta. KH UTGFPKC ] RTKPVH 1VT[OWLGU UV[RGPFKWO C Y[PKMK // Raport na temat średniej. åY PCWEG RQPKGYC OCU TGFPKæ H P KH UTGFPKC ] åUTGFPKC RTKPVH 1VT[OWLGU UV[RGPFKWO _ GNUG KH UTGFPKC ] åC Y[PKMK Y PCWEG RQPKGYC OCU åRTKPVH 1VT[OWLGU MUKæ Mú RQPKGYC å TGFPKæ H P UTGFPKC åOCU TGFPKæ H P UTGFPKC _ GNUG KH UTGFPKC ] _ GNUG KH UTGFPKC ] RTKPVH 1VT[OWLGU MUKæ Mú RQPKGYC åRTKPVH 1VT[OWLGU RQEJYC ú RQPKGYC åOCU TGFPKæ H P UTGFPKC åOCU TGFPKæ H P UTGFPKC _ GNUG KH UTGFPKC ] Klauzule else i else if _ GNUG ] RTKPVH 1VT[OWLGU RQEJYC ú RQPKGYC RTKPVH /Q G Y RT[U [O TQMW DúFKG åOCU TGFPKæ H P UTGFPKC åNGRKGL TGFPKC VQ PKG YU[UVMQP _ GNUG ] _ RTKPVH /Q G Y RT[U [O TQMW DúFKG åNGRKGL TGFPKC VQ PKG YU[UVMQP Same warunki są bardzo podobne do tych _ z poprzedniego przykładu, ale teraz wszystko stanowi jedną du ą instrukcję warunkową. IGVEJCT /* Zatrzymaj, a u ytkownik naciśnie Aplikacja będzie sprawdzała warunki tak åklawisz Enter lub Return. */ długo, a któryś z nich nie oka e się TGVWTP prawdziwy. W przeciwnym razie zostanie wykonana klauzula GNUG. _ 82
  18. 18. Struktury sterujące Zauwa , e drugi i trzeci warunek nie muszą sprawdzać, czy wartość jest mniejsza od konkretnej liczby. Na przykład, jeśli UTGFPKC wynosi 3,8, pierwszy i drugi warunek jest fałszywy, a dopiero trzeci jest prawdziwy. W trzecim warunku nie trzeba ju sprawdzać, czy UTGFPKC jest mniejsza od 3,9, poniewa zostało to stwierdzone ju w drugim warunku. Skoro program sprawdza dany warunek, mamy pewność, e poprzednie warunki z tej samej konstrukcji były fałszywe. 4. Zapisz program w pliku srednia2.c, skompiluj i uruchom go (patrz rysunek 4.7). 5. Zmień wartość zmiennej UTGFPKC na inną i ponownie skompiluj oraz uruchom aplikację (patrz rysunek 4.8). Wskazówki Klauzule else i else if Choć nie jest to wymagane, warto wprowadzać wcięcia dla instrukcji znajdujących się wewnątrz klauzul KH, GNUG i GNUG KH. Zwiększa to czytelność kodu. Podobnie jak zwykła konstrukcja KH, tak e GNUG i GNUG KH nie wymagają stosowania nawiasów klamrowych, gdy występuje po nich tylko jedna instrukcja. Warto jednak dodawać te nawiasy, aby w przyszłości nie popełnić błędów. Rysunek 4.7. Dla wielu średnich aplikacja zachowuje się dokładnie tak samo jak poprzednio (patrz rysunki 4.3 i 4.4) pomimo zmian w warunkach Rysunek 4.8. Nowa odpowiedź zostanie wyświetlona dla średnich poni ej 3,75 83
  19. 19. Rozdział 4. Listing 4.4. Operator trójargumentowy często stosuje Operator trójargumentowy się jako krótszą wersję warunku if-else, jeśli trzeba Język C posiada składnię alternatywną dla zwrócić jedną z dwóch wartości konstrukcji KHGNUG. Jest to tak zwany operator trójargumentowy. Nazwa wynika z faktu, /* pogoda.c - listing 4.4 */ e operator ten wymaga trzech parametrów (składa się z trzech części). Oto jego podstawowa KPENWFG UVFKQJ składnia: KPV OCKP XQKF ] YCTWPGM ! Y[PKMAFNCARTCYF[ Y[PKMAFNCAHCNUW KPV VGORGTCVWTC // Temperatura Zauwa my, e operator ten zwraca jedną z dwóch åw stopniach Celsjusza. wartości w zale ności od warunku. Zwracaną wartość mo na przypisać do zmiennej lub KH VGORGTCVWTC ] // Sprawdź, åczy gorąco. wyświetlić. Na przykład poni szy kod zwróci informację o tym, czy liczba jest wartością RTKPVH ,GUV F UVQRPK E[NK PC FYQTG parzystą czy nieparzystą. Do sprawdzenia åLGUV DCTFQ IQTæEQP VGORGTCVWTC parzystości u ywamy operatora reszty z dzielenia. _ GNUG KH VGORGTCVWTC ] // Wyświetl EJCT RCT[UV[APKGRCT[UV[ å'zimno' lub 'lodowato' w zale ności Operator trójargumentowy RCT[UV[APKGRCT[UV[ NKEDC ! å od temperatury. å R P RTKPVH ,GUV F UVQRPK E[NK PC FYQTG Gdyby w tym samym celu zastosować warunek KH, åLGUV U P VGORGTCVWTC wyglądałby on następująco: å VGORGTCVWTC ! NQFQYCVQ å KOPQ EJCT RCT[UV[APKGRCT[UV[ KH NKEDC ] _ GNUG ] // Nie jest ani za gorąco, ani za zimno. RCT[UV[APKGRCT[UV[ R _ GNUG ] RTKPVH ,GUV F UVQRPK E[NK PC FYQTG RCT[UV[APKGRCT[UV[ P åLGUV EC MKGO RT[LGOPKGP _ åVGORGTCVWTC W następnym przykładzie operator trójargumentowy zostanie wykorzystany _ do wyświetlenia odpowiedniego komunikatu w zale ności od temperatury. IGVEJCT /* Zatrzymaj, a u ytkownik naciśnie åklawisz Enter lub Return. */ Aby wykorzystać TGVWTP operator trójargumentowy: _ 1. Utwórz nowy, pusty dokument w edytorze tekstu lub IDE. 2. Dodaj początkowy komentarz i kod (listing 4.4). /* pogoda.c - listing 4.4 */ KPENWFG UVFKQJ KPV OCKP XQKF ] 84
  20. 20. Struktury sterujące 3. Zadeklaruj i zainicjalizuj zmienną całkowitą. KPV VGORGTCVWTC Ta zmienna przechowuje aktualną temperaturę w stopniach Celsjusza. 4. Rozpocznij główny warunek KH. KH VGORGTCVWTC ] RTKPVH ,GUV F UVQRPK E[NK PC FYQTG åLGUV DCTFQ IQTæEQP VGORGTCVWTC Pierwszy warunek sprawdza, czy na dworze jest ponad 30 stopni Celsjusza. Jeśli tak, wyświetla aktualną temperaturę i informuje o tym, e jest gorąco (jest to program dla osób, które lubią, by komputer informował je o rzeczach oczywistych). 5. Dodaj warunek GNUG KH wraz z operatorem trójargumentowym wewnątrz instrukcji Operator trójargumentowy RTKPVH . _ GNUG KH VGORGTCVWTC ] RTKPVH ,GUV F UVQRPK E[NK PC FYQTG åLGUV U P VGORGTCVWTC VGORGTCVWTC å ! NQFQYCVQ KOPQ Jeśli jest poni ej 10 stopni, aplikacja wyświetli NQFQYCVQ lub KOPQ w zale ności od tego, jak bardzo jest zimno. Zamiast u ywać osobnej konstrukcji GNUG KH, stosujemy operator trójargumentowy wewnątrz instrukcji RTKPVH . Znacznik U wewnątrz tekstu komunikatu określa miejsce, w którym zostanie wstawiona wartość zwrócona przez operator trójargumentowy (patrz trzeci parametr funkcji RTKPVH ). Operator sprawdza, czy temperatura ma wartość poni ej 0. Jeśli tak, zwraca wartość NQFQYCVQ. W przeciwnym razie zwraca wartość KOPQ. Zauwa , e obie wartości to ciągi znaków (poniewa znajdują się w cudzysłowach). 85
  21. 21. Rozdział 4. 6. Dokończ warunek. _ GNUG ] RTKPVH ,GUV F UVQRPK E[NK PC FYQTG åLGUV EC MKGO RT[LGOPKGP VGORGTCVWTC Rysunek 4.9. Jeśli jest ponad 30 stopni, pojawia _ się następujący komunikat (patrz listing 4.4) Je eli temperatura jest między 10 a 30 stopniami, informujemy o przyjemnej pogodzie za oknem. 7. Zakończ funkcję OCKP . Rysunek 4.10. Jeśli jest poni ej 10 stopni, IGVEJCT za pomocą operatora trójargumentowego TGVWTP wybierany jest komunikat lodowato lub zimno _ 8. Zapisz dokument w pliku pogoda.c. 9. Skompiluj kod. 10. Uruchom aplikację (patrz rysunek 4.9). 11. Zmodyfikuj wartość zmiennej VGORGTCVWTC, Operator trójargumentowy a następnie ponownie skompiluj i uruchom aplikację (patrz rysunek 4.10). Wskazówki Mo na zmodyfikować przedstawiony powy ej kod, na przykład zmieniając pierwszy warunek na 22 stopnie i dodając w instrukcji RTKPVH operator trójargumentowy rozró niający stan EKGR Q i IQTæEQ. Główną zaletą operatora trójargumentowego jest jego bardzo zwięzły zapis w porównaniu z konstrukcją KHGNUG. Wadą jest zmniejszona przejrzystość kodu. 86
  22. 22. Struktury sterujące Instrukcja switch Poza operatorem trójargumentowym istnieje równie inna odmiana tradycyjnego warunku, a mianowicie instrukcja UYKVEJ. Przyjmuje ona jako swój parametr wartość całkowitą, a następnie sprawdza ją względem kilku wymienionych mo liwości. Oto przykład: UYKVEJ TQM ] ECUG /* Zrób coś. */ DTGCM ECUG /* Zrób coś innego. */ DTGCM FGHCWNV /* Zrób to. */ DTGCM _ Instrukcja DTGCM jest niezmiernie wa na, jeśli chodzi o działanie instrukcji UYKVEJ. Po dotarciu do DTGCM aplikacja opuści cały fragment UYKVEJ. Jeśli pominie Instrukcja switch się DTGCM, wykonane zostaną tak e pozostałe instrukcje, nawet te nale ące do innych mo liwości. Mo liwość FGHCWNV jest opcjonalna, ale gdy ju się ją dodaje, to zazwyczaj na samym końcu instrukcji UYKVEJ. Jeśli adna z wcześniejszych mo liwości nie będzie poprawna, wykonany zostanie kod mo liwości FGHCWNV (działa ona mniej więcej tak samo jak klauzula GNUG). Kolejny przykład działa ró nie w zale ności od wartości właściwości RNGE. Zmienna typu EJCT, która tak naprawdę jest okrojonym typem KPV, bez problemów funkcjonuje w instrukcji UYKVEJ. 87
  23. 23. Rozdział 4. Aby użyć instrukcji switch: Listing 4.5. Instrukcja switch pozwala określić ró ne odpowiedzi dla ró nych wartości całkowitych 1. Utwórz nowy, pusty dokument w edytorze lub znaków tekstu lub IDE. 2. Dodaj początkowy komentarz i kod (listing 4.5). /* plec.c - listing 4.5 */ /* plec.c - listing 4.5 */ KPENWFG UVFKQJ KPENWFG UVFKQJ KPV OCKP XQKF ] KPV OCKP XQKF ] 3. Zadeklaruj i zainicjalizuj zmienną znakową. EJCT RNGE / // Płeć jako znak pojedynczy. EJCT RNGE / UYKVEJ RNGE ] // Zmień wyświetlane Zmienna przechowuje płeć osoby jako åpozdrowienie. pojedynczy znak. ECUG / 4. Rozpocznij instrukcję UYKVEJ. RTKPVH 9KVCO RCPC P DTGCM UYKVEJ RNGE ] Poprawna składnia instrukcji UYKVEJ wymaga ECUG - RTKPVH 9KVCO RCPKæ P zastosowania słowa kluczowego UYKVEJ DTGCM i podania w nawiasach testowanej zmiennej. Otwierający nawias klamrowy oznacza początek FGHCWNV Instrukcja switch zawartości instrukcji UYKVEJ. RTKPVH 9KVCO YU[UVMKEJ P DTGCM 5. Dodaj pierwszą mo liwość. _ // Koniec instrukcji switch. ECUG / RTKPVH 9KVCO RCPC P IGVEJCT /* Zatrzymaj, a u ytkownik DTGCM ånaciśnie klawisz Enter lub Return. */ Pierwszy element sprawdza, czy zmienna TGVWTP zawiera wartość /. Jeśli tak, wyświetlany jest tekst 9KVCO RCPC . Instrukcja DTGCM wymusza _ wyjście z konstrukcji UYKVEJ, aby pozostałe instrukcje RTKPVH nie zostały wykonane. 6. Dodaj drugą mo liwość. ECUG - RTKPVH 9KVCO RCPKæ P DTGCM Struktura tego elementu jest taka sama jak elementu z kroku poprzedniego. Po prostu testowana jest inna wartość. 88
  24. 24. Struktury sterujące 7. Dodaj domyślny element i zakończ instrukcję UYKVEJ. FGHCWNV Rysunek 4.11. Wynik wykonania programu RTKPVH 9KVCO YU[UVMKEJ P dla zmiennej ustawionej na wartość M DTGCM _ Jeśli zmienna RNGE nie zawiera wartości / lub - (choć jest to mało prawdopodobne), pojawi się ogólny komunikat. Rysunek 4.12. Jeśli zmienna nie jest równa M ani F, stosowany jest element domyślny 8. Zakończ funkcję OCKP . IGVEJCT TGVWTP _ 9. Zapisz dokument w pliku plec.c. 10. Skompiluj przykład. 11. Uruchom aplikację (patrz rysunek 4.11). 12. Dla porównania zmień wartość zmiennej na inną literę lub spację, a następnie ponownie Instrukcja switch skompiluj i uruchom aplikację (patrz rysunek 4.12). Wskazówki Główną wadą instrukcji UYKVEJ jest to, e mo na Nic nie stoi na przeszkodzie, by te same jej u ywać tylko dla liczb całkowitych instrukcje dotyczyły kilku mo liwości. i pojedynczych znaków. Znacznie ogranicza Wtedy składnia konstrukcji UYKVEJ jest to jej przydatność. Gdy jednak mo na ją następująca: zastosować, byłaby konstrukcją szybszą i bardziej przejrzystą ni KH. UYKVEJ RNGE ] ECUG / W języku C istnieje jeszcze jedna instrukcja ECUG O sterująca nieomawiana w tej ksią ce /* Zrób coś. */ DTGCM — instrukcja IQVQ. Osoby zaznajomione ECUG - z innymi językami, takimi jak na przykład ECUG M Basic lub Pascal, powinny ją znać, ale tak /* I tak dalej... */ naprawdę w języku C nie jest ona do niczego DTGCM potrzebna. _ 89
  25. 25. Rozdział 4. Pętla while Instrukcje warunkowe to tylko jeden rodzaj sterowania działaniem programu — drugim są pętle. Język C obsługuje dwie postacie pętli: YJKNG (i jego siostra FQYJKNG) oraz HQT. Ka dy z typów pętli wykonuje to samo zadanie — powtarza określony ciąg instrukcji a do uzyskania fałszywości pewnego warunku — ale w nieco inny sposób. Pętla YJKNG wygląda bardzo podobnie do instrukcji KH, gdy wykonuje pewne instrukcje, gdy określony warunek jest prawdziwy. YJKNG YCTWPGM ] /* Zrób coś. */ _ Gdy wykona się jedna iteracja pętli, warunek Rysunek 4.13. Diagram prezentujący działanie sprawdzany jest ponownie. Je eli nadal jest pętli w języku C. Instrukcje wykonywane są prawdziwy, zachodzi kolejna iteracja pętli. Jeśli tak długo, jak długo warunek jest prawdziwy jest fałszywy, program przechodzi do następnej instrukcji po pętli (patrz rysunek 4.13). Pętla while Typowym błędem początkujących programistów jest tworzenie pętli, w których warunek nigdy nie stanie się fałszywy. Powstaje wtedy pętla nieskończona (aplikacja działa i działa). Z tego powodu trzeba zapewnić takie określenie zawartości pętli, by w pewnym momencie warunek przestał być prawdziwy. W następnym przykładzie wykorzystamy pętlę YJKNG do napisania programu, który obliczy silnię z wybranej liczby. Silna (reprezentowana przez znak wykrzyknika) to wartość uzyskana z mno enia wszystkich liczb całkowitych od 1 a do podanej wartości. Oto przykład:
  26. 26. // 120
  27. 27. // 6 90
  28. 28. Struktury sterujące Listing 4.6. Pętla while pomaga policzyć silnię Aby użyć pętli while: z wybranej liczby. Pętla wykonuje się tak długo, jak długo zmienna mnoznik jest mniejsza 1. Utwórz nowy dokument w edytorze tekstu lub równa zmiennej liczba lub IDE. 2. Dodaj początkowy komentarz i kod (listing 4.6). /* silnia.c - listing 4.6 */ /* silnia.c - listing 4.6 */ KPENWFG UVFKQJ KPENWFG UVFKQJ KPV OCKP XQKF ] KPV OCKP XQKF ] 3. Zadeklaruj i ustaw wartości zmiennych. // W tym przykładzie stosujemy tylko liczby WPUKIPGF KPV NKEDC ådodatnie. WPUKIPGF KPV Y[PKM WPUKIPGF KPV OPQPKM WPUKIPGF KPV NKEDC // Wartość, z której åwyliczamy silnię. Aplikacja korzysta z trzech wartości całkowitych WPUKIPGF KPV Y[PKM // Zmienna bez znaku. Przypisujemy zmiennym wartości åprzechowująca przyszły wynik - silnię. początkowe. Zmienna NKEDC określa wartość, WPUKIPGF KPV OPQPKM // Mno nik åu ywany do obliczenia silni. dla której liczymy silnię. Zmienna Y[PKM przechowuje wyniki obliczeń. Zmienna OPQPKM // Przejdź przez wszystkie mno niki od 1 do liczba. jest wykorzystywana w pętli do obliczenia silni. YJKNG OPQPKM NKEDC ] 4. Rozpoczęcie pętli YJKNG. Y[PKM
  29. 29. OPQPKM // Mno enie YJKNG OPQPKM NKEDC ] Pętla while åwcześniejszego wyniku przez mno nik. OPQPKM // Inkrementacja mno nika. Silnię liczymy, mno ąc wynik przez kolejne liczby całkowite od 1 do NKEDC. Obliczenia _ // Koniec pętli. wykonujemy w pętli, więc warunek pętli // Wyświetlenie wyniku. musi pozwalać wyjść z pętli po wykonaniu RTKPVH 5KNPKC NKED[ W VQ WP odpowiedniej liczby mno eń. Gdy OPQPKM jest NKEDC Y[PKM mniejszy lub równy zmiennej NKEDC, oznacza to, e obliczenia jeszcze się nie zakończyły i trzeba IGVEJCT /* Zatrzymaj, a u ytkownik naciśnie åklawisz Enter lub Return. */ wykonać zawartość pętli. W przeciwnym razie wszystkie obliczenia zostały przeprowadzone. TGVWTP _ 91
  30. 30. Rozdział 4. 5. Wykonaj obliczenia. Y[PKM
  31. 31. OPQPKM Instrukcje break, continue i exit Instrukcja DTGCM (która występuje między Przy wykorzystaniu operatora przypisania innymi we wnętrzu instrukcji UYKVEJ) jest z mno eniem wartość zmiennej Y[PKM jest po prostu jedną z konstrukcji języka C ustawiana na wartość Y[PKM pomno oną przez stosowaną wewnątrz struktur sterujących. wartość zmiennej OPQPKM. Przy pierwszej Przypomnijmy, e instrukcja DTGCM pozwala iteracji pętli zmienna Y[PKM będzie równa 1 opuścić aktualną pętlę lub instrukcję (1·1). W drugiej iteracji będzie równa 2 (1·2), UYKVEJ. Oto przykładowy sposób jej u ycia: w trzeciej 6 (2·3), w czwartej 24 (6·4), YJKNG YCTWPGM ] a w piątej i ostatniej 120 (24·5). /* Wykonaj cokolwiek. */ KH YCTWPGM ] 6. Zwiększ wartość zmiennej OPQPKM o 1. DTGCM /* Opuszczenie pętli. */ OPQPKM _ _ W pewien sposób jest to najwa niejszy wiersz Instrukcja EQPVKPWG pozwala opuścić pętli. Jeśli wartość zmiennej mno nik nie aktualną iterację pętli i powrócić byłaby zwiększana, warunek trwania pętli do sprawdzania warunku. Po sprawdzeniu byłby zawsze prawdziwy, więc powstałaby warunku pętla mo e, ale nie musi, być pętla nieskończona. wykonywana po raz kolejny. YJKNG YCTWPGM ] 7. Dokończ pętlę YJKNG. /* Wykonaj cokolwiek. */ _ // Koniec pętli. KH YCTWPGM ] Pętla while EQPVKPWG /* Powrót do początku pętli. */ Gdy kod staje się coraz to bardziej zło ony, _ warto oznaczać komentarzem, której pętli _ dotyczy dane zakończenie. Warto podkreślić, e przedstawione powy ej instrukcje działają tylko w pętlach 8. Wyświetlenie wyników obliczeń. i instrukcjach UYKVEJ. Nie są aktywne w instrukcjach KH. RTKPVH 5KNPKC NKED[ W VQ WP åNKEDC Y[PKM Inną konstrukcją języka C jest instrukcja GZKV powodująca wyłączenie całej aplikacji. Instrukcja RTKPVH wyświetla zarówno Pod koniec ksią ki poka emy, w jaki parametr silni, jak i sam wynik obliczeń. sposób skorzystać z tej instrukcji, jeśli w trakcie działania programu wystąpi 9. Dokończ funkcję OCKP . powa ny problem. IGVEJCT TGVWTP _ 10. Zapisz dokument w pliku silnia.c. 11. Skompiluj kod źródłowy. 92
  32. 32. Struktury sterujące 12. Uruchom aplikację (patrz rysunek 4.14). 13. Dla porównania zmodyfikuj wartość zmiennej NKEDC, a następnie ponownie skompiluj Rysunek 4.14. Uruchomienie aplikacji i uruchom program (patrz rysunek 4.15). pozwala poznać wartość silni dla liczby 5 Wskazówki Istnieje odmiana pętli YJKNG o nazwie FQYJKNG. Główna ró nica między nią a przedstawioną wcześniej wersją polega na tym, e warunek sprawdzany jest na końcu Rysunek 4.15. Wystarczy tylko zmienić pętli (co oznacza, e pętla wykona się co wartość zmiennej liczba, aby program najmniej jeden raz). Oto składnia tej pętli: przedstawił nową wartość silni FQ ] /* instrukcje */ _ YJKNG YCTWPGM W rozdziale 5., „Standardowe wejście i wyjście”, wykorzystamy pętlę YJKNG do ciągłego pobierania znaków z klawiatury. Przedstawiona aplikacja z silnią mo e być doskonałym przykładem problemu Pętla while z przepełnieniem (patrz rozdział 3., „Liczby”). Gdy oblicza się silnię z du ych liczb, bardzo łatwo mo na przekroczyć dopuszczalny zakres wartości liczb całkowitych. 93
  33. 33. Rozdział 4. Listing 4.7. Powrót do przykładu z silnią Pętla for i zamiana pętli while na pętlę for Ostatnią strukturą sterującą omawianą w tym rozdziale (jak i w całej ksią ce) jest pętla HQT. /* silnia2.c - listing 4.7 - modyfikacja listingu 4.6 Podobnie jak pętla YJKNG wykonuje ona pewną å(silnia.c) */ liczbę iteracji, a ka da iteracja składa się z wcześniej KPENWFG UVFKQJ określonych poleceń. Choć działanie obu pętli jest podobne, ich składnia jest zdecydowanie inna. KPV OCKP XQKF ] HQT Y[TC GPKG KPKELCNKWLæEG YCTWPGM Y[TC GPKG åKVGTCE[LPG ] // W tym przykładzie stosujemy tylko liczby /* Zrób cokolwiek. */ ådodatnie. _ WPUKIPGF KPV NKEDC // Wartość, Gdy aplikacja po raz pierwszy dotrze do pętli, åz której wyliczamy silnię. wykonuje wyra enie inicjalizujące. Następnie WPUKIPGF KPV Y[PKM // Zmienna åprzechowująca przyszły wynik - silnię. sprawdzony zostanie warunek działania pętli. WPUKIPGF KPV K // Mno nik u ywany Jeśli będzie prawdziwy, wykona się kod pętli ådo obliczenia silni. (reprezentowany tutaj przez komentarz TÎD EQMQNYKGM). Przed przejściem do następnej iteracji // Przejdź przez wszystkie mno niki od 1 do liczba. zostanie wykonane wyra enie iteracyjne. Następnie HQT K K NKEDC K ] dojdzie do ponownego sprawdzenia warunku. Cały Y[PKM
  34. 34. K // Mno enie wcześniejszego proces będzie się powtarzał (poza wyra eniem åwyniku przez mno nik. inicjalizującym, patrz rysunek 4.16) a do uzyskania Pętla for fałszywego warunku działania pętli. W pętli HQT _ // Koniec pętli. wyra enie iteracyjne jest odpowiedzialne za doprowadzenie w pewnym momencie // Wyświetlenie wyniku. RTKPVH 5KNPKC NKED[ W VQ WP do zmiany warunku pętli na fałsz. åNKEDC Y[PKM Zmodyfikujmy przykład z silnią w taki sposób, aby IGVEJCT /* Zatrzymaj, a u ytkownik naciśnie wykorzystać pętlę HQT. Przekonamy się, e pętli åklawisz Enter lub Return. */ HQT i YJKNG u ywa się w bardzo podobny sposób. TGVWTP Aby użyć pętli for: _ 1. Otwórz plik silnia.c (listing 4.6) w edytorze tekstu lub środowisku IDE. 2. Zmodyfikuj nazwę zmiennej OPQPKM na K oraz nie ustawiaj jej wartości początkowej (patrz listing 4.7). WPUKIPGF KPV K Przyjęło się oznaczać w języku C zmienną związaną z pętlą HQT literą K. Choć nie jest to konieczne, w tym rozdziale zastosujemy się do tego zalecenia. Nie trzeba przy deklaracji ustawiać wartości początkowej zmiennej, gdy zostanie to wykonane w pętli HQT. 94
  35. 35. Struktury sterujące 3. Usuń całą pętlę YJKNG. 4. Rozpocznij definicję pętli HQT. HQT K K NKEDC K ] Przy pierwszym napotkaniu pętli aplikacja ustawi wartość zmiennej K na 1. Następnie, jeśli liczba jest większa lub równa K, pętla będzie wykonywać instrukcję z kroku 5. Po wykonaniu instrukcji z pętli (po ka dej iteracji) nastąpi inkrementacja zmiennej K o 1. 5. Dodaj instrukcję wewnątrz pętli. Y[PKM
  36. 36. K Poniewa mno nik nosi teraz nazwę K, trzeba odpowiednio zmodyfikować wnętrze pętli. Zauwa , e inkrementacja mno nika występuje teraz w definicji pętli i nie stanowi części instrukcji wykonywanych w samej pętli. 6. Zamknij pętlę. _ // Koniec pętli. Rysunek 4.16. Działanie pętli for jest nieco Pętla for inne od działania pętli while, gdy dochodzi 7. Zapisz dokument w pliku silnia2.c. inicjalizacja zmiennej i wyra enie inkrementacyjne 8. Skompiluj i w razie konieczności popraw kod programu. Uruchom aplikację wynikową (patrz rysunek 4.17). 9. Jeśli chcesz, zmodyfikuj wartość zmiennej Rysunek 4.17. Pętla for oblicza silnię NKEDC, a następnie skompiluj i ponownie równie wydajnie jak pętla while uruchom aplikację. 95
  37. 37. Rozdział 4. Wskazówki Zagnie d anie instrukcji Choć na ogół w pętli HQT korzysta się z trzech osobnych wyra eń, mo na utworzyć bardziej warunkowych i pętli rozbudowane rozwiązanie. Pierwsza i ostatnia Język C umo liwia zagnie d anie ró nych część pętli HQT (wyra enie początkowe struktur sterujących, na przykład i iteracyjne) mo e posiadać wiele wyra eń, umieszczenie jednej instrukcji warunkowej wewnątrz innej, jednej pętli wewnątrz jeśli zostaną one oddzielone przecinkami. drugiej, pętli wewnątrz instrukcji HQT Y[PKM K K NKEDC K ] warunkowej itp. Gdy jednak korzysta się z tego rozwiązania, niezmiernie wa ne Co więcej, wszystkie z trzech wyra eń są jest zachowanie odpowiedniej składni. opcjonalne. Oto kilka sugestii związanych HQT ] z zagnie d aniem struktur sterujących: Zawsze u ywaj otwierających Powy szy kod jest w pełni poprawny i zamykających nawiasów klamrowych i powoduje utworzenie pętli nieskończonej. do oznaczenia początku i końca struktury sterującej. Pętlę HQT bardzo często stosuje się w połączeniu z tablicami, aby wykonać operacje na ich Stosuj coraz większe wcięcia dla kolejnych zagnie d eń. elementach. To zagadnienie przedstawimy dokładniej w rozdziale 6., „Tablice”. Korzystaj z komentarzy w celu opisania działania struktury sterującej. W trakcie zagnie d ania pętli HQT (patrz ramka) W trakcie stosowania zagnie d eń często najbardziej zewnętrzna pętla stosuje często popełnianym błędem jest brak Pętla for zmienną K, bardziej wewnętrzna zmienną L, zrównowa enia liczby nawiasów a najbardziej wewnętrzna zmienną M. otwierających i zamykających. W dalszej części ksią ki pojawi się wiele zagnie d eń. Wszystkie stosują się do powy szych sugestii w celu zminimalizowania liczby błędów. 96

×