IDZ DO
IDZ DO
PRZYKŁADOWY ROZDZIAŁ
PRZYKŁADOWY ROZDZIAŁ
Programowanie
SPIS TRE CI
SPIS TRE CI
w języku C. Szybki start
KATALOG KSIĄŻEK
KATALOG KSIĄŻEK
Autorzy: Larry Ullman, Marc Liyanage
Tłumaczenie: Rafał Jońca
KATALOG ONLINE
KATALOG ONLINE
ISBN: 83-7361-808-2
Tytuł oryginału: C Programming : Visual
ZAMÓW DRUKOWANY KATALOG
ZAMÓW DRUKOWANY KATALOG
QuickStart Guide (Visual Quickstart Guides)
Format: B5, stron: 400
TWÓJ KOSZYK
TWÓJ KOSZYK
DODAJ DO KOSZYKA
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
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
ZAMÓW INFORMACJE
programistyczne. Zewnętrzne biblioteki, dostępne w sieci oraz dołączane do
O NOWO CIACH
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
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
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
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
Poznaj zalety i możliwo ci najpopularniejszego języka programowania
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
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 zró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
5
Spis treści
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
6
Spis treści
Spis treści
Rozdział 9. Wskazniki 207
Program w pamięci komputera.................................................................208
Operator pobrania adresu zmiennej.........................................................210
Przechowywanie i pobieranie adresów ze zmiennych wskaznikowych....214
Inne spojrzenie na zmienne wskaznikowe ..............................................218
Dereferencja zmiennych wskaznikowych ...............................................220
Przekazanie adresu do funkcji.................................................................224
Tablice, wskazniki i arytmetyka wskaznikowa .......................................228
Tablice wskaznikó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 wskazników na ciągi znaków...............................272
Znajdowanie długości ciągu znaków.......................................................277
Aą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
Spis treści
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
8
Spis treści
Struktury sterujące
Struktury sterujące
4
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
(jeśli) i jego odmiany: , oraz
. Rozdział rozpoczniemy od omówienia
właśnie tego warunku. W tym czasie natkniemy się
na nowe operatory języka C (poza już wymienionym
operatorami arytmetycznymi i przypisania). Następnie
przejdziemy do dwóch pozostałych instrukcji
warunkowych operatora trójargumentowego
i konstrukcji . Na końcu rozdziału zajmiemy
się dwoma typowymi rodzajami pętli: i .
Po przeczytaniu tego rozdziału będziesz potrafił pisać
bardziej funkcjonalne aplikację w języku C.
73
Struktury sterujące
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ę . Jej składnia jest bardzo
prosta:
Warunek umieszcza się wewnątrz nawiasów
okrągłych, a instrukcje, które mają zostać wykonane,
wewnątrz nawiasów klamrowych. Jeśli warunek
jest prawdziwy, instrukcje zostaną wykonane.
W przeciwnym razie zostaną pominięte.
W język C najprostszą reprezentacją fałszu jest
wartość 0. Wszystko inne traktowane jest jako
prawda.
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:
Kolejny przykład zobrazuje, w jaki sposób korzystać
z warunków w języku C.
74
Instrukcja warunkowa if
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
listing 4.1).
/* if.c - listing 4.1 */
// Zmienna będąca warunkiem.
3. Zadeklaruj i zainicjalizuj zmienną.
// Wyświetlenie tekstu wprowadzenia.
// 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 ,
jeśli chcielibyśmy być minimalistami). Posłuży
nam ona jako element warunku w strukturze
sterującej.
4. Dodanie komunikatu początkowego.
/* Zatrzymaj, aż użytkownik naciśnie
klawisz Enter lub Return. */
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 .
Jeśli warunek jest prawdziwy, zostanie
wyświetlony dodatkowy tekst wraz z wartością
zmiennej . Tak sytuacja wystąpi, gdy
zmienna będzie zawierała wartość
różną od 0. W przeciwnym razie ( )
instrukcja w ogóle nie zostanie
wykonana.
75
Instrukcja warunkowa if
Rozdział 4.
6. Dokończ funkcję .
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 sprawdz poprawność kompilacji.
9. Uruchom aplikację (patrz rysunek 4.1).
10. Aby sprawdzić działanie aplikacji dla zmiennej
Rysunek 4.2. Jeśli zmienna test ma wartość
równej 0, ponownie skompiluj aplikację,
równą 0, pojawi się tylko jeden komunikat
ustawiając na 0 (patrz rysunek 4.2).
W tym przypadku warunek jest fałszywy,
więc druga instrukcja nie zostanie
wykonana.
Wskazówki
Tworzenie instrukcji warunkowej dla jednego
polecenia bez stosowania nawiasów klamrowych
jest co prawda w pełni poprawne, ale może
prowadzić do błędów, jeśli w przyszłości będzie
się dokonywać modyfikacji warunku. Choć to
rozwiązanie jest bardzo kuszące i można się
na nie natknąć, przeglądając kod napisany przez
inne osoby, nie warto go stosować.
Standard C99 wprowadza nowy typ danej
o nazwie 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 .
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: (odpowiednik ),
(odpowiednik liczby 1) oraz (odpowiednik
liczby 0). Czyni to kod języka C lepiej
przenośnym do języka C++.
76
Instrukcja warunkowa if
Struktury sterujące
Tabela 4.1. Operatory logiczne i porównania
Operatory logiczne
bardzo często występują w warunkach i innych
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
wykorzystać operatory porównania i logiczne
większy od lub równy
(patrz tabela 4.1).
równy
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.
Wykorzystanie wartości takiego wyrażenia
negacja (not)
(prawda lub fałsz), pozwala konstruować
bardziej przydatne instrukcje warunkowe.
Operatory logiczne bardzo często stosuje się
w połączeniu z nawiasami, aby utworzyć bardziej
złożone warunki, na przykład zakresy.
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 ( ).
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ę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
Operatory logiczne i porównania
Rozdział 4.
Aby wykorzystać operatory logiczne Listing 4.2. Dzięki operatorom logicznym
i porównania możliwe jest jednoczesne
i porównania:
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
(patrz listing 4.2).
/* srednia.c - listing 4.1 */
// Średnia ocen studenta.
3. Zadeklaruj i zainicjalizuj zmienną.
// Sprawdzenie, czy przysługuje stypendium (średnia
co najmniej 4.0).
Zmienna przechowuje średnią ocen
studenta. Na początku zostanie ustawiona
na wartość .
4. Sprawdz, czy studentowi należy się stypendium
// Sprawdzenie, czy przysługuje książka za wyniki.
za wyniki w nauce.
// Sprawdzenie, czy przysługuje pochwała za wyniki.
Jeśli wartość jest wyższa lub równa ,
wykonujemy instrukcję wyświetlenia tekstu
na ekranie. Jeżeli średnia jest mniejsza,
pomijamy instrukcję .
/* Zatrzymaj, aż użytkownik naciśnie
5. Sprawdzenie, czy średnia kwalifikuje się
klawisz Enter lub Return. */
do otrzymania książki.
78
Operatory logiczne i porównania
Struktury sterujące
Korzystając z operatorów logicznych
i porównania, sprawdzamy, czy student osiągnął
średnią większą od 3,9, ale jednocześnie nie
przekroczył średniej 4,0. Z powodu zastosowania
Rysunek 4.3. W zależności od zawartości zmiennej
operatora iloczynu logicznego ( ), aby cały
srednia na ekranie pojawiają się różne komunikaty
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.
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ę .
8. Zapisz program w pliku srednia.c.
9. Skompiluj i sprawdz 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
79
Operatory logiczne i porównania
Rozdział 4.
Wskazówki
Dalszy ciąg kolejności
Sposób, w jaki został napisany przykład,
operatorów
powoduje, że dla mniejszej od 3,75
Podobnie jak operatory arytmetyczne
nie zostanie wyświetlony żaden komunikat.
także operatory logiczne i porównania
Poprawimy tę kwestię w następnym przykładzie.
mają swoją ściśle określoną kolejność
Można też dodać kolejny warunek, który
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 lub .
pory operatory, operatory porównania
Z racji takiego, a nie innego sposobu mają większy priorytet niż operator
przypisania ( ), ale niższy priorytet
reprezentacji liczb zmiennoprzecinkowych
niż operatory arytmetyczne.
w komputerze, dwie wartości wydające się
być identycznymi mogą w rzeczywistości Co więcej, operator negacji ( ) ma większy
priorytet niż mnożenie i dzielenie,
różnić się na jednej pozycji. Co więcej, liczba
natomiast operatory iloczynu i sumy
całkowita 2 może nie być równa liczbie
logicznej ( i ) mają większy priorytet
zmiennoprzecinkowej 2,0.
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
zapamiętać kolejność wykonywania
wszystkich operatorów (pełna lista
Zaletą takiego rozwiązania jest to, że gdy priorytetów operatorów znajduje się
w dodatku B) lub też po prostu stosować
przypadkowo opuścimy jeden ze znaków
nawiasy.
równości, kompilator zgłosi błąd (ponieważ
nie można przypisać zmiennej do konkretnej
wartości).
Aby sprawdzić, czy dwa ciągi znaków są
identyczne, używa się specjalnej funkcji
. Funkcja ta zwraca liczbę różnic
między obu sprawdzanymi tekstami. Jeśli
zwróconą wartością jest 0, oba teksty są
identyczne.
Więcej informacji na ten temat znajduje się
w rozdziale 11., Ciągi znaków .
80
Operatory logiczne i porównania
Struktury sterujące
Klauzule else i else if
Instrukcja warunkowa jest bardzo użyteczna,
ale może zostać wzbogacona o dodatkowe elementy
za pomocą klauzul i . Składnia
konstrukcji jest następująca:
/* Zrób coś. */
/* W przeciwnym razie wykonaj to. */
Zauważ, że instrukcje z klauzuli 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
działa jak odpowiedz 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żne
Rysunek 4.6. Diagram przedstawia działanie
jest tylko, by klauzula byłą ostatnia (gdyż
warunku if-else if (elementów else if może być
jest rozwiązaniem domyślnym). Zmodyfikujmy
nieskończenie dużo)
wcześniejszy przykład z ocenami, aby uwzględniał
nowe instrukcje.
81
Klauzule else i else if
Rozdział 4.
Listing 4.3. Korzystając z klauzul else i else if,
Aby skorzystać 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
(srednia.c) */
(patrz listing 4.3).
Trzy osobne warunki zostaną zastąpione
jedną dużą konstrukcją
, więc nie będą już potrzebne.
3. Utwórz główną pętlę.
// Średnia ocen studenta.
// Raport na temat średniej.
Same warunki są bardzo podobne do tych
z poprzedniego przykładu, ale teraz wszystko
stanowi jedną dużą instrukcję warunkową. /* Zatrzymaj, aż użytkownik naciśnie
klawisz Enter lub Return. */
Aplikacja będzie sprawdzała warunki tak
długo, aż któryś z nich nie okaże się
prawdziwy. W przeciwnym razie zostanie
wykonana klauzula .
82
Klauzule else i else if
Struktury sterujące
Zauważ, że drugi i trzeci warunek nie muszą
sprawdzać, czy wartość jest mniejsza
od konkretnej liczby. Na przykład, jeśli
wynosi 3,8, pierwszy i drugi warunek jest
fał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, 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 na inną
i ponownie skompiluj oraz uruchom aplikację
(patrz rysunek 4.8).
Wskazówki
Choć nie jest to wymagane, warto wprowadzać
wcięcia dla instrukcji znajdujących się wewnątrz
klauzul , i . Zwiększa to
czytelność kodu.
Podobnie jak zwykła konstrukcja , także
i 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 odpowiedz zostanie wyświetlona
dla średnich poniżej 3,75
83
Klauzule else i else if
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
zwrócić jedną z dwóch wartości
Język C posiada składnię alternatywną dla
konstrukcji . 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
składnia:
// Temperatura
Zauważmy, że operator ten zwraca jedną z dwóch w stopniach Celsjusza.
wartości w zależności od warunku. Zwracaną
// Sprawdz,
wartość można przypisać do zmiennej lub
czy gorąco.
wyświetlić. Na przykład poniższy kod zwróci
informację o tym, czy liczba jest wartością
parzystą czy nieparzystą. Do sprawdzenia
parzystości używamy operatora reszty z dzielenia.
// Wyświetl
'zimno' lub 'lodowato' w zależności
od temperatury.
Gdyby w tym samym celu zastosować warunek ,
wyglądałby on następująco:
// Nie jest ani za gorąco, ani za zimno.
W następnym przykładzie operator
trójargumentowy zostanie wykorzystany
do wyświetlenia odpowiedniego komunikatu
w zależności od temperatury.
/* Zatrzymaj, aż użytkownik naciśnie
klawisz Enter lub Return. */
Aby wykorzystać
operator trójargumentowy:
1. Utwórz nowy, pusty dokument w edytorze
tekstu lub IDE.
2. Dodaj początkowy komentarz i kod
(listing 4.4).
/* pogoda.c - listing 4.4 */
84
Operator trójargumentowy
Struktury sterujące
3. Zadeklaruj i zainicjalizuj zmienną całkowitą.
Ta zmienna przechowuje aktualną temperaturę
w stopniach Celsjusza.
4. Rozpocznij główny warunek .
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 wraz z operatorem
trójargumentowym wewnątrz instrukcji
.
Jeśli jest poniżej 10 stopni, aplikacja wyświetli
lub w zależności od tego, jak
bardzo jest zimno. Zamiast używać osobnej
konstrukcji , stosujemy operator
trójargumentowy wewnątrz instrukcji .
Znacznik wewnątrz tekstu komunikatu określa
miejsce, w którym zostanie wstawiona wartość
zwrócona przez operator trójargumentowy
(patrz trzeci parametr funkcji ). Operator
sprawdza, 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).
85
Operator trójargumentowy
Rozdział 4.
6. Dokończ warunek.
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ę .
Rysunek 4.10. Jeśli jest poniżej 10 stopni,
za pomocą operatora trójargumentowego
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 ,
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
operator trójargumentowy rozróżniający stan
i .
Główną zaletą operatora trójargumentowego
jest jego bardzo zwięzły zapis w porównaniu
z konstrukcją . Wadą jest zmniejszona
przejrzystość kodu.
86
Operator trójargumentowy
Struktury sterujące
Instrukcja switch
Poza operatorem trójargumentowym istnieje również
inna odmiana tradycyjnego warunku, a mianowicie
instrukcja . Przyjmuje ona jako swój
parametr wartość całkowitą, a następnie sprawdza
ją względem kilku wymienionych możliwości.
Oto przykład:
/* Zrób coś. */
/* Zrób coś innego. */
/* Zrób to. */
Instrukcja jest niezmiernie ważna, jeśli chodzi
o działanie instrukcji . Po dotarciu do
aplikacja opuści cały fragment . Jeśli pominie
się , wykonane zostaną także pozostałe
instrukcje, 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ści
nie będzie poprawna, wykonany zostanie kod
możliwości (działa ona mniej więcej
tak samo jak klauzula ).
Kolejny przykład działa różnie w zależności
od wartości właściwości . Zmienna typu ,
która tak naprawdę jest okrojonym typem ,
bez problemów funkcjonuje w instrukcji .
87
Instrukcja switch
Rozdział 4.
Listing 4.5. Instrukcja switch pozwala określić
Aby użyć instrukcji switch:
różne odpowiedzi dla różnych wartości całkowitych
1. Utwórz nowy, pusty dokument w edytorze lub znaków
tekstu lub IDE.
/* plec.c - listing 4.5 */
2. Dodaj początkowy komentarz i kod (listing 4.5).
/* plec.c - listing 4.5 */
3. Zadeklaruj i zainicjalizuj zmienną znakową.
// Płeć jako znak pojedynczy.
// Zmień wyświetlane
Zmienna przechowuje płeć osoby jako pozdrowienie.
pojedynczy znak.
4. Rozpocznij instrukcję .
Poprawna składnia instrukcji wymaga
zastosowania słowa kluczowego
i podania w nawiasach testowanej zmiennej.
Otwierający nawias klamrowy oznacza początek
zawartości instrukcji .
5. Dodaj pierwszą możliwość.
// Koniec instrukcji switch.
/* Zatrzymaj, aż użytkownik
naciśnie klawisz Enter lub Return. */
Pierwszy element sprawdza, czy zmienna
zawiera wartość . Jeśli tak, wyświetlany jest
tekst . Instrukcja wymusza
wyjście z konstrukcji , aby pozostałe
instrukcje nie zostały wykonane.
6. Dodaj drugą możliwość.
Struktura tego elementu jest taka sama jak
elementu z kroku poprzedniego. Po prostu
testowana jest inna wartość.
88
Instrukcja switch
Struktury sterujące
7. Dodaj domyślny element i zakończ instrukcję
.
Rysunek 4.11. Wynik wykonania programu
dla zmiennej ustawionej na wartość M
Jeśli zmienna 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ę .
9. Zapisz dokument w pliku plec.c.
10. Skompiluj przykład.
11. Uruchom aplikację (patrz rysunek 4.11).
12. Dla porównania zmień wartość zmiennej
na inną literę lub spację, a następnie ponownie
skompiluj i uruchom aplikację (patrz
rysunek 4.12).
Wskazówki
Główną wadą instrukcji jest to, że można
jej używać tylko dla liczb całkowitych
Nic nie stoi na przeszkodzie, by te same
i pojedynczych znaków. Znacznie ogranicza
instrukcje dotyczyły kilku możliwości.
to jej przydatność. Gdy jednak można ją
Wtedy składnia konstrukcji jest
zastosować, byłaby konstrukcją szybszą
następująca:
i bardziej przejrzystą niż .
W języku C istnieje jeszcze jedna instrukcja
sterująca nieomawiana w tej książce
/* Zrób coś. */
instrukcja . Osoby zaznajomione
z innymi językami, takimi jak na przykład
Basic lub Pascal, powinny ją znać, ale tak
/* I tak dalej... */
naprawdę w języku C nie jest ona do niczego
potrzebna.
89
Instrukcja switch
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: (i jego
siostra ) oraz . 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 wygląda bardzo podobnie
do instrukcji , gdyż wykonuje pewne
instrukcje, gdy określony warunek jest
prawdziwy.
/* 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ą
tak długo, jak długo warunek jest prawdziwy
prawdziwy, zachodzi kolejna iteracja pętli. Jeśli
jest fałszywy, program przechodzi do następnej
instrukcji po pętli (patrz rysunek 4.13).
Typowym błędem początkujących programistów
jest tworzenie pętli, w których warunek nigdy
nie stanie się fałszywy. Powstaje wtedy pętla
nieskończona (aplikacja działa i działa). Z tego
powodu trzeba zapewnić takie określenie zawartości
pętli, by w pewnym momencie warunek przestał
być prawdziwy.
W następnym przykładzie wykorzystamy pętlę
do napisania programu, który obliczy silnię
z wybranej liczby. Silna (reprezentowana przez znak
wykrzyknika) to wartość uzyskana z mnożenia
wszystkich liczb całkowitych od 1 aż do podanej
wartości. Oto przykład:
// 120
// 6
90
Pętla while
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 */
3. Zadeklaruj i ustaw wartości zmiennych.
// W tym przykładzie stosujemy tylko liczby
dodatnie.
// Wartość, z której
wyliczamy silnię. Aplikacja korzysta z trzech wartości całkowitych
// Zmienna
bez znaku. Przypisujemy zmiennym wartości
przechowująca przyszły wynik - silnię.
początkowe. Zmienna określa wartość,
// Mnożnik
dla której liczymy silnię. Zmienna
używany do obliczenia silni.
przechowuje wyniki obliczeń. Zmienna
// Przejdz przez wszystkie mnożniki od 1 do liczba. jest wykorzystywana w pętli do obliczenia silni.
4. Rozpoczęcie pętli .
// Mnożenie
wcześniejszego wyniku przez mnożnik.
// Inkrementacja mnożnika.
Silnię liczymy, mnożąc wynik przez kolejne
liczby całkowite od 1 do . Obliczenia
// Koniec pętli.
wykonujemy w pętli, więc warunek pętli
musi pozwalać wyjść z pętli po wykonaniu
// Wyświetlenie wyniku.
odpowiedniej liczby mnożeń. Gdy jest
mniejszy lub równy zmiennej , oznacza to,
że obliczenia jeszcze się nie zakończyły i trzeba
/* Zatrzymaj, aż użytkownik naciśnie
wykonać zawartość pętli. W przeciwnym razie
klawisz Enter lub Return. */
wszystkie obliczenia zostały przeprowadzone.
91
Pętla while
Rozdział 4.
5. Wykonaj obliczenia.
Instrukcje break, continue i exit
Instrukcja (która występuje między
Przy wykorzystaniu operatora przypisania
innymi we wnętrzu instrukcji ) jest
z mnożeniem wartość zmiennej jest
po prostu jedną z konstrukcji języka C
ustawiana na wartość pomnożoną przez
stosowaną wewnątrz struktur sterujących.
wartość zmiennej . Przy pierwszej
Przypomnijmy, że instrukcja pozwala
iteracji pętli zmienna będzie równa 1
opuścić aktualną pętlę lub instrukcję
(11). W drugiej iteracji będzie równa 2 (12),
. Oto przykładowy sposób jej użycia:
w trzeciej 6 (23), w czwartej 24 (64),
a w piątej i ostatniej 120 (245).
/* Wykonaj cokolwiek. */
6. Zwiększ wartość zmiennej o 1.
/* Opuszczenie pętli. */
W pewien sposób jest to najważniejszy wiersz
Instrukcja 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ć
wykonywana po raz kolejny.
pętla nieskończona.
7. Dokończ pętlę .
/* Wykonaj cokolwiek. */
// Koniec pętli.
/* Powrót do początku pętli. */
Gdy kod staje się coraz to bardziej złożony,
warto oznaczać komentarzem, której pętli
Warto podkreślić, że przedstawione
dotyczy dane zakończenie.
powyżej instrukcje działają tylko w pętlach
8. Wyświetlenie wyników obliczeń. i instrukcjach . Nie są aktywne
w instrukcjach .
Inną konstrukcją języka C jest instrukcja
powodująca wyłączenie całej aplikacji.
Instrukcja 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ę .
poważny problem.
10. Zapisz dokument w pliku silnia.c.
11. Skompiluj kod zródłowy.
92
Pętla while
Struktury sterujące
12. Uruchom aplikację (patrz rysunek 4.14).
13. Dla porównania zmodyfikuj wartość zmiennej
, a następnie ponownie skompiluj
i uruchom program (patrz rysunek 4.15).
Rysunek 4.14. Uruchomienie aplikacji
pozwala poznać wartość silni dla liczby 5
Wskazówki
Istnieje odmiana pętli o nazwie
. 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
/* instrukcje */
W rozdziale 5., Standardowe wejście i wyjście ,
wykorzystamy pętlę do ciągłego
pobierania znaków z klawiatury.
Przedstawiona aplikacja z silnią może
być doskonałym przykładem problemu
z przepełnieniem (patrz rozdział 3., Liczby ).
Gdy oblicza się silnię z dużych liczb, bardzo
łatwo można przekroczyć dopuszczalny zakres
wartości liczb całkowitych.
93
Pętla while
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 .
/* silnia2.c - listing 4.7 - modyfikacja listingu 4.6
(silnia.c) */
Podobnie jak pętla wykonuje ona pewną
liczbę iteracji, a każda iteracja składa się z wcześniej
określonych poleceń. Choć działanie obu pętli
jest podobne, ich składnia jest zdecydowanie inna.
// W tym przykładzie stosujemy tylko liczby
dodatnie.
/* Zrób cokolwiek. */
// Wartość,
z której wyliczamy silnię.
Gdy aplikacja po raz pierwszy dotrze do pętli,
// Zmienna
wykonuje wyrażenie inicjalizujące. Następnie
przechowująca przyszły wynik - silnię.
sprawdzony zostanie warunek działania pętli.
// Mnożnik używany
Jeśli będzie prawdziwy, wykona się kod pętli
do obliczenia silni.
(reprezentowany tutaj przez komentarz
// Przejdz przez wszystkie mnożniki od 1 do liczba.
). Przed przejściem do następnej iteracji
zostanie wykonane wyrażenie iteracyjne. Następnie
dojdzie do ponownego sprawdzenia warunku. Cały
// 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
fałszywego warunku działania pętli. W pętli // Koniec pętli.
wyrażenie iteracyjne jest odpowiedzialne
// Wyświetlenie wyniku.
za doprowadzenie w pewnym momencie
do zmiany warunku pętli na fałsz.
Zmodyfikujmy przykład z silnią w taki sposób, aby
/* Zatrzymaj, aż użytkownik naciśnie
wykorzystać pętlę . Przekonamy się, że pętli
klawisz Enter lub Return. */
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 edytorze
tekstu 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 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 .
94
Pętla for
Struktury sterujące
3. Usuń całą pętlę .
4. Rozpocznij definicję pętli .
Przy pierwszym napotkaniu pętli aplikacja
ustawi wartość zmiennej na 1. Następnie,
jeśli liczba jest większa lub równa , pętla
będzie wykonywać instrukcję z kroku 5.
Po wykonaniu instrukcji z pętli (po każdej
iteracji) nastąpi inkrementacja zmiennej o 1.
5. Dodaj instrukcję wewnątrz pętli.
Ponieważ mnożnik nosi teraz nazwę , 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
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
, a następnie skompiluj i ponownie
Rysunek 4.17. Pętla for oblicza silnię
uruchom aplikację.
równie wydajnie jak pętla while
95
Pętla for
Rozdział 4.
Wskazówki
Zagnieżdżanie instrukcji
Choć na ogół w pętli korzysta się z trzech
warunkowych i pętli
osobnych wyrażeń, można utworzyć bardziej
Język C umożliwia zagnieżdżanie różnych
rozbudowane rozwiązanie. Pierwsza i ostatnia
struktur sterujących, na przykład
część pętli (wyrażenie początkowe
umieszczenie jednej instrukcji warunkowej
i iteracyjne) może posiadać wiele wyrażeń,
wewnątrz innej, jednej pętli wewnątrz
jeśli zostaną one oddzielone przecinkami.
drugiej, pętli wewnątrz instrukcji
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
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ę bardzo często stosuje się w połączeniu
Stosuj coraz większe wcięcia
z tablicami, aby wykonać operacje na ich
dla kolejnych zagnieżdżeń.
elementach. To zagadnienie przedstawimy
Korzystaj z komentarzy w celu opisania
dokładniej w rozdziale 6., Tablice .
działania struktury sterującej.
W trakcie zagnieżdżania pętli (patrz ramka)
W trakcie stosowania zagnieżdżeń
często najbardziej zewnętrzna pętla stosuje
często popełnianym błędem jest brak
zmienną , bardziej wewnętrzna zmienną ,
zrównoważenia liczby nawiasów
a najbardziej wewnętrzna zmienną . 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
Pętla for
Wyszukiwarka
Podobne podstrony:
Programowanie w jezyku C Szybki start procpp01 Wprowadzenie do programowania w jezyku CPHP6 i MySQL 5 Dynamiczne strony WWW Szybki start ph6ms5Efektywne Programowanie W Języku JavaLab Programowanie w jezyku powlokiVisual Basic Net Szybki startAdobe Air i Ajax Szybki startA Poznański Programowanie w języku C dla chętnychOracle?tabaseg Programowanie w jezyku PL SQL or10psWprowadzenie do programowania w języku Cwięcej podobnych podstron