Programowanie w języku C. Szybki start

29
Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: [email protected] PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ IDZ DO IDZ DO ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG KATALOG KSI¥¯EK KATALOG KSI¥¯EK TWÓJ KOSZYK TWÓJ KOSZYK CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE O NOWOCIACH ZAMÓW INFORMACJE O NOWOCIACH ZAMÓW CENNIK ZAMÓW CENNI K CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE SPIS TRECI SPIS TRECI DODAJ DO KOSZYKA DODAJ DO KOSZYKA KATALOG ONLINE KATALOG ONLINE Programowanie w jêzyku C. Szybki start B³yskawiczny kurs programowania aplikacji w jêzyku C Jêzyk C, mimo prawie 30-letniej historii, cieszy siê nies³abn¹c¹ popularnoci¹ wró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¿liwoci, 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¿liwoci 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 czynnoci. Wykonuj¹c kolejne przyk³ady z ksi¹¿ki, poznasz wszystkie podstawowe wiadomoci o programowaniu w jêzyku C. • Struktura programu w jêzyku C • Typy danych • Sterowanie dzia³aniem programu • Korzystanie ze standardowego wejcia i wyjcia • Deklarowanie i stosowanie funkcji • Dyrektywy preprocesora • Wskaniki i zarz¹dzanie pamiêci¹ • Obs³uga plików • Z³o¿one typy danych Poznaj zalety i mo¿liwoci najpopularniejszego jêzyka programowania 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

description

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.

Transcript of Programowanie w języku C. Szybki start

Page 1: Programowanie w języku C. Szybki start

Wydawnictwo Helion

ul. Chopina 6

44-100 Gliwice

tel. (32)230-98-63

e-mail: [email protected]

PRZYK£ADOWY ROZDZIA£PRZYK£ADOWY ROZDZIA£

IDZ DOIDZ DO

ZAMÓW DRUKOWANY KATALOGZAMÓW DRUKOWANY KATALOG

KATALOG KSI¥¯EKKATALOG KSI¥¯EK

TWÓJ KOSZYKTWÓJ KOSZYK

CENNIK I INFORMACJECENNIK I INFORMACJE

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW INFORMACJEO NOWO�CIACH

ZAMÓW CENNIKZAMÓW CENNIK

CZYTELNIACZYTELNIA

FRAGMENTY KSI¥¯EK ONLINEFRAGMENTY KSI¥¯EK ONLINE

SPIS TRE�CISPIS TRE�CI

DODAJ DO KOSZYKADODAJ DO KOSZYKA

KATALOG ONLINEKATALOG ONLINE

Programowaniew jêzyku C. Szybki start

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

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

Page 2: Programowanie w języku C. Szybki start

Spis treści

5

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

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

Spis treści

Page 3: Programowanie w języku C. Szybki start

Spis treści

6

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

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

Page 4: Programowanie w języku C. Szybki start

Spis treści

7

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

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

Page 5: Programowanie w języku C. Szybki start

Spis treści

8

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

Page 6: Programowanie w języku C. Szybki start

Struktury sterujące

73

Choć przykłady przedstawione do tej porykorzystały ze zmiennych, przeprowadzały obliczeniai wyświetlały wyniki, brakowało im dynamicznejnatury prawdziwego programowania. Jednymz kluczowych elementów prawdziwych aplikacjijest ich elastyczność zapewniaqna przez strukturysterujące takie jak pętle i instrukcje warunkowe.

Najczęściej stosowaną strukturą sterującą jest warunek�� (jeśli) i jego odmiany: �������, ��������� oraz��������������. Rozdział rozpoczniemy od omówieniawłaśnie tego warunku. W tym czasie natkniemy sięna nowe operatory języka C (poza już wymienionymoperatorami arytmetycznymi i przypisania). Następnieprzejdziemy do dwóch pozostałych instrukcjiwarunkowych — operatora trójargumentowegoi konstrukcji �����. Na końcu rozdziału zajmiemysię dwoma typowymi rodzajami pętli: ���� i ��.Po przeczytaniu tego rozdziału będziesz potrafił pisaćbardziej funkcjonalne aplikację w języku C.

Struktury sterujące 4

Struktury ste

rujące

Page 7: Programowanie w języku C. Szybki start

Rozdział 4.

74

Instrukcja warunkowa ifWarunki to struktury sterujące pozwalającena rozgałęzianie przebiegu programu, czyliuzależnianie jego działania od różnych parametrów.Ze wszystkich rodzajów rozgałęzień najczęściejstosuje się instrukcję ��. Jej składnia jest bardzoprosta:

��������������������������

Warunek umieszcza się wewnątrz nawiasówokrągłych, a instrukcje, które mają zostać wykonane,wewnątrz nawiasów klamrowych. Jeśli warunekjest prawdziwy, instrukcje zostaną wykonane.W przeciwnym razie zostaną pominięte.

W język C najprostszą reprezentacją fałszu jestwartość 0. Wszystko inne traktowane jest jakoprawda.

������������� ����������������������������������������� �������������������������������

W wyniku prawdziwości warunku wykonana możezostać dowolną liczba instrukcji. Jeżeli warunekdotyczy tylko jednej instrukcji, można pominąćnawiasy klamrowe. Oto przykład:

���������� ������������������������������������

Kolejny przykład zobrazuje, w jaki sposób korzystaćz warunków w języku C.

Instrukcja w

arunkowa if

Page 8: Programowanie w języku C. Szybki start

Struktury sterujące

75

Listing 4.1. Podstawowa instrukcja warunkowa

sprawdza, czy zmienna test ma wartość różną od 0

���/* if.c - listing 4.1 */���� �������!�����"#$%������&����������'(�������������)����// Zmienna będąca warunkiem.*+����// Wyświetlenie tekstu wprowadzenia.�,������ �������������&�����������-�����������// Sprawdzenie wartości zmiennej i wyświetlenie������tekstu (jeśli test = 0, tekst się nie wyświetli).�����������������$�������� ��...�/&���������������������������01�2��-��3�������%�����'�(���4���"�����/* Zatrzymaj, aż użytkownik naciśnie������klawisz Enter lub Return. */�*�+��������,��,����

Aby utworzyć warunek if:

1. Utwórz nowy dokument w edytorze tekstulub IDE.

2. Dodaj początkowy komentarz i kod (patrzlisting 4.1).

/* if.c - listing 4.1 */ �������!�����"#����&����������

3. Zadeklaruj i zainicjalizuj zmienną.

���������)���

Zmienna test jest liczbą całkowitą (równiedobrze mogłaby być typu � ��� �������� �,jeśli chcielibyśmy być minimalistami). Posłużynam ona jako element warunku w strukturzesterującej.

4. Dodanie komunikatu początkowego.

��� �������������&�����������-����

Komunikat ten zapewni odpowiedni kontekstdla dowolnego kolejnego tekstu. Gwarantuje,że aplikacja wyświetli jakiś tekst niezależnieod spełnienia warunku (w przeciwnym razieprzy fałszywym warunku tekst nie zostałbywyświetlony).

5. Zdefiniuj warunek ��.

���������������� ��...�/&��������������������01���2��-��3�������

Jeśli warunek jest prawdziwy, zostaniewyświetlony dodatkowy tekst wraz z wartościązmiennej ����. Tak sytuacja wystąpi, gdyzmienna ���� będzie zawierała wartośćróżną od 0. W przeciwnym razie (��������)instrukcja ���� � w ogóle nie zostaniewykonana.

Instru

kcja

warunkowa if

Page 9: Programowanie w języku C. Szybki start

Rozdział 4.

76

6. Dokończ funkcję ��� �.

��4���"�����������,��

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���� równej 0, ponownie skompiluj aplikację,ustawiając ���� na 0 (patrz rysunek 4.2).

W tym przypadku warunek jest fałszywy,więc druga instrukcja ���� � nie zostaniewykonana.

Wskazówki

� Tworzenie instrukcji warunkowej dla jednegopolecenia bez stosowania nawiasów klamrowychjest co prawda w pełni poprawne, ale możeprowadzić do błędów, jeśli w przyszłości będziesię dokonywać modyfikacji warunku. Choć torozwiązanie jest bardzo kuszące i można sięna nie natknąć, przeglądając kod napisany przezinne osoby, nie warto go stosować.

� Standard C99 wprowadza nowy typ danejo nazwie ����� — wartość logiczna. Zmiennetego typu zawsze będą posiadały wartość0 (fałsz) lub 1 (prawda). Wpisanie do zmiennejjakiejkolwiek wartości różnej od 0 spowodujezamianę tej zmiennej na wartość 1. ŚrodowiskoDev-C++ w wersji 4. nie obsługuje typu �����.Jest on dostępny dopiero w wersji betaDev-C++ 5.

� Dodatkowo standard C99 definiuje plikstdbool.h, który zawiera deklarację trzech słówkluczowych: ���� (odpowiednik �����), ���(odpowiednik liczby 1) oraz ����� (odpowiednikliczby 0). Czyni to kod języka C lepiejprzenośnym do języka C++.

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

Instrukcja w

arunkowa if

Page 10: Programowanie w języku C. Szybki start

Struktury sterujące

77

Tabela 4.1. Operatory logiczne i porównania

bardzo często występują w warunkach i innych

strukturach sterujących

Operatory logicznei porównaniaKorzystanie z prostych zmiennych(jak w poprzednim przykładzie) raczej niepozwoli nikomu zajść daleko w programowaniuw języku C. Aby móc tworzyć bardziejzaawansowane instrukcje warunkowe, trzebawykorzystać operatory porównania i logiczne(patrz tabela 4.1).

Operatory porównania wykorzystuje się dlawartoś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.

��������#)��*�������� ��5�������������6�6����78����3���7��&9��4:�����1�����

Operatory logiczne bardzo często stosuje sięw połączeniu z nawiasami, aby utworzyć bardziejzłożone warunki, na przykład zakresy.

���������#�����;;������!��,��������� ��<��4��=�����������>����

Szczególną uwagę należy zwracać na operatorrówności (��). Jednym z najczęstszych błędówpopełnianych przez programistów (także tychwprawionych) jest przypadkowe stosowaniew miejscu operatora równości operatoraprzypisania (�).

�����&�)��+,������

Programista w rzeczywistości chciał sprawdzić,czy wartość zmiennej �� jest równa 190 (chciałnapisać ���������), co może, ale nie musi byćprawdą. Niestety, brak jednego znaku powoduje,iż przedstawiony warunek zawsze będzieprawdziwy (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 operatorydo wyświetlenia różnych tekstów w zależnościod średniej ocen studenta.

Operatory lo

giczn

e i p

orównania

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)

Page 11: Programowanie w języku C. Szybki start

Rozdział 4.

78

Aby wykorzystać operatory logicznei porównania:

1. Utwórz nowy dokument w edytorze tekstulub IDE.

2. Dodaj początkowy komentarz i kod(patrz listing 4.2).

/* srednia.c - listing 4.1 */ �������!�����"#����&����������

3. Zadeklaruj i zainicjalizuj zmienną.

������������)���*�

Zmienna ����� przechowuje średnią ocenstudenta. Na początku zostanie ustawionana wartość ���.

4. Sprawdź, czy studentowi należy się stypendiumza wyniki w nauce.

����������#)�$�,�������� ��@���&��������������&������������������3�������A�&����0���6�2,�� >-��3�����������

Jeśli wartość ����� jest wyższa lub równa ���,wykonujemy instrukcję wyświetlenia tekstuna ekranie. Jeżeli średnia jest mniejsza,pomijamy instrukcję ���� �.

5. Sprawdzenie, czy średnia kwalifikuje siędo otrzymania książki.

�����������#)���+��;;�������!$�,��������� ��@���&��������6A�83�������A�&������0���6�2,�� >-��3���������

Listing 4.2. Dzięki operatorom logicznym

i porównania możliwe jest jednoczesne

sprawdzanie kilku warunków

��/* srednia.c - listing 4.2 */��� �������!�����"#$%�����&����������'(���������������)���*��// Średnia ocen studenta.*+���// Sprawdzenie, czy przysługuje stypendium (średnia�����co najmniej 4.0). ������������������������ ���������������������������������������������� ������!"�������#�������������$����%�&��'�()��"��������* '���+���$���// Sprawdzenie, czy przysługuje książka za wyniki. ,������������������-�.��//��������0������ 1����������������������� ��%# 2"�������#������������$����%�&��'�()��"��������* 3���+�*�+���// Sprawdzenie, czy przysługuje pochwała za wyniki.'�������������������-�3,��//��������0-�.����' �������������������������!4��52"�������#�������������$����%�&��'�()��"��������*''���+���$���4���"�����/* Zatrzymaj, aż użytkownik naciśnie������klawisz Enter lub Return. */�%�'��������,��(�*��

Operatory logiczn

e i porównania

Page 12: Programowanie w języku C. Szybki start

Struktury sterujące

79

Rysunek 4.3. W zależności od zawartości zmiennej

srednia na ekranie pojawiają się różne komunikaty

Korzystając z operatorów logicznychi porównania, sprawdzamy, czy student osiągnąłśrednią większą od 3,9, ale jednocześnie nieprzekroczył średniej 4,0. Z powodu zastosowaniaoperatora iloczynu logicznego (��), aby caływarunek był prawdziwy, oba warunki składowemuszą zwrócić wartość prawdy. Jeśli średniajest mniejsza od 3,9 lub też równa albo większaod 4,0, instrukcja z warunku nie zostaniewykonana.

6. Sprawdzenie, czy student kwalifikuje siędo otrzymania pochwały.

�����������#)���(%��;;�������!��+��������� ��@���&���������"��:83�������A���&����0���6�2,�� >-��3���������

Ostatni z warunków działa dokładnie tak samojak poprzedni, ale korzysta z innych wartościw trakcie testów.

7. Dokończ funkcję ��� �.

��4���"�����������,��

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����� i ponownie skompiluj program(patrz rysunek 4.4).

Rysunek 4.4. Zastosowanie innej wartości srednia powoduje uzyskanie innego wyniku

Operatory lo

giczn

e i p

orównania

Page 13: Programowanie w języku C. Szybki start

Rozdział 4.

80

Wskazówki

� Sposób, w jaki został napisany przykład,powoduje, że dla ����� mniejszej od 3,75nie zostanie wyświetlony żaden komunikat.Poprawimy tę kwestię w następnym przykładzie.Można też dodać kolejny warunek, którywyświetli komunikat dla wartości mniejszejod 3,75.

� Pamiętaj, aby nigdy nie sprawdzać równościdwóch zmiennych typu ���� lub �����.Z racji takiego, a nie innego sposobureprezentacji liczb zmiennoprzecinkowychw komputerze, dwie wartości wydające siębyć identycznymi mogą w rzeczywistościróżnić się na jednej pozycji. Co więcej, liczbacałkowita 2 może nie być równa liczbiezmiennoprzecinkowej 2,0.

� Niektórzy programiści zalecają odwracaniewartości w warunku wykorzystującym równość,gdy jednym ze sprawdzanych elementów jeststała. Oto przykład:

�����$�))�4�����������

Zaletą takiego rozwiązania jest to, że gdyprzypadkowo opuścimy jeden ze znakówrówności, kompilator zgłosi błąd (ponieważnie można przypisać zmiennej do konkretnejwartości).

� Aby sprawdzić, czy dwa ciągi znaków sąidentyczne, używa się specjalnej funkcji��!�� �. Funkcja ta zwraca liczbę różnicmiędzy obu sprawdzanymi tekstami. Jeślizwróconą wartością jest 0, oba teksty sąidentyczne.

�������&���&�3��&���))�,������

Więcej informacji na ten temat znajduje sięw rozdziale 11., „Ciągi znaków”.

Dalszy ciąg kolejnościoperatorów

Podobnie jak operatory arytmetycznetakże operatory logiczne i porównaniamają 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 tejpory operatory, operatory porównaniamają większy priorytet niż operator

przypisania (�), ale niższy priorytetniż operatory arytmetyczne.

Co więcej, operator negacji ($) ma większypriorytet niż mnożenie i dzielenie,natomiast operatory iloczynu i sumy

logicznej (�� i %%) mają większy priorytet

niż operator przypisania (�), ale niższypriorytet niż operatory porównań.

Poza tym operator �� jest ważniejszyod operatora %%.

Pogmatwane? Na pewno. Możnazapamiętać kolejność wykonywaniawszystkich operatorów (pełna listapriorytetów operatorów znajduje sięw dodatku B) lub też po prostu stosowaćnawiasy.

Operatory logiczn

e i porównania

Page 14: Programowanie w języku C. Szybki start

Struktury sterujące

81

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)

Klauzule else i else ifInstrukcja warunkowa �� jest bardzo użyteczna,ale może zostać wzbogacona o dodatkowe elementyza pomocą klauzul ���� i �������. Składniakonstrukcji ������ jest następująca:

����������������/* Zrób coś. */��������/* W przeciwnym razie wykonaj to. */�

Zauważ, że instrukcje z klauzuli ���� zostanąwykonane tylko wtedy, gdy główny warunek niebędzie prawdziwy. Innymi słowy, klauzula ����działa jak odpowiedź domyślna (patrz rysunek 4.5).

Klauzula ������� jest bardziej rozbudowana, gdyżpozwala dodatkowo sprawdzić kolejny warunek,jeśli okazało się, że pierwszy warunek nie byłprawdziwy (patrz rysunek 4.6).

����������� ������/* Zrób coś. */���������������� ������/* Zrób coś innego. */�

Liczba klauzul ������� jest nieograniczona.Często łączy się klauzule ������� i ����. Ważnejest tylko, by klauzula ���� byłą ostatnia (gdyżjest rozwiązaniem domyślnym). Zmodyfikujmywcześniejszy przykład z ocenami, aby uwzględniałnowe instrukcje.

Klauzu

le else

i else

if

Page 15: Programowanie w języku C. Szybki start

Rozdział 4.

82

Aby skorzystać z klauzul else i else if:

1. Otwórz plik srednia.c (listing 4.2) w edytorzetekstu lub środowisku IDE.

2. Usuń wszystkie istniejące warunki(patrz listing 4.3).

Trzy osobne warunki �� zostaną zastąpionejedną dużą konstrukcją ����������������������, więc nie będą już potrzebne.

3. Utwórz główną pętlę.

����������#)�$�,�������� ��@���&��������������&������������������3�������A�&����0���6�2,�� >-��3�������������������������#)���+��������� ��@���&��������6A�83�������A���&����0���6�2,�� >-��3�����������������������#)���(%��������� ��@���&���������"��:83�������A���&����0���6�2,�� >-��3������������������� ��5�A���������:�&�����78�����������3�0��������������������-�����

Same warunki są bardzo podobne do tychz poprzedniego przykładu, ale teraz wszystkostanowi jedną dużą instrukcję warunkową.Aplikacja będzie sprawdzała warunki takdługo, aż któryś z nich nie okaże sięprawdziwy. W przeciwnym razie zostaniewykonana klauzula ����.

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) */���� �������!�����"#$%������&����������'(����������������)���*��// Średnia ocen studenta.*+����// Raport na temat średniej. ������������������������ ���������������������������������������������� ������!"�������#�������������$����%�&��'�()��"��������* '���+������������������-�.��� -����������������������� ��%# 2"�������#�������������$����%�&��'�()��"��������* ����+������������������-�3,��� ,�������������������������!4��52"�������#�������������$����%�&��'�()��"��������* 1���+����� 3�������������6�#���������5����� �72���������������"�$������������������ ��)���* 8���+�+�,���4���"�����/* Zatrzymaj, aż użytkownik naciśnie������klawisz Enter lub Return. */������������,����$��

Klauzu

le else i else if

Page 16: Programowanie w języku C. Szybki start

Struktury sterujące

83

Zauważ, że drugi i trzeci warunek nie musząsprawdzać, czy wartość jest mniejszaod konkretnej liczby. Na przykład, jeśli �����wynosi 3,8, pierwszy i drugi warunek jestfałszywy, a dopiero trzeci jest prawdziwy.W trzecim warunku nie trzeba już sprawdzać,czy ����� jest mniejsza od 3,9, ponieważzostało to stwierdzone już w drugim warunku.Skoro program sprawdza dany warunek, mamypewność, że poprzednie warunki z tej samejkonstrukcji były fałszywe.

4. Zapisz program w pliku srednia2.c, skompiluji uruchom go (patrz rysunek 4.7).

5. Zmień wartość zmiennej ����� 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ątrzklauzul ��, ���� i �������. Zwiększa toczytelność kodu.

� Podobnie jak zwykła konstrukcja ��, także ����i ������� nie wymagają stosowania nawiasówklamrowych, gdy występuje po nich tylko jednainstrukcja. 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

Klauzu

le else

i else

if

Page 17: Programowanie w języku C. Szybki start

Rozdział 4.

84

Operator trójargumentowyJęzyk C posiada składnię alternatywną dlakonstrukcji �������. Jest to tak zwany operatortrójargumentowy. Nazwa wynika z faktu,że operator ten wymaga trzech parametrów(składa się z trzech części). Oto jego podstawowaskładnia:

����������B������������������C�����������������

Zauważmy, że operator ten zwraca jedną z dwóchwartości w zależności od warunku. Zwracanąwartość można przypisać do zmiennej lubwyświetlić. Na przykład poniższy kod zwróciinformację o tym, czy liczba jest wartościąparzystą czy nieparzystą. Do sprawdzeniaparzystości używamy operatora reszty z dzielenia.

!4����������D�����������������D����������)�������7��2����))�,��B�E�E�C�E�E�

Gdyby w tym samym celu zastosować warunek ��,wyglądałby on następująco:

!4����������D�������������������7��2����))�,������������D����������)�E�E����������������D����������)�E�E��

W następnym przykładzie operatortrójargumentowy zostanie wykorzystanydo wyświetlenia odpowiedniego komunikatuw zależności od temperatury.

Aby wykorzystaćoperator trójargumentowy:

1. Utwórz nowy, pusty dokument w edytorzetekstu lub IDE.

2. Dodaj początkowy komentarz i kod(listing 4.4).

/* pogoda.c - listing 4.4 */ �������!�����"#����&����������

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 */���� �������!�����"#$%������&����������'(����������&�������)��*��// Temperatura������w stopniach Celsjusza.*+����������&�������#��,����// Sprawdź,������czy gorąco.�,���������� ��F����2�������3���������������������������7�����4�6���-��3���&��������������������������&�������!��,����// Wyświetl������'zimno' lub 'lodowato' w zależności������ od temperatury.�$�%�������� ��F����2�������3���������������������������2�>-��3���&������3�����������&�������!�,���B������������C����������&������'�(����������// Nie jest ani za gorąco, ani za zimno.�* .�������������9���&��������"�!�������������������������!�5 ������������)��"�����������������*�,�����������$���4���"�����/* Zatrzymaj, aż użytkownik naciśnie������klawisz Enter lub Return. */�%�'��������,��(�*��

Operator trójargumentowy

Page 18: Programowanie w języku C. Szybki start

Struktury sterujące

85

3. Zadeklaruj i zainicjalizuj zmienną całkowitą.

������&�������)��*�

Ta zmienna przechowuje aktualną temperaturęw stopniach Celsjusza.

4. Rozpocznij główny warunek ��.

������&�������#��,�������� ��F����2�������3����������������������7�����4�6���-��3���&��������

Pierwszy warunek sprawdza, czy na dworze jestponad 30 stopni Celsjusza. Jeśli tak, wyświetlaaktualną temperaturę i informuje o tym, że jestgorąco (jest to program dla osób, które lubią,by komputer informował je o rzeczachoczywistych).

5. Dodaj warunek ������� wraz z operatoremtrójargumentowym wewnątrz instrukcji���� �.

�����������&�������!��,�������� ��F����2�������3����������������������2�>-��3���&������3����&���������!�,���B������������C���&�����

Jeśli jest poniżej 10 stopni, aplikacja wyświetli����&��� lub ���� w zależności od tego, jakbardzo jest zimno. Zamiast używać osobnejkonstrukcji �������, stosujemy operatortrójargumentowy wewnątrz instrukcji ���� �.

Znacznik '� wewnątrz tekstu komunikatu określamiejsce, w którym zostanie wstawiona wartośćzwrócona przez operator trójargumentowy(patrz trzeci parametr funkcji ���� �). Operatorsprawdza, czy temperatura ma wartość poniżej 0.Jeśli tak, zwraca wartość ����&���.W przeciwnym razie zwraca wartość ����.Zauważ, że obie wartości to ciągi znaków(ponieważ znajdują się w cudzysłowach).

Operator tró

jargumentowy

Page 19: Programowanie w języku C. Szybki start

Rozdział 4.

86

6. Dokończ warunek.

����������� ��F����2�������3������������������������:��&������&���-��3���&���������

Jeżeli temperatura jest między 10 a 30 stopniami,informujemy o przyjemnej pogodzie za oknem.

7. Zakończ funkcję ��� �.

��4���"�����������,��

8. Zapisz dokument w pliku pogoda.c.

9. Skompiluj kod.

10. Uruchom aplikację (patrz rysunek 4.9).

11. Zmodyfikuj wartość zmiennej ���������,a następnie ponownie skompiluj i uruchomaplikację (patrz rysunek 4.10).

Wskazówki

� Można zmodyfikować przedstawiony powyżejkod, na przykład zmieniając pierwszy warunekna 22 stopnie i dodając w instrukcji ���� �operator trójargumentowy rozróżniający stan!��(� i )�*!�.

� Główną zaletą operatora trójargumentowegojest jego bardzo zwięzły zapis w porównaniuz konstrukcją ������. Wadą jest zmniejszonaprzejrzystość kodu.

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

Operator trójargumentowy

Page 20: Programowanie w języku C. Szybki start

Struktury sterujące

87

Instrukcja switchPoza operatorem trójargumentowym istnieje równieżinna odmiana tradycyjnego warunku, a mianowicieinstrukcja �����. Przyjmuje ona jako swójparametr wartość całkowitą, a następnie sprawdzają względem kilku wymienionych możliwości.Oto przykład:

����!4���������!����,,%C����/* Zrób coś. */����7�� ���!����,,$C����/* Zrób coś innego. */����7�� ��������C����/* Zrób to. */����7�� ��

Instrukcja ����� jest niezmiernie ważna, jeśli chodzio działanie instrukcji �����. Po dotarciu do �����aplikacja opuści cały fragment �����. Jeśli pominiesię �����, wykonane zostaną także pozostałeinstrukcje, nawet te należące do innych możliwości.

Możliwość ������� jest opcjonalna, ale gdy już sięją dodaje, to zazwyczaj na samym końcu instrukcji�����. Jeśli żadna z wcześniejszych możliwościnie będzie poprawna, wykonany zostanie kodmożliwości ������� (działa ona mniej więcejtak samo jak klauzula ����).

Kolejny przykład działa różnie w zależnościod wartości właściwości ���!. Zmienna typu ���,która tak naprawdę jest okrojonym typem � �,bez problemów funkcjonuje w instrukcji �����.

Instru

kcja

switch

Page 21: Programowanie w języku C. Szybki start

Rozdział 4.

88

Aby użyć instrukcji switch:

1. Utwórz nowy, pusty dokument w edytorzetekstu lub IDE.

2. Dodaj początkowy komentarz i kod (listing 4.5).

/* plec.c - listing 4.5 */ �������!�����"#����&����������

3. Zadeklaruj i zainicjalizuj zmienną znakową.

!4��������)�E5E�

Zmienna przechowuje płeć osoby jakopojedynczy znak.

4. Rozpocznij instrukcję �����.

����!4���������

Poprawna składnia instrukcji ����� wymagazastosowania słowa kluczowego �����i podania w nawiasach testowanej zmiennej.Otwierający nawias klamrowy oznacza początekzawartości instrukcji �����.

5. Dodaj pierwszą możliwość.

!���E5EC����� ��G��&�����>-������7�� �

Pierwszy element sprawdza, czy zmiennazawiera wartość +. Jeśli tak, wyświetlany jesttekst ,��������$. Instrukcja ����� wymuszawyjście z konstrukcji �����, aby pozostałeinstrukcje ���� � nie zostały wykonane.

6. Dodaj drugą możliwość.

!���EHEC����� ��G��&����6>-������7�� �

Struktura tego elementu jest taka sama jakelementu z kroku poprzedniego. Po prostutestowana jest inna wartość.

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 */���� �������!�����"#$%�����&���I�����'(�����"�������)�E5E��// Płeć jako znak pojedynczy.*.��������!4����!����// Zmień wyświetlane������pozdrowienie.�, �����!���:6:; '���������������<���������()���* -�������7�� *�$ ,�����!���:=:; 1���������������<���������%()���* 3�������7�� *�* .����������;'����������������<����������� �!4()���*' �������7�� *��'-���+�// Koniec instrukcji switch.�$�%���4���"�����/* Zatrzymaj, aż użytkownik������naciśnie klawisz Enter lub Return. */�'�(��������,��*�+��

Instrukcja switch

Page 22: Programowanie w języku C. Szybki start

Struktury sterujące

89

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 sameinstrukcje dotyczyły kilku możliwości.Wtedy składnia konstrukcji ����� jestnastępująca:

����!4������������!���E5EC���!���E&EC�����/* Zrób coś. */�����7�� ����!���EHEC���!���E�EC������/* I tak dalej... */������7�� ����

7. Dodaj domyślny element i zakończ instrukcję�����.

�������C������� ��G��&���������">-��������7�� ��

Jeśli zmienna ���! nie zawiera wartości + lub -(choć jest to mało prawdopodobne), pojawi sięogólny komunikat.

8. Zakończ funkcję ��� �.

��4���"�����������,��

9. Zapisz dokument w pliku plec.c.

10. Skompiluj przykład.

11. Uruchom aplikację (patrz rysunek 4.11).

12. Dla porównania zmień wartość zmiennejna inną literę lub spację, a następnie ponownieskompiluj i uruchom aplikację (patrzrysunek 4.12).

Wskazówki

� Główną wadą instrukcji ����� jest to, że możnajej używać tylko dla liczb całkowitychi pojedynczych znaków. Znacznie ograniczato jej przydatność. Gdy jednak można jązastosować, byłaby konstrukcją szybsząi bardziej przejrzystą niż ��.

� W języku C istnieje jeszcze jedna instrukcjasterująca nieomawiana w tej książce— instrukcja ��. Osoby zaznajomionez innymi językami, takimi jak na przykładBasic lub Pascal, powinny ją znać, ale taknaprawdę w języku C nie jest ona do niczegopotrzebna.

Instru

kcja

switch

Page 23: Programowanie w języku C. Szybki start

Rozdział 4.

90

Pętla whileInstrukcje warunkowe to tylko jeden rodzajsterowania działaniem programu — drugim są pętle.Język C obsługuje dwie postacie pętli: ���� (i jegosiostra ��������) oraz ��. Każdy z typów pętliwykonuje to samo zadanie — powtarza określonyciąg instrukcji aż do uzyskania fałszywości pewnegowarunku — ale w nieco inny sposób.

Pętla ���� wygląda bardzo podobniedo instrukcji ��, gdyż wykonuje pewneinstrukcje, gdy określony warunek jestprawdziwy.

�4����������������/* Zrób coś. */�

Gdy wykona się jedna iteracja pętli, waruneksprawdzany jest ponownie. Jeżeli nadal jestprawdziwy, zachodzi kolejna iteracja pętli. Jeślijest fałszywy, program przechodzi do następnejinstrukcji po pętli (patrz rysunek 4.13).

Typowym błędem początkujących programistówjest tworzenie pętli, w których warunek nigdynie stanie się fałszywy. Powstaje wtedy pętlanieskończona (aplikacja działa i działa). Z tegopowodu trzeba zapewnić takie określenie zawartościpętli, by w pewnym momencie warunek przestałbyć prawdziwy.

W następnym przykładzie wykorzystamy pętlę���� do napisania programu, który obliczy silnięz wybranej liczby. Silna (reprezentowana przez znakwykrzyknika) to wartość uzyskana z mnożeniawszystkich liczb całkowitych od 1 aż do podanejwartości. Oto przykład:

%>�)���.���.���.�$�.�%�// 120�>�)���.���.���// 6

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

Pętla w

hile

Page 24: Programowanie w języku C. Szybki start

Struktury sterujące

91

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 */���� �������!�����"#$%������&����������'(����// W tym przykładzie stosujemy tylko liczby������dodatnie.*+�������>����������7��)�%��// Wartość, z której������wyliczamy silnię.�,������>������������)����// Zmienna������przechowująca przyszły wynik - silnię.��������>�������&������)����// Mnożnik������używany do obliczenia silni.�������// Przejdź przez wszystkie mnożniki od 1 do liczba. �����4���������� �0����!�7���� , 1��������� �?�������� *�// Mnożenie��������wcześniejszego wyniku przez mnożnik. 3�����@@������ *�// Inkrementacja mnożnika. 8 .���+�// Koniec pętli.�,�����// Wyświetlenie wyniku.�������� ��J���������7��2�����2��-��3��������7�3����������$���4���"�����/* Zatrzymaj, aż użytkownik naciśnie������klawisz Enter lub Return. */�%�'��������,��(�*��

Aby użyć pętli while:

1. Utwórz nowy dokument w edytorze tekstulub IDE.

2. Dodaj początkowy komentarz i kod (listing 4.6).

/* silnia.c - listing 4.6 */ �������!�����"#����&����������

3. Zadeklaruj i ustaw wartości zmiennych.

���>����������7��)�%����>������������)������>�������&������)���

Aplikacja korzysta z trzech wartości całkowitychbez znaku. Przypisujemy zmiennym wartościpoczątkowe. Zmienna �!��� określa wartość,dla której liczymy silnię. Zmienna &.�/przechowuje wyniki obliczeń. Zmienna �����/jest wykorzystywana w pętli do obliczenia silni.

4. Rozpoczęcie pętli ����.

�4����&������!)����7����

Silnię liczymy, mnożąc wynik przez kolejneliczby całkowite od 1 do �!���. Obliczeniawykonujemy w pętli, więc warunek pętlimusi pozwalać wyjść z pętli po wykonaniuodpowiedniej liczby mnożeń. Gdy �����/ jestmniejszy lub równy zmiennej �!���, oznacza to,że obliczenia jeszcze się nie zakończyły i trzebawykonać zawartość pętli. W przeciwnym raziewszystkie obliczenia zostały przeprowadzone.

Pętla

while

Page 25: Programowanie w języku C. Szybki start

Rozdział 4.

92

5. Wykonaj obliczenia.

�����.)�&������

Przy wykorzystaniu operatora przypisaniaz mnożeniem wartość zmiennej &.�/ jestustawiana na wartość &.�/ pomnożoną przezwartość zmiennej �����/. Przy pierwszejiteracji pętli zmienna &.�/ 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 �����/ o 1.

KK&������

W pewien sposób jest to najważniejszy wierszpętli. Jeśli wartość zmiennej mnożnik niebyłaby zwiększana, warunek trwania pętlibyłby zawsze prawdziwy, więc powstałabypętla nieskończona.

7. Dokończ pętlę ����.

��// Koniec pętli.

Gdy kod staje się coraz to bardziej złożony,warto oznaczać komentarzem, której pętlidotyczy dane zakończenie.

8. Wyświetlenie wyników obliczeń.

��� ��J���������7��2�����2��-��3����7�3�������

Instrukcja ���� � wyświetla zarównoparametr silni, jak i sam wynik obliczeń.

9. Dokończ funkcję ��� �.

��4���"�����������,��

10. Zapisz dokument w pliku silnia.c.

11. Skompiluj kod źródłowy.

Instrukcje break, continue i exit

Instrukcja ����� (która występuje między

innymi we wnętrzu instrukcji �����) jestpo prostu jedną z konstrukcji języka Cstosowaną wewnątrz struktur sterujących.

Przypomnijmy, że instrukcja ����� pozwalaopuścić aktualną pętlę lub instrukcję

�����. Oto przykładowy sposób jej użycia:

�4�����������������/* Wykonaj cokolwiek. */�� �����������������7�����/* Opuszczenie pętli. */����

Instrukcja � �� �� pozwala opuścićaktualną iterację pętli i powrócićdo sprawdzania warunku. Po sprawdzeniuwarunku pętla może, ale nie musi, byćwykonywana po raz kolejny.

�4�����������������/* Wykonaj cokolwiek. */�� ��������������������������/* Powrót do początku pętli. */����

Warto podkreślić, że przedstawionepowyżej instrukcje działają tylko w pętlach

i instrukcjach �����. Nie są aktywne

w instrukcjach ��.

Inną konstrukcją języka C jest instrukcja

�0� powodująca wyłączenie całej aplikacji.Pod koniec książki pokażemy, w jakisposób skorzystać z tej instrukcji, jeśliw trakcie działania programu wystąpipoważny problem.

Pętla w

hile

Page 26: Programowanie w języku C. Szybki start

Struktury sterujące

93

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

12. Uruchom aplikację (patrz rysunek 4.14).

13. Dla porównania zmodyfikuj wartość zmiennej�!���, a następnie ponownie skompiluji uruchom program (patrz rysunek 4.15).

Wskazówki

� Istnieje odmiana pętli ���� o nazwie��������. Główna różnica między niąa przedstawioną wcześniej wersją polegana tym, że warunek sprawdzany jest na końcupętli (co oznacza, że pętla wykona się conajmniej jeden raz). Oto składnia tej pętli:

������/* instrukcje */���4�������������

� W rozdziale 5., „Standardowe wejście i wyjście”,wykorzystamy pętlę ���� do ciągłegopobierania znaków z klawiatury.

� Przedstawiona aplikacja z silnią możebyć doskonałym przykładem problemuz przepełnieniem (patrz rozdział 3., „Liczby”).Gdy oblicza się silnię z dużych liczb, bardzołatwo można przekroczyć dopuszczalny zakreswartości liczb całkowitych.

Pętla

while

Page 27: Programowanie w języku C. Szybki start

Rozdział 4.

94

Pętla forOstatnią strukturą sterującą omawianą w tymrozdziale (jak i w całej książce) jest pętla ��.Podobnie jak pętla ���� wykonuje ona pewnąliczbę iteracji, a każda iteracja składa się z wcześniejokreślonych poleceń. Choć działanie obu pętlijest podobne, ich składnia jest zdecydowanie inna.

�������������� �������������������������������������������������/* Zrób cokolwiek. */�

Gdy aplikacja po raz pierwszy dotrze do pętli,wykonuje wyrażenie inicjalizujące. Następniesprawdzony zostanie warunek działania pętli.Jeśli będzie prawdziwy, wykona się kod pętli(reprezentowany tutaj przez komentarz 12�!�/��&�/�). Przed przejściem do następnej iteracjizostanie wykonane wyrażenie iteracyjne. Następniedojdzie do ponownego sprawdzenia warunku. Całyproces będzie się powtarzał (poza wyrażenieminicjalizującym, patrz rysunek 4.16) aż do uzyskaniafałszywego warunku działania pętli. W pętli ��wyrażenie iteracyjne jest odpowiedzialneza doprowadzenie w pewnym momenciedo zmiany warunku pętli na fałsz.

Zmodyfikujmy przykład z silnią w taki sposób, abywykorzystać pętlę ��. Przekonamy się, że pętli�� i ���� używa się w bardzo podobny sposób.

Aby użyć pętli for:

1. Otwórz plik silnia.c (listing 4.6) w edytorzetekstu lub środowisku IDE.

2. Zmodyfikuj nazwę zmiennej �����/ na oraz nie ustawiaj jej wartości początkowej(patrz listing 4.7).

���>��������

Przyjęło się oznaczać w języku C zmiennązwiązaną z pętlą �� literą . Choć nie jest tokonieczne, w tym rozdziale zastosujemy siędo tego zalecenia. Nie trzeba przy deklaracjiustawiać wartości początkowej zmiennej,gdyż zostanie to wykonane w pętli ��.

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) */���� �������!�����"#$%������&����������'(����// W tym przykładzie stosujemy tylko liczby������dodatnie.*+�������>����������7��)�%��// Wartość,������z której wyliczamy silnię.�,������>������������)����// Zmienna������przechowująca przyszły wynik - silnię. ������>��������*�// Mnożnik używany������do obliczenia silni.�������// Przejdź przez wszystkie mnożniki od 1 do liczba. ������������� *���0����!�7�*�@@�����% 1��������� �?���*�// Mnożenie wcześniejszego��������wyniku przez mnożnik.�( 8���+�// Koniec pętli.�+�,���// Wyświetlenie wyniku.�������� ��J���������7��2�����2��-��3���������7�3��������������4���"�����/* Zatrzymaj, aż użytkownik naciśnie������klawisz Enter lub Return. */�$�%��������,��'�(��

Pętla for

Page 28: Programowanie w języku C. Szybki start

Struktury sterujące

95

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

3. Usuń całą pętlę ����.

4. Rozpocznij definicję pętli ��.

������)�����!)����7���KK���

Przy pierwszym napotkaniu pętli aplikacjaustawi wartość zmiennej na 1. Następnie,jeśli liczba jest większa lub równa , pętlabędzie wykonywać instrukcję z kroku 5.Po wykonaniu instrukcji z pętli (po każdejiteracji) nastąpi inkrementacja zmiennej o 1.

5. Dodaj instrukcję wewnątrz pętli.

�����.)��

Ponieważ mnożnik nosi teraz nazwę , trzebaodpowiednio zmodyfikować wnętrze pętli.Zauważ, że inkrementacja mnożnika występujeteraz w definicji pętli i nie stanowi częściinstrukcji 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 poprawkod programu. Uruchom aplikację wynikową(patrz rysunek 4.17).

9. Jeśli chcesz, zmodyfikuj wartość zmiennej�!���, a następnie skompiluj i ponownieuruchom aplikację.

Pętla

for

Page 29: Programowanie w języku C. Szybki start

Rozdział 4.

96

Wskazówki

� Choć na ogół w pętli �� korzysta się z trzechosobnych wyrażeń, można utworzyć bardziejrozbudowane rozwiązanie. Pierwsza i ostatniaczęść pętli �� (wyrażenie początkowei iteracyjne) może posiadać wiele wyrażeń,jeśli zostaną one oddzielone przecinkami.

����������)��3��)�����!)����7���KK������

� Co więcej, wszystkie z trzech wyrażeń sąopcjonalne.

�������������

Powyższy kod jest w pełni poprawnyi powoduje utworzenie pętli nieskończonej.

� Pętlę �� bardzo często stosuje się w połączeniuz tablicami, aby wykonać operacje na ichelementach. To zagadnienie przedstawimydokładniej w rozdziale 6., „Tablice”.

� W trakcie zagnieżdżania pętli �� (patrz ramka)często najbardziej zewnętrzna pętla stosujezmienną , bardziej wewnętrzna zmienną ,a najbardziej wewnętrzna zmienną /.

Zagnieżdżanie instrukcjiwarunkowych i pętli

Język C umożliwia zagnieżdżanie różnychstruktur sterujących, na przykładumieszczenie jednej instrukcji warunkowejwewnątrz innej, jednej pętli wewnątrzdrugiej, pętli wewnątrz instrukcjiwarunkowej itp. Gdy jednak korzysta sięz tego rozwiązania, niezmiernie ważnejest zachowanie odpowiedniej składni.Oto kilka sugestii związanychz zagnieżdżaniem struktur sterujących:

� Zawsze używaj otwierającychi zamykających nawiasów klamrowychdo oznaczenia początku i końcastruktury sterującej.

� Stosuj coraz większe wcięciadla kolejnych zagnieżdżeń.

� Korzystaj z komentarzy w celu opisaniadziałania struktury sterującej.

W trakcie stosowania zagnieżdżeńczęsto popełnianym błędem jest brakzrównoważenia liczby nawiasówotwierających i zamykających.W dalszej części książki pojawi się wielezagnieżdżeń. Wszystkie stosują siędo powyższych sugestii w celuzminimalizowania liczby błędów.

Pętla for