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.
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. 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. 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. 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. 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. 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. 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. 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.
10.
11. 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
12.
13.
14. 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
15. 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
16. 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
17. 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
18. 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
19. 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
20. 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
21. 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
22. 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
23. 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
24. 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
25. 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
26. 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
27. 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
28. 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
29. 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:
32. 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
33. 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
35. 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
36. 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
37. 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
38. 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
39. 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
40. 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
41. 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