Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00487 007856 10467406 na godz. na dobę w sumie
Programowanie w języku C. Szybki start - książka
Programowanie w języku C. Szybki start - książka
Autor: , Liczba stron: 400
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-808-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c - programowanie
Porównaj ceny (książka, ebook, audiobook).

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.

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

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Programowanie w jêzyku C. Szybki start Autorzy: Larry Ullman, Marc Liyanage T³umaczenie: Rafa³ Joñca ISBN: 83-7361-808-2 Tytu³ orygina³u: C Programming : Visual QuickStart Guide (Visual Quickstart Guides) Format: B5, stron: 400 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 Spis treści Spis treści Wprowadzenie Dlaczego właśnie język C?...................................................w.....................10 Sposób działania języka C...................................................w......................11 Co będzie potrzebne? ...................................................w.............................12 O książce ...................................................w................................................13 Uzyskanie pomocy ...................................................w.................................15 9 Rozdział 1. Zaczynamy przygodę z językiem C 17 Składnia podstawowa ...................................................w.............................18 Wyświetlanie tekstu ...................................................w...............................21 Kompilacja i uruchomienie programu...................................................w....23 Unikanie zamknięcia aplikacji ...................................................w...............28 Dodanie komentarzy do kodu źródłowego................................................30 Stosowanie białych znaków ...................................................w...................33 Rozdział 2. Typy danych 35 Rozdział 3. Poprawna składnia zmiennych ...................................................w...............36 Przypisanie wartości do zmiennej ...................................................w..........40 Wyświetlanie zmiennych ...................................................w.......................41 Znaki...................................................w...................................................w....44 Ciągi znaków...................................................w..........................................46 Stałe...................................................w...................................................w.....48 Liczby 51 Wybór odpowiedniego typu danych numerycznych .................................52 Operacje arytmetyczne ...................................................w...........................55 Operatory inkrementacji i dekrementacji ..................................................60 Kolejność wykonywania operatorów ...................................................w.....63 Przepełnienie i niedomiar...................................................w.......................66 Konwersja zmiennych ...................................................w............................70 Rozdział 4. Struktury sterujące 73 Instrukcja warunkowa if...................................................w.........................74 Operatory logiczne i porównania...................................................w..............77 Klauzule else i else if ...................................................w.............................81 5 S p i s t r e ś c i Spis treści Operator trójargumentowy ...................................................w.....................84 Instrukcja switch ...................................................w....................................87 Pętla while ...................................................w..............................................90 Pętla for ...................................................w..................................................94 Rozdział 5. Standardowe wejście i wyjście 97 Pobranie pojedynczego znaku ...................................................w................98 Pobranie całego słowa ...................................................w..........................103 Odczyt danych liczbowych ...................................................w..................107 Odczyt wielu wartości ...................................................w..........................111 Walidacja otrzymanych danych ...................................................w...........116 Zaawansowane wykorzystanie funkcji printf() .......................................120 Rozdział 6. Tablice 123 Wprowadzenie do tablic...................................................w.......................124 Przypisywanie wartości do tablicy ...................................................w.......126 Dostęp do wartości tablicy ...................................................w...................131 Definiowanie tablic za pomocą stałych...................................................w134 Przechodzenie przez elementy tablicy w pętli.........................................136 Tablice znaków ...................................................w....................................139 Tablice wielowymiarowe ...................................................w.....................144 Rozdział 7. Tworzenie własnych funkcji 149 Tworzenie prostych funkcji...................................................w..................150 Funkcje przyjmujące argumenty ...................................................w...........154 Tworzenie funkcji zwracającej wartość ..................................................159 Tworzenie funkcji typu inline ...................................................w..............165 Rekurencja...................................................w............................................168 Zasięg zmiennych...................................................w.................................172 Rozdział 8. Preprocesor języka C 177 Wprowadzenie do preprocesora języka C ...............................................178 Wykorzystanie stałych ...................................................w.........................185 Makra przypominające funkcje ...................................................w.............188 Makra jako funkcje i przyjmowanie argumentów...................................191 Tworzenie i dołączanie plików nagłówkowych ......................................196 Dołączanie plików nagłówkowych..................................................w........200 Tworzenie warunków ...................................................w...........................203 6 i c ś e r t s i p S Rozdział 9. Wskaźniki Spis treści 207 Program w pamięci komputera ...................................................w..............208 Operator pobrania adresu zmiennej...................................................w......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...................................................w..............224 Tablice, wskaźniki i arytmetyka wskaźnikowa .......................................228 Tablice wskaźników ...................................................w.............................233 Rozdział 10. Zarządzanie pamięcią 239 Pamięć statyczna i dynamiczna ...................................................w.............240 Rzutowanie typów...................................................w................................245 Alokacja tablic o rozmiarze dynamicznym .............................................249 Zmiana rozmiaru bloku pamięci...................................................w............253 Zwracanie pamięci z funkcji ...................................................w................262 Zapobieganie wyciekom pamięci ...................................................w...........268 Rozdział 11. Ciągi znaków 271 Podstawowa składnia wskaźników na ciągi znaków...............................272 Znajdowanie długości ciągu znaków...................................................w....277 Łączenie ciągów znaków (konkatenacja)................................................281 Porównywanie ciągów znaków ...................................................w............285 Kopiowanie ciągów znaków ...................................................w................291 Sortowanie ciągów znaków...................................................w..................296 S p i s t r e ś c i Rozdział 12. Tworzenie napisów i plansz tytułowych 303 Otwarcie i zamknięcie pliku...................................................w.................304 Zapis danych do pliku ...................................................w..........................310 Odczyt danych z plików ...................................................w.......................317 Przetwarzanie danych odczytanych z pliku.............................................321 Zapis danych binarnych..................................................w.........................323 Odczyt plików binarnych ...................................................w.....................329 Poruszanie się po pliku binarnym...................................................w.........332 Rozdział 13. Stosowanie efektów 337 Wprowadzenie do struktur ...................................................w...................338 Konstrukcja typedef ...................................................w.............................345 Tablice struktur ...................................................w....................................350 Wprowadzenie do list...................................................w...........................356 7 Spis treści Dodatek A Instalacja i obsługa narzędzi programistycznych Dev-C++ dla systemu Windows ...................................................w..........370 Korzystanie ze środowiska Dev-C++...................................................w...372 Aplikacja Xcode z systemu Mac OS X ...................................................w375 Narzędzia dostępne w systemach uniksowych........................................377 Znajdowanie błędów za pomocą programu uruchomieniowego GDB ...378 Inne narzędzia ...................................................w......................................380 369 Dodatek B Materiały dodatkowe 381 Witryny internetowe...................................................w.............................382 Tabele ...................................................w...................................................w384 Skorowidz 387 i c ś e r t s i p S 8 Struktury sterujące 4 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 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. S t r u k t u r y s t e r u j ą c e 73 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 prawda. KH  ] RTKPVH 6GPYCTWPGMCYUGLGUVRTCYFKY[  RTKPVH 6QLGUVMQNGLPCKPUVTWMELC  _ 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 6GPYCTWPGMCYUGLGUV åRTCYFKY[  Kolejny przykład zobrazuje, w jaki sposób korzystać z warunków w języku C. f i a w o k n u r a w a j c k u r t s n I 74 Listing 4.1. Podstawowa instrukcja warunkowa sprawdza, czy zmienna test ma wartość różną od 0 Aby utworzyć warunek if: Struktury sterujące /* if.c - listing 4.1 */  KPENWFGUVFKQJ  KPVOCKP XQKF ]  KPVVGUV// Zmienna będąca warunkiem.  // Wyświetlenie tekstu wprowadzenia. RTKPVH 6GUVQYCPGOKGPPGLVGUV P   // Sprawdzenie wartości zmiennej i wyświetlenie åtekstu (jeśli test = 0, tekst się nie wyświetli). KH VGUV ] RTKPVH   OKGPPCVGUVCYKGTC åYCTVQħèF PVGUV  _  IGVEJCT /* Zatrzymaj, aż użytkownik naciśnie åklawisz Enter lub Return. */  TGVWTP  _ 1. Utwórz nowy dokument w edytorze tekstu lub IDE. 2. Dodaj początkowy komentarz i kod (patrz listing 4.1). /* if.c - listing 4.1 */ KPENWFGUVFKQJ KPVOCKP XQKF ] 3. Zadeklaruj i zainicjalizuj zmienną. KPVVGUV Zmienna test jest liczbą całkowitą (równie dobrze mogłaby być typu WPUKIPGFUJQTVKPV, jeśli chcielibyśmy być minimalistami). Posłuży nam ona jako element warunku w strukturze sterującej. 4. Dodanie komunikatu początkowego. RTKPVH 6GUVQYCPGOKGPPGLVGUV P  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   OKGPPCVGUVCYKGTCYCTVQħè åF PVGUV  _ 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. I n s t r u k c j a w a r u n k o w a i f 75 Rysunek 4.1. Jeśli zmienna test ma wartość różną od 0, zostanie wyświetlony dodatkowy komunikat Rysunek 4.2. Jeśli zmienna test ma wartość równą 0, pojawi się tylko jeden komunikat Rozdział 4. 6. Dokończ funkcję OCKP . IGVEJCT  TGVWTP _ 7. Zapisz projekt w pliku if.c. 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ę, ustawiając VGUV na 0 (patrz rysunek 4.2). W tym przypadku warunek jest fałszywy, więc druga instrukcja RTKPVH nie zostanie wykonana. Wskazówki  Tworzenie instrukcji warunkowej dla jednego 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++. f i a w o k n u r a w a j c k u r t s n I 76 Tabela 4.1. Operatory logiczne i porównania bardzo często występują w warunkach i innych strukturach sterujących Operatory logiczne i porównania Operator Znaczenie       ^^  większy od mniejszy od mniejszy od lub równy większy od lub równy równy różny od iloczyn logiczny (and) suma logiczna (or) negacja (not) Struktury sterujące Operatory logiczne i porównania Korzystanie z prostych zmiennych (jak w poprzednim przykładzie) raczej nie pozwoli nikomu zajść daleko w programowaniu w języku C. Aby móc tworzyć bardziej zaawansowane instrukcje warunkowe, trzeba wykorzystać operatory porównania i logiczne (patrz tabela 4.1). Operatory porównania wykorzystuje się dla wartości liczbowych, na przykład by wskazać, czy dana wartość jest wyższa od innej. Wykorzystanie wartości takiego wyrażenia (prawda lub fałsz), pozwala konstruować bardziej przydatne instrukcje warunkowe. KH YKGM  ] RTKPVH /CUY[UVCTECLæEæNKEDúNCV åD[OÎEIđ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 7YCICPCUVQNCVGM  _ 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 O p e r a t o r y l o g i c z n e i p o r ó w n a n i a Rozdział 4. Aby wykorzystać operatory logiczne i porównania: 1. Utwórz nowy dokument w edytorze tekstu lub IDE. 2. Dodaj początkowy komentarz i kod (patrz listing 4.2). /* srednia.c - listing 4.1 */ KPENWFGUVFKQJ KPVOCKP XQKF ] 3. Zadeklaruj i zainicjalizuj zmienną. HNQCVUTGFPKC Zmienna UTGFPKC przechowuje średnią ocen studenta. Na początku zostanie ustawiona na wartość . 4. Sprawdź, czy studentowi należy się stypendium za wyniki w nauce. KH UTGFPKC  ] RTKPVH 1VT[OWLGUUV[RGPFKWOCY[PKMK åYPCWEGRQPKGYCľOCUħTGFPKæH P åUTGFPKC  _ Jeśli wartość UTGFPKC jest wyższa lub równa , wykonujemy instrukcję wyświetlenia tekstu na ekranie. Jeżeli średnia jest mniejsza, pomijamy instrukcję RTKPVH . 5. Sprawdzenie, czy średnia kwalifikuje się do otrzymania książki. KH UTGFPKC   UTGFPKC ] RTKPVH 1VT[OWLGUMUKæľMúRQPKGYCľOCU åħTGFPKæH PUTGFPKC  _ a i n a n w ó r o p i e n z c i g o l y r o t a r e p O Listing 4.2. Dzięki operatorom logicznym i porównania możliwe jest jednoczesne sprawdzanie kilku warunków /* srednia.c - listing 4.2 */  KPENWFGUVFKQJ  KPVOCKP XQKF ]  HNQCVUTGFPKC// Średnia ocen studenta.  // Sprawdzenie, czy przysługuje stypendium (średnia åco najmniej 4.0). KH UTGFPKC  ] RTKPVH 1VT[OWLGUUV[RGPFKWO åCY[PKMKYPCWEGRQPKGYCľOCU åħTGFPKæH PUTGFPKC  _  // Sprawdzenie, czy przysługuje książka za wyniki. KH UTGFPKC   UTGFPKC ] RTKPVH 1VT[OWLGUMUKæľMúRQPKGYCľ OCUħTGFPKæH PUTGFPKC  _  // Sprawdzenie, czy przysługuje pochwała za wyniki. KH UTGFPKC   UTGFPKC ] RTKPVH 1VT[OWLGURQEJYCđúRQPKGYCľ åOCUħTGFPKæH PUTGFPKC  _  IGVEJCT /* Zatrzymaj, aż użytkownik naciśnie åklawisz Enter lub Return. */  TGVWTP  _ 78 Rysunek 4.3. W zależności od zawartości zmiennej srednia na ekranie pojawiają się różne komunikaty 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 przekroczył średniej 4,0. Z powodu zastosowania 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[OWLGURQEJYCđúRQPKGYCľ åOCUħTGFPKæH PUTGFPKC  _ 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). O p e r a t o r y l o g i c z n e i p o r ó w n a n i a Rysunek 4.4. Zastosowanie innej wartości srednia powoduje uzysknanie innego wyniku 79 Dalszy ciąg kolejności operatorów Podobnie jak operatory arytmetyczne także operatory logiczne i porównania mają swoją ściśle określoną kolejność wykonywania. Na przykład operatory , ,  i  mają wyższy priorytet niż operatory  i . Jeśli uwzględnić wszystkie poznane do tej pory operatory, operatory porównania mają większy priorytet niż operator przypisania (), ale niższy priorytet niż operatory arytmetyczne. Co więcej, operator negacji () ma większy priorytet niż mnożenie i dzielenie, natomiast operatory iloczynu i sumy logicznej ( i ^^) mają większy priorytet niż operator przypisania (), ale niższy priorytet niż operatory porównań. Poza tym operator  jest ważniejszy od operatora ^^. Pogmatwane? Na pewno. Można zapamiętać kolejność wykonywania wszystkich operatorów (pełna lista priorytetów operatorów znajduje się w dodatku B) lub też po prostu stosować nawiasy. Rozdział 4. Wskazówki  Sposób, w jaki został napisany przykład, powoduje, że dla UTGFPKGL mniejszej od 3,75 nie zostanie wyświetlony żaden komunikat. Poprawimy tę kwestię w następnym przykładzie. Można też dodać kolejny warunek, który wyświetli komunikat dla wartości mniejszej od 3,75.  Pamiętaj, aby nigdy nie sprawdzać równości dwóch zmiennych typu HNQCV lub FQWDNG. Z racji takiego, a nie innego sposobu reprezentacji liczb zmiennoprzecinkowych w komputerze, dwie wartości wydające się być identycznymi mogą w rzeczywistości różnić się na jednej pozycji. Co więcej, liczba całkowita 2 może nie być równa liczbie zmiennoprzecinkowej 2,0.  Niektórzy programiści zalecają odwracanie wartości w warunku wykorzystującym równość, gdy jednym ze sprawdzanych elementów jest stała. Oto przykład: KH IQFKP[ ] Zaletą takiego rozwiązania jest to, że gdy przypadkowo opuścimy jeden ze znaków równości, kompilator zgłosi błąd (ponieważ 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 OO  ] Więcej informacji na ten temat znajduje się w rozdziale 11., „Ciągi znaków”. a i n a n w ó r o p i e n z c i g o l y r o t a r e p O 80 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 GNUGKH. 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ą wykonane tylko wtedy, gdy główny warunek nie będzie prawdziwy. Innymi słowy, klauzula GNUG działa jak odpowiedź domyślna (patrz rysunek 4.5). Klauzula GNUGKH jest bardziej rozbudowana, gdyż pozwala dodatkowo sprawdzić kolejny warunek, jeśli okazało się, że pierwszy warunek nie był prawdziwy (patrz rysunek 4.6). KH YCTWPGM ] /* Zrób coś. */ _GNUGKH YCTWPGM ] /* Zrób coś innego. */ _ Liczba klauzul GNUGKH jest nieograniczona. Często łączy się klauzule GNUGKH i GNUG. Ważne jest tylko, by klauzula GNUG byłą ostatnia (gdyż jest rozwiązaniem domyślnym). Zmodyfikujmy wcześniejszy przykład z ocenami, aby uwzględniał nowe instrukcje. K l a u z u l e e l s e i e l s e i f Rysunek 4.5. Diagram przedstawia działanie warunku if-else Rysunek 4.6. Diagram przedstawia działanie warunku if-else if (elementów else if może być nieskończenie dużo) 81 Rozdział 4. Aby skorzystać z klauzul else i else if: 1. Otwórz plik srednia.c (listing 4.2) w edytorze tekstu lub środowisku IDE. 2. Usuń wszystkie istniejące warunki (patrz listing 4.3). Trzy osobne warunki KH zostaną zastąpione jedną dużą konstrukcją KHGNUGKHGNUG KHGNUG, więc nie będą już potrzebne. 3. Utwórz główną pętlę. KH UTGFPKC  ] RTKPVH 1VT[OWLGUUV[RGPFKWOCY[PKMK åYPCWEGRQPKGYCľOCUħTGFPKæH P åUTGFPKC  _GNUGKH UTGFPKC  ] åRTKPVH 1VT[OWLGUMUKæľMúRQPKGYCľ åOCUħTGFPKæH PUTGFPKC  _GNUGKH UTGFPKC  ] åRTKPVH 1VT[OWLGURQEJYCđúRQPKGYCľ åOCUħTGFPKæH PUTGFPKC  _GNUG] RTKPVH /QľGYRT[Uđ[OTQMWDúFKG åNGRKGLħTGFPKCVQPKGYU[UVMQ P  _ Same warunki są bardzo podobne do tych z poprzedniego przykładu, ale teraz wszystko stanowi jedną dużą instrukcję warunkową. Aplikacja będzie sprawdzała warunki tak długo, aż któryś z nich nie okaże się prawdziwy. W przeciwnym razie zostanie wykonana klauzula GNUG. f i e s l e i e s l e e l u z u a l K Listing 4.3. Korzystając z klauzul else i else if, zmodyfikowaliśmy wcześniejszy przykład ze średnią ocen /* srednia2.c - listing 4.3 - przeróbka listingu 4.2 å (srednia.c) */  KPENWFGUVFKQJ  KPVOCKP XQKF ]  HNQCVUTGFPKC// Średnia ocen studenta.  // Raport na temat średniej. KH UTGFPKC  ] RTKPVH 1VT[OWLGUUV[RGPFKWO åCY[PKMKYPCWEGRQPKGYCľOCU åħTGFPKæH PUTGFPKC  _GNUGKH UTGFPKC  ] RTKPVH 1VT[OWLGUMUKæľMúRQPKGYCľ åOCUħTGFPKæH PUTGFPKC  _GNUGKH UTGFPKC  ] RTKPVH 1VT[OWLGURQEJYCđúRQPKGYCľ åOCUħTGFPKæH PUTGFPKC  _GNUG] RTKPVH /QľGYRT[Uđ[OTQMWDúFKG åNGRKGLħTGFPKCVQPKGYU[UVMQ P  _  IGVEJCT /* Zatrzymaj, aż użytkownik naciśnie åklawisz Enter lub Return. */  TGVWTP  _ 82 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  Choć nie jest to wymagane, warto wprowadzać wcięcia dla instrukcji znajdujących się wewnątrz klauzul KH, GNUG i GNUGKH. Zwiększa to czytelność kodu.  Podobnie jak zwykła konstrukcja KH, także GNUG i GNUGKH 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. K l a u z u l e e l s e i e l s e i f 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 Listing 4.4. Operator trójargumentowy często stosuje się jako krótszą wersję warunku if-else, jeśli trzeba zwrócić jedną z dwóch wartości /* pogoda.c - listing 4.4 */  KPENWFGUVFKQJ  KPVOCKP XQKF ]  KPVVGORGTCVWTC// Temperatura åw stopniach Celsjusza.  KH VGORGTCVWTC  ]// Sprawdź, åczy gorąco.  RTKPVH ,GUVFUVQRPKE[NKPCFYQTG åLGUVDCTFQIQTæEQ PVGORGTCVWTC   _GNUGKH VGORGTCVWTC ]// Wyświetl å zimno lub lodowato w zależności å od temperatury.  RTKPVH ,GUVFUVQRPKE[NKPCFYQTG åLGUVU PVGORGTCVWTC å VGORGTCVWTC !NQFQYCVQ åKOPQ   _GNUG]// Nie jest ani za gorąco, ani za zimno.  RTKPVH ,GUVFUVQRPKE[NKPCFYQTG åLGUVECđMKGORT[LGOPKG P åVGORGTCVWTC   _   IGVEJCT /* Zatrzymaj, aż użytkownik naciśnie åklawisz Enter lub Return. */  TGVWTP  _ Rozdział 4. Operator trójargumentowy Język C posiada składnię alternatywną dla konstrukcji KHGNUG. Jest to tak zwany operator trójargumentowy. Nazwa wynika z faktu, że operator ten wymaga trzech parametrów (składa się z trzech części). Oto jego podstawowa składnia: YCTWPGM !Y[PKMAFNCARTCYF[Y[PKMAFNCAHCNUW Zauważmy, że operator ten zwraca jedną z dwóch wartości w zależności od warunku. Zwracaną wartość można przypisać do zmiennej lub wyświetlić. Na przykład poniższy kod zwróci informację o tym, czy liczba jest wartością parzystą czy nieparzystą. Do sprawdzenia parzystości używamy operatora reszty z dzielenia. EJCTRCT[UV[APKGRCT[UV[ RCT[UV[APKGRCT[UV[  NKEDC  ! å R  P  Gdyby w tym samym celu zastosować warunek KH, wyglądałby on następująco: EJCTRCT[UV[APKGRCT[UV[ KH  NKEDC  ] RCT[UV[APKGRCT[UV[ R  _GNUG] RCT[UV[APKGRCT[UV[ P  _ W następnym przykładzie operator trójargumentowy zostanie wykorzystany do wyświetlenia odpowiedniego komunikatu w zależności od temperatury. Aby wykorzystać 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 */ KPENWFGUVFKQJ KPVOCKP XQKF ] 84 y w o t n e m u g r a j ó r t r o t a r e p O Struktury sterujące 3. Zadeklaruj i zainicjalizuj zmienną całkowitą. KPVVGORGTCVWTC Ta zmienna przechowuje aktualną temperaturę w stopniach Celsjusza. 4. Rozpocznij główny warunek KH. KH VGORGTCVWTC  ] RTKPVH ,GUVFUVQRPKE[NKPCFYQTG åLGUVDCTFQIQTæEQ PVGORGTCVWTC  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 GNUGKH wraz z operatorem trójargumentowym wewnątrz instrukcji RTKPVH . _GNUGKH VGORGTCVWTC ] RTKPVH ,GUVFUVQRPKE[NKPCFYQTG åLGUVU PVGORGTCVWTC VGORGTCVWTC å !NQFQYCVQKOPQ  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 GNUGKH, 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). O p e r a t o r t r ó j a r g u m e n t o w y 85 Rysunek 4.9. Jeśli jest ponad 30 stopni, pojawia się następujący komunikat (patrz listing 4.4) Rysunek 4.10. Jeśli jest poniżej 10 stopni, za pomocą operatora trójargumentowego wybierany jest komunikat lodowato lub zimno Rozdział 4. 6. Dokończ warunek. _GNUG] RTKPVH ,GUVFUVQRPKE[NKPCFYQTG åLGUVECđMKGORT[LGOPKG PVGORGTCVWTC  _ Jeżeli temperatura jest między 10 a 30 stopniami, informujemy o przyjemnej pogodzie za oknem. 7. Zakończ funkcję OCKP . IGVEJCT  TGVWTP _ 8. Zapisz dokument w pliku pogoda.c. 9. Skompiluj kod. 10. Uruchom aplikację (patrz rysunek 4.9). 11. Zmodyfikuj wartość zmiennej VGORGTCVWTC, 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. y w o t n e m u g r a j ó r t r o t a r e p O 86 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 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. I n s t r u k c j a s w i t c h 87 Listing 4.5. Instrukcja switch pozwala określić różne odpowiedzi dla różnych wartości całkowitych lub znaków /* plec.c - listing 4.5 */  KPENWFGUVFKQJ  KPVOCKP XQKF ]  EJCTRNGE / // Płeć jako znak pojedynczy.  UYKVEJ RNGE ]// Zmień wyświetlane åpozdrowienie.  ECUG /  RTKPVH 9KVCORCPC P  DTGCM  ECUG -  RTKPVH 9KVCORCPKæ P  DTGCM  FGHCWNV RTKPVH 9KVCOYU[UVMKEJ P  DTGCM  _// Koniec instrukcji switch.  IGVEJCT /* Zatrzymaj, aż użytkownik ånaciśnie klawisz Enter lub Return. */  TGVWTP  _ Rozdział 4. Aby użyć instrukcji switch: 1. Utwórz nowy, pusty dokument w edytorze tekstu lub IDE. 2. Dodaj początkowy komentarz i kod (listing 4.5). /* plec.c - listing 4.5 */ KPENWFGUVFKQJ KPVOCKP XQKF ] 3. Zadeklaruj i zainicjalizuj zmienną znakową. EJCTRNGE /  Zmienna przechowuje płeć osoby jako pojedynczy znak. 4. Rozpocznij instrukcję UYKVEJ. UYKVEJ RNGE ] Poprawna składnia instrukcji UYKVEJ wymaga zastosowania słowa kluczowego UYKVEJ i podania w nawiasach testowanej zmiennej. Otwierający nawias klamrowy oznacza początek zawartości instrukcji UYKVEJ. 5. Dodaj pierwszą możliwość. ECUG /  RTKPVH 9KVCORCPC P  DTGCM Pierwszy element sprawdza, czy zmienna zawiera wartość /. Jeśli tak, wyświetlany jest tekst 9KVCORCPC. Instrukcja DTGCM wymusza wyjście z konstrukcji UYKVEJ, aby pozostałe instrukcje RTKPVH nie zostały wykonane. 6. Dodaj drugą możliwość. ECUG -  RTKPVH 9KVCORCPKæ P  DTGCM Struktura tego elementu jest taka sama jak elementu z kroku poprzedniego. Po prostu testowana jest inna wartość. h c t i w s a j c k u r t s n I 88 Rysunek 4.11. Wynik wykonania programu dla zmiennej ustawionej na wartość M Rysunek 4.12. Jeśli zmienna nie jest równa M ani F, stosowany jest element domyślny  Nic nie stoi na przeszkodzie, by te same instrukcje dotyczyły kilku możliwości. Wtedy składnia konstrukcji UYKVEJ jest następująca: UYKVEJ RNGE ] ECUG /  ECUG O  /* Zrób coś. */ DTGCM ECUG -  ECUG M  /* I tak dalej... */ DTGCM _ Struktury sterujące 7. Dodaj domyślny element i zakończ instrukcję UYKVEJ. FGHCWNV RTKPVH 9KVCOYU[UVMKEJ P  DTGCM _ Jeśli zmienna RNGE nie zawiera wartości / lub - (choć jest to mało prawdopodobne), pojawi się ogólny komunikat. 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 skompiluj i uruchom aplikację (patrz rysunek 4.12). Wskazówki  Główną wadą instrukcji UYKVEJ jest to, że można jej używać tylko dla liczb całkowitych i pojedynczych znaków. Znacznie ogranicza to jej przydatność. Gdy jednak można ją zastosować, byłaby konstrukcją szybszą i bardziej przejrzystą niż KH.  W języku C istnieje jeszcze jedna instrukcja sterująca nieomawiana w tej książce — instrukcja IQVQ. Osoby zaznajomione z innymi językami, takimi jak na przykład Basic lub Pascal, powinny ją znać, ale tak naprawdę w języku C nie jest ona do niczego potrzebna. I n s t r u k c j a s w i t c h 89 Rysunek 4.13. Diagram prezentujący działanie pętli w języku C. Instrukcje wykonywane są tak długo, jak długo warunek jest prawdziwy 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 sprawdzany jest ponownie. Jeżeli nadal jest prawdziwy, zachodzi kolejna iteracja pętli. Jeśli jest fałszywy, program przechodzi do następnej instrukcji po pętli (patrz rysunek 4.13). 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:     // 120   // 6 e l i h w a l t ę P 90 Listing 4.6. Pętla while pomaga policzyć silnię z wybranej liczby. Pętla wykonuje się tak długo, jak długo zmienna mnoznik jest mniejsza lub równa zmiennej liczba /* silnia.c - listing 4.6 */  KPENWFGUVFKQJ  KPVOCKP XQKF ]  // W tym przykładzie stosujemy tylko liczby ådodatnie.  WPUKIPGFKPVNKEDC// Wartość, z której åwyliczamy silnię. WPUKIPGFKPVY[PKM// Zmienna åprzechowująca przyszły wynik - silnię. WPUKIPGFKPVOPQPKM// Mnożnik åużywany do obliczenia silni.  // Przejdź przez wszystkie mnożniki od 1 do liczba. YJKNG OPQPKMNKEDC ]  Y[PKM OPQPKM// Mnożenie åwcześniejszego wyniku przez mnożnik.  OPQPKM// Inkrementacja mnożnika.  _// Koniec pętli.  // Wyświetlenie wyniku. RTKPVH 5KNPKCNKED[WVQW P NKEDCY[PKM   IGVEJCT /* Zatrzymaj, aż użytkownik naciśnie åklawisz Enter lub Return. */  TGVWTP  _ Struktury sterujące Aby użyć pętli while: 1. Utwórz nowy dokument w edytorze tekstu lub IDE. 2. Dodaj początkowy komentarz i kod (listing 4.6). /* silnia.c - listing 4.6 */ KPENWFGUVFKQJ KPVOCKP XQKF ] 3. Zadeklaruj i ustaw wartości zmiennych. WPUKIPGFKPVNKEDC WPUKIPGFKPVY[PKM WPUKIPGFKPVOPQPKM Aplikacja korzysta z trzech wartości całkowitych bez znaku. Przypisujemy zmiennym wartości początkowe. Zmienna NKEDC określa wartość, dla której liczymy silnię. Zmienna Y[PKM przechowuje wyniki obliczeń. Zmienna OPQPKM jest wykorzystywana w pętli do obliczenia silni. 4. Rozpoczęcie pętli YJKNG. YJKNG OPQPKMNKEDC ] Silnię liczymy, mnożąc wynik przez kolejne liczby całkowite od 1 do NKEDC. Obliczenia wykonujemy w pętli, więc warunek pętli musi pozwalać wyjść z pętli po wykonaniu odpowiedniej liczby mnożeń. Gdy OPQPKM jest mniejszy lub równy zmiennej NKEDC, oznacza to, że obliczenia jeszcze się nie zakończyły i trzeba wykonać zawartość pętli. W przeciwnym razie wszystkie obliczenia zostały przeprowadzone. P ę t l a w h i l e 91 Instrukcje break, continue i exit Instrukcja DTGCM (która występuje między innymi we wnętrzu instrukcji UYKVEJ) jest po prostu jedną z konstrukcji języka C stosowaną wewnątrz struktur sterujących. Przypomnijmy, że instrukcja DTGCM pozwala opuścić aktualną pętlę lub instrukcję UYKVEJ. Oto przykładowy sposób jej użycia: YJKNG YCTWPGM ] /* Wykonaj cokolwiek. */ KH YCTWPGM ] DTGCM/* Opuszczenie pętli. */ _ _ Instrukcja EQPVKPWG pozwala opuścić aktualną iterację pętli i powrócić do sprawdzania warunku. Po sprawdzeniu warunku pętla może, ale nie musi, być wykonywana po raz kolejny. YJKNG YCTWPGM ] /* Wykonaj cokolwiek. */ KH YCTWPGM ] EQPVKPWG/* Powrót do początku pętli. */ _ _ Warto podkreślić, że przedstawione powyżej instrukcje działają tylko w pętlach i instrukcjach UYKVEJ. Nie są aktywne w instrukcjach KH. Inną konstrukcją języka C jest instrukcja GZKV powodująca wyłączenie całej aplikacji. Pod koniec książki pokażemy, w jaki sposób skorzystać z tej instrukcji, jeśli w trakcie działania programu wystąpi poważny problem. Rozdział 4. 5. Wykonaj obliczenia. Y[PKM OPQPKM Przy wykorzystaniu operatora przypisania z mnożeniem wartość zmiennej Y[PKM jest ustawiana na wartość Y[PKM pomnożoną przez wartość zmiennej OPQPKM. Przy pierwszej iteracji pętli zmienna Y[PKM będzie równa 1 (1·1). W drugiej iteracji będzie równa 2 (1·2), w trzeciej 6 (2·3), w czwartej 24 (6·4), a w piątej i ostatniej 120 (24·5). 6. Zwiększ wartość zmiennej OPQPKM o 1. OPQPKM W pewien sposób jest to najważniejszy wiersz pętli. Jeśli wartość zmiennej mnożnik nie byłaby zwiększana, warunek trwania pętli byłby zawsze prawdziwy, więc powstałaby pętla nieskończona. 7. Dokończ pętlę YJKNG. _// Koniec pętli. Gdy kod staje się coraz to bardziej złożony, warto oznaczać komentarzem, której pętli dotyczy dane zakończenie. 8. Wyświetlenie wyników obliczeń. RTKPVH 5KNPKCNKED[WVQW P åNKEDCY[PKM  Instrukcja RTKPVH wyświetla zarówno parametr silni, jak i sam wynik obliczeń. 9. Dokończ funkcję OCKP . IGVEJCT  TGVWTP _ 10. Zapisz dokument w pliku silnia.c. 11. Skompiluj kod źródłowy. e l i h w a l t ę P 92 Rysunek 4.14. Uruchomienie aplikacji pozwala poznać wartość silni dla liczby 5 Rysunek 4.15. Wystarczy tylko zmienić wartość zmiennej liczba, aby program przedstawił nową wartość silni Struktury sterujące 12. Uruchom aplikację (patrz rysunek 4.14). 13. Dla porównania zmodyfikuj wartość zmiennej NKEDC, a następnie ponownie skompiluj i uruchom program (patrz rysunek 4.15). 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 pętli (co oznacza, że pętla wykona się co najmniej jeden raz). Oto składnia tej pętli: 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 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. P ę t l a w h i l e 93 Listing 4.7. Powrót do przykładu z silnią i zamiana pętli while na pętlę for /* silnia2.c - listing 4.7 - modyfikacja listingu 4.6 å(silnia.c) */  KPENWFGUVFKQJ  KPVOCKP XQKF ]  // W tym przykładzie stosujemy tylko liczby ådodatnie.  WPUKIPGFKPVNKEDC// Wartość, åz której wyliczamy silnię. WPUKIPGFKPVY[PKM// Zmienna åprzechowująca przyszły wynik - silnię. WPUKIPGFKPVK// Mnożnik używany ådo obliczenia silni.  // Przejdź przez wszystkie mnożniki od 1 do liczba. HQT KKNKEDC K ]  Y[PKM K// Mnożenie wcześniejszego åwyniku przez mnożnik.  _// Koniec pętli.  // Wyświetlenie wyniku. RTKPVH 5KNPKCNKED[WVQW P åNKEDCY[PKM   IGVEJCT /* Zatrzymaj, aż użytkownik naciśnie åklawisz Enter lub Return. */  TGVWTP  _ Rozdział 4. Pętla for Ostatnią strukturą sterującą omawianą w tym rozdziale (jak i w całej książce) jest pętla HQT. Podobnie jak pętla YJKNG wykonuje ona pewną liczbę iteracji, a każda iteracja składa się z wcześniej określonych poleceń. Choć działanie obu pętli jest podobne, ich składnia jest zdecydowanie inna. HQT Y[TCľGPKGKPKELCNKWLæEGYCTWPGMY[TCľGPKG åKVGTCE[LPG ] /* Zrób cokolwiek. */ _ Gdy aplikacja po raz pierwszy dotrze do pętli, wykonuje wyrażenie inicjalizujące. Następnie sprawdzony zostanie warunek działania pętli. Jeśli będzie prawdziwy, wykona się kod pętli (reprezentowany tutaj przez komentarz TÎD EQMQNYKGM). Przed przejściem do następnej iteracji zostanie wykonane wyrażenie iteracyjne. Następnie dojdzie do ponownego sprawdzenia warunku. Cały proces będzie się powtarzał (poza wyrażeniem inicjalizującym, patrz rysunek 4.16) aż do uzyskania fałszywego warunku działania pętli. W pętli HQT wyrażenie iteracyjne jest odpowiedzialne za doprowadzenie w pewnym momencie do zmiany warunku pętli na fałsz. Zmodyfikujmy przykład z silnią w taki sposób, aby wykorzystać pętlę HQT. Przekonamy się, że pętli HQT i YJKNG używa się w bardzo podobny sposób. 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). WPUKIPGFKPVK 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 r o f a l t ę P Rysunek 4.16. Działanie pętli for jest nieco inne od działania pętli while, gdyż dochodzi inicjalizacja zmiennej i wyrażenie inkrementacyjne Rysunek 4.17. Pętla for oblicza silnię równie wydajnie jak pętla while Struktury sterujące 3. Usuń całą pętlę YJKNG. 4. Rozpocznij definicję pętli HQT. HQT KKNKEDC 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 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. 7. Zapisz dokument w pliku silnia2.c. 8. Skompiluj i w razie konieczności popraw kod programu. Uruchom aplikację wynikową (patrz rysunek 4.17). 9. Jeśli chcesz, zmodyfikuj wartość zmiennej NKEDC, a następnie skompiluj i ponownie uruchom aplikację. P ę t l a f o r 95 Rozdział 4. Wskazówki  Choć na ogół w pętli HQT korzysta się z trzech osobnych wyrażeń, można utworzyć bardziej rozbudowane rozwiązanie. Pierwsza i ostatnia część pętli HQT (wyrażenie początkowe i iteracyjne) może posiadać wiele wyrażeń, jeśli zostaną one oddzielone przecinkami. HQT Y[PKMKKNKEDC K ]  Co więcej, wszystkie z trzech wyrażeń są opcjonalne. HQT  ] Powyższy kod jest w pełni poprawny i powoduje utworzenie pętli nieskończonej.  Pętlę HQT bardzo często stosuje się w połączeniu z tablicami, aby wykonać operacje na ich elementach. To zagadnienie przedstawimy dokładniej w rozdziale 6., „Tablice”.  W trakcie zagnieżdżania pętli HQT (patrz ramka) często najbardziej zewnętrzna pętla stosuje zmienną K, bardziej wewnętrzna zmienną L, a najbardziej wewnętrzna zmienną M. r o f a l t ę P Zagnieżdżanie instrukcji warunkowych i pętli Język C umożliwia zagnieżdżanie różnych struktur sterujących, na przykład umieszczenie jednej instrukcji warunkowej wewnątrz innej, jednej pętli wewnątrz drugiej, pętli wewnątrz instrukcji warunkowej itp. Gdy jednak korzysta się z tego rozwiązania, niezmiernie ważne jest zachowanie odpowiedniej składni. Oto kilka sugestii związanych z zagnieżdżaniem struktur sterujących:  Zawsze używaj otwierających i zamykających nawiasów klamrowych do oznaczenia początku i końca struktury sterującej.  Stosuj coraz większe wcięcia dla kolejnych zagnieżdżeń.  Korzystaj z komentarzy w celu opisania działania struktury sterującej. W trakcie stosowania zagnieżdżeń często popełnianym błędem jest brak zrównoważenia liczby nawiasów 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
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Programowanie w języku C. Szybki start
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: