Programowanie strukturalne i obiektowe Podrecznik do nauki zawodu technik informatyk 2

Idź do

• Spis treści
• Przykładowy rozdział

Helion SA

ul. Kościuszki 1c

44-100 Gliwice

tel. 32 230 98 63

e-mail: helion@helion.pl

Katalog książek

Twój koszyk

Cennik i informacje

Czytelnia

Kontakt

• Zamów drukowany

katalog

Programowanie strukturalne

i obiektowe. Podrêcznik do

nauki zawodu technik

informatyk

Autor: Adam Majczak

ISBN: 978-83-246-2389-1

Format: 168237, stron: 392

Podrêcznik jest zgodny z podstaw¹ programow¹ kszta³cenia

w zawodzie technik informatyk 312[01]

Znajomoœæ podstaw programowania – zarówno strukturalnego, jak i obiektowego – jest

integraln¹ czêœci¹ wykszta³cenia technika informatyka. Dziêki temu podrêcznikowi uczeñ

zapozna siê z metodologi¹ programowania, opanuje zasady pisania i modyfikowania

istniej¹cych programów, a tak¿e utrwali wiadomoœci. Materia³ zamieszczony w ksi¹¿ce

obejmuje tematykê zwi¹zan¹ z programowaniem strukturalnym w jêzykach Pascal i C oraz

programowaniem obiektowym w jêzyku C++, wraz z omówieniem regu³, typów danych,

funkcji i mo¿liwoœci ka¿dego z tych jêzyków. Uczeñ znajdzie tu tak¿e oko³o setki

praktycznych przyk³adów oraz propozycje æwiczeñ i zadañ do samodzielnego wykonania.

Podrêcznik ten jest tak¿e zgodny z wytycznymi OKE i CKE do egzaminu zawodowego.
„Technik Informatyk” to doskona³y, charakteryzuj¹cy siê wysok¹ jakoœci¹ i kompletny

zestaw edukacyjny, przygotowany przez dysponuj¹cego ogromnym doœwiadczeniem

lidera na rynku ksi¹¿ek informatycznych – wydawnictwo Helion.
W sk³ad zestawu „Technik Informatyk” wchodz¹ tak¿e:

•

„Systemy i sieci komputerowe. Podrêcznik do nauki zawodu technik

informatyk”

•

„Multimedia i grafika komputerowa. Podrêcznik do nauki zawodu technik

informatyk”

•

„Urz¹dzenia techniki komputerowej. Podrêcznik do nauki zawodu technik

informatyk”

•

„Oprogramowanie biurowe. Podrêcznik do nauki zawodu technik informatyk”

Podrêczniki oraz inne pomoce naukowe nale¿¹ce do tej serii zosta³y opracowane

z myœl¹ o wykszta³ceniu kompetentnych techników, którzy bez trudu poradz¹ sobie

z wyzwaniami w œwiecie wspó³czesnej informatyki.

Spis treści

Wstęp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Część I PASCAL — WProWAdzenIe

do ProgrAmoWAnIA StrukturALnego

rozdział 1. Wybór i instalacja

kompilatora języka Pascal . . . . . . . . . . . . . . . 15

1.1. Współczesne wersje kompilatorów Pascala . . . . . . . . . . . . . . . . .16
1.2. Jak zainstalować i uruchomić kompilator Turbo Pascal? . . . . . . .17

rozdział 2. Pojęcie algorytmu . . . . . . . . . . . . . . . . . . . . . 19

2.1. Sposoby reprezentacji algorytmów . . . . . . . . . . . . . . . . . . . . . . .21

2.1.1.

Opis słowny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.1.2.

Lista kroków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.1.3.

Pseudokod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.1.4.

Schemat blokowy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

rozdział 3. Środowisko IDE Turbo Pascala . . . . . . . . . . . 24

3.1. Instrukcje i elementy języka . . . . . . . . . . . . . . . . . . . . . . . . . . . . .27
3.2. Jeśli zdarzy się błąd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .29

rozdział 4. Ważne polecenia i ważne słowa kluczowe . . 31

4.1. Kompilacja do pamięci RAM i do pliku EXE . . . . . . . . . . . . . . . . .31
4.2. Słowa kluczowe Pascala . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .34

rozdział 5. Iteracja i instrukcje warunkowe . . . . . . . . . . . 36

5.1. Tekst i tło na ekranie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .36
5.2. Iteracja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .38
5.3. Jak komputery dokonują wyboru? . . . . . . . . . . . . . . . . . . . . . . . .43
5.4. Operatory relacji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .47

rozdział 6. Tryb graficzny w Pascalu . . . . . . . . . . . . . . . . 49

6.1. Inicjowanie trybu graficznego . . . . . . . . . . . . . . . . . . . . . . . . . . . .50
6.2. Procedury graficzne Line() i Circle() . . . . . . . . . . . . . . . . . . . . . . .53
6.3. Biblioteka graficzna Turbo Pascala: GRAPH.TPU . . . . . . . . . . . . .55

rozdział 7. Wypełnianie wnętrza obszarów ekranu . . . . . 65

7.1. Stałe i procedury graficzne . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
7.2. Ustawienie grubości i stylu linii . . . . . . . . . . . . . . . . . . . . . . . . . . .69

rozdział 8. Okna i liczby pseudolosowe . . . . . . . . . . . . . 71

8.1. Okno graficzne ViewPort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71
8.2. Generowanie i stosowanie liczb pseudolosowych . . . . . . . . . . . .73

rozdział 9. Tekst i czcionki w trybie graficznym . . . . . . . . 77

9.1. Czcionki w trybie graficznym . . . . . . . . . . . . . . . . . . . . . . . . . . . .77
9.2. Inkrementacja i dekrementacja,

specyfika If-Then-Else w Pascalu . . . . . . . . . . . . . . . . . . . . . . . . .80

rozdział 10. Zmienne . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

10.1. Co to jest zmienna? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .82
10.2. Przypisywanie zmiennym wartości,

czyli inicjowanie zmiennych . . . . . . . . . . . . . . . . . . . . . . . . . . . .83

10.3. Ile miejsca trzeba zarezerwować w pamięci dla zmiennej? . . .85
10.4. Zmienne łańcuchowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .86
10.5. Deklarowanie i inicjowanie zmiennych . . . . . . . . . . . . . . . . . . . .87
10.6. Proste typy zmiennych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88

rozdział 11. Praca w trybie tekstowym . . . . . . . . . . . . . . 91

11.1. Tabela kodów ASCII . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .92

rozdział 12. Znaki semigraficzne

i okna w trybie tekstowym . . . . . . . . . . . . . . 95

12.1. Rysowanie ramek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95
12.2. Podział ekranu na okna w trybie tekstowym . . . . . . . . . . . . . .101

rozdział 13. Obsługa klawiszy specjalnych . . . . . . . . . . 104

13.1. O klawiszach specjalnych . . . . . . . . . . . . . . . . . . . . . . . . . . . . .104
13.2. Instrukcje While i Case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .110

rozdział 14. Macierze jednowymiarowe

i wielowymiarowe . . . . . . . . . . . . . . . . . . . 114

14.1. Tablica jednowymiarowa — wektor . . . . . . . . . . . . . . . . . . . . . .114
14.2. Określanie precyzji wydruku danych numerycznych . . . . . . . .118
14.3. Tablice dwuwymiarowe i wielowymiarowe . . . . . . . . . . . . . . . .120

rozdział 15. Programowanie strukturalne

— wprowadzenie . . . . . . . . . . . . . . . . . . . . 125

15.1. Metodyka Top-Down Design . . . . . . . . . . . . . . . . . . . . . . . . . .126
15.2. Budowanie programu metodą Top-Down . . . . . . . . . . . . . . . .128

rozdział 16. Programowanie strukturalne — funkcje . . . 132

16.1. Procedura może pobierać argument(y) . . . . . . . . . . . . . . . . . .132
16.2. Konstruujemy własne funkcje . . . . . . . . . . . . . . . . . . . . . . . . . .134

rozdział 17. Rekordy — strukturalne typy

danych i zaawansowane funkcje . . . . . . . . 138

17.1. Rekordy, czyli struktury danych . . . . . . . . . . . . . . . . . . . . . . . .138
17.2. Zastosowanie funkcji — rozwiązywanie równań kwadratowych . 140
17.3. Jak narysować wykres funkcji? . . . . . . . . . . . . . . . . . . . . . . . . .142
17.4. Zagnieżdżanie funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .144
17.5. Rekurencja, funkcje rekursywne . . . . . . . . . . . . . . . . . . . . . . . .145

rozdział 18. Programowanie strukturalne

— Bottom-Up Design . . . . . . . . . . . . . . . . . 147

18.1. Metodologia Bottom-Up . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .147
18.2. Zamiana liczb dziesiętnych na dwójkowe . . . . . . . . . . . . . . . .149
18.3. Przez wartość czy przez referencję? . . . . . . . . . . . . . . . . . . . .152

rozdział 19. Pomiar czasu rzeczywistego . . . . . . . . . . 155

19.1. Czas rzeczywisty na ekranie . . . . . . . . . . . . . . . . . . . . . . . . . .155
19.2. Kłopoty z datami . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .156

Część II ProgrAmoWAnIe StrukturALne

W C I C++

rozdział 20. Języki C i C++ — wprowadzenie . . . . . . . 161

20.1. C i C++ a standard ANSI . . . . . . . . . . . . . . . . . . . . . . . . . . . . .161
20.2. Wykorzystanie przykładów z systemu pomocy . . . . . . . . . . . .162
20.3. Jak rozpocząć pracę z C++? . . . . . . . . . . . . . . . . . . . . . . . . .163

rozdział 21. Korygowanie błędów . . . . . . . . . . . . . . . . 169

21.1. Podobieństwa kompilatorów C++ i Turbo Pascala . . . . . . . . . .169
21.2. Pisanie i uruchamianie programów . . . . . . . . . . . . . . . . . . . . .172
21.3. Podstawowe elementy programów w C . . . . . . . . . . . . . . . . . .172

21.3.1.

Stałe i zmienne w C i C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

21.3.2.

Wyrażenia i instrukcje C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

21.3.3.

Operatory arytmetyczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

21.3.4.

Identyfikatory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

21.3.5.

Instrukcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

21.3.6.

Bloki instrukcji, czyli instrukcje złożone . . . . . . . . . . . . . . . . . . . . . . . . 175

21.4. Konstrukcja funkcji w języku C . . . . . . . . . . . . . . . . . . . . . . . . .176

21.4.1.

Jak określa się typ funkcji? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

21.4.2.

Argumenty przekazywane do funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . 177

21.4.3.

Ciało funkcji, czyli kod podprogramu . . . . . . . . . . . . . . . . . . . . . . . . . . 177

rozdział 22. Słowa kluczowe i typy danych C . . . . . . . . 180

22.1. Typ danych char . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .181

22.1.1.

Zmienne i stałe znakowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

22.1.2.

Znaki specjalne — kody sterujące . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183

22.1.3.

Stałe łańcuchy znaków w C i C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

22.1.4.

Numeryczne typy danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185

22.2. Opcje i parametry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .185

rozdział 23. Trzy ważne słowa w C . . . . . . . . . . . . . . . . 188

rozdział 24. Instrukcje sterujące i instrukcje iteracji . . . . 196

24.1. Słowo kluczowe if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .196
24.2. Instrukcja warunkowa if-else . . . . . . . . . . . . . . . . . . . . . . . . . .199
24.3. Zagnieżdżone instrukcje warunkowe if-else-if . . . . . . . . . . . . .200
24.4. Instrukcja switch-case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .201
24.5. Instrukcje break, continue . . . . . . . . . . . . . . . . . . . . . . . . . . . .203

24.5.1.

Przerwanie nieskończonej pętli dzięki instrukcji break . . . . . . . . . . . . . 205

24.5.2.

Instrukcja continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

24.6. Pętle programowe typu for — dokładniej . . . . . . . . . . . . . . . . .207

24.6.1.

Pętla for — szczegóły techniczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

24.6.2.

Instrukcja pusta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

24.6.3.

Dodajemy wyrażenia do nagłówka pętli for . . . . . . . . . . . . . . . . . . . . . 209

24.7. Instrukcja pętli while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .210
24.8. Pętla do-while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .212

rozdział 25. Operatory i sposoby wymiany danych . . . . 217

25.1. Operatory języka C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .217
25.2. Podstawowe typy danych w C . . . . . . . . . . . . . . . . . . . . . . . . .220
25.3. Preinkrementacja i postinkrementacja . . . . . . . . . . . . . . . . . .222
25.4. Różne sposoby użycia funkcji bibliotecznej printf() . . . . . . . . . .224
25.5. Wykorzystanie ograniczonej precyzji

i pułapki formatowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .227

rozdział 26. O obsłudze wejścia/wyjścia w C . . . . . . . . 231

26.1. Różne sposoby stosowania funkcji scanf() . . . . . . . . . . . . . . . .231
26.2. Rodzaje zmiennych, tablice znaków i konwersje typu . . . . . . .232
26.3. Konwersje typów danych . . . . . . . . . . . . . . . . . . . . . . . . . . . . .234
26.4. Jak jedno wyrażenie arytmetyczne

może dać trzy różne wyniki? . . . . . . . . . . . . . . . . . . . . . . . . . .236

rozdział 27. Wskaźniki w C . . . . . . . . . . . . . . . . . . . . . . 238

27.1. Pojęcie wskaźnika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .238
27.2. Wskaźniki i tablice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .242
27.3. Tablice wielowymiarowe i arytmetyka wskaźników . . . . . . . . .243
27.4. Wskaźniki do tablic wielowymiarowych

— przykład praktyczny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .246

rozdział 28. Znaki, teksty i wewnętrzny

format danych . . . . . . . . . . . . . . . . . . . . . . 249

28.1. Zmienne znakowe i tekstowe w praktyce programowania . . .249
28.2. Konwersja liczb dziesiętnych na postać binarną w C . . . . . . . .253
28.3. Liczby zmiennoprzecinkowe typu float . . . . . . . . . . . . . . . . . . .257

rozdział 29. Struktury, unie i więcej o funkcjach . . . . . . 259

29.1. Struktury danych w C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .259
29.2. Wskaźniki i struktury w C/C++ . . . . . . . . . . . . . . . . . . . . . . . . .263
29.3. Pola bitowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .265
29.4. Unie, czyli zmienne wariantowe . . . . . . . . . . . . . . . . . . . . . . .266
29.5. Kategorie i dostępność danych . . . . . . . . . . . . . . . . . . . . . . . .268

29.5.1.

Zmienne statyczne — static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269

29.5.2.

Zmienne automatyczne — auto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269

29.5.3.

Zmienne rejestrowe — register . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270

29.5.4.

Zmienne zewnętrzne — extern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270

29.5.5.

Operator widoczności :: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270

rozdział 30. Jak ważne są funkcje . . . . . . . . . . . . . . . . 272

30.1. Funkcje bezparametrowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . .272
30.2. Dane zwracane przez funkcje . . . . . . . . . . . . . . . . . . . . . . . . .276
30.3. Wskaźniki do funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .277
30.4. Funkcja specjalna main() . . . . . . . . . . . . . . . . . . . . . . . . . . . . .279

rozdział 31. Przekazywanie argumentów,

preprocesor i makroinstrukcje . . . . . . . . . . 284

31.1. Przekazywanie argumentów do funkcji . . . . . . . . . . . . . . . . . .284
31.2. Jak działa preprocesor C? . . . . . . . . . . . . . . . . . . . . . . . . . . . .286
31.3. Makroinstrukcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288

31.3.1.

Dyrektywy #define oraz #undef . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

31.3.2.

Dyrektywy kompilacji warunkowej . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291

31.3.3.

Łączenie łańcuchów przez preprocesor — operator ## . . . . . . . . . . . 293

31.3.4.

Niektóre szczególne dyrektywy preprocesora C++ . . . . . . . . . . . . . . . 294

31.3.5.

Predefiniowane makropolecenia w diagnostyce i uruchamianiu . . . . . 294

rozdział 32. Funkcje, klawisze sterujące,

buforowanie, typ porządkowy . . . . . . . . . . 297

32.1. Funkcje o zmiennej liczbie argumentów . . . . . . . . . . . . . . . . .297
32.2. Typ porządkowy enum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .299
32.3. Funkcje rekurencyjne w C . . . . . . . . . . . . . . . . . . . . . . . . . . . . .299
32.4. Problem sortowania w C . . . . . . . . . . . . . . . . . . . . . . . . . . . . .300

32.4.1.

Co i jak wskazuje wskaźnik typu void? . . . . . . . . . . . . . . . . . . . . . . . . . 300

32.4.2.

Co zwraca operator sizeof? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

32.4.3.

Jak porównywać z sobą dane różnych typów? . . . . . . . . . . . . . . . . . . 305

32.5. Sortowanie liczb za pomocą funkcji qsort() . . . . . . . . . . . . . . .306
32.6. Sortowanie łańcuchów tekstowych . . . . . . . . . . . . . . . . . . . . .307
32.7. Rozpoznawanie klawiszy sterujących w C . . . . . . . . . . . . . . . .309
32.8. Akumulowanie danych w buforze . . . . . . . . . . . . . . . . . . . . . . .312

Część III ProgrAmoWAnIe obIektoWe W C++

rozdział 33. Jak struktury C stały się obiektami C++ . . 317

33.1. Strumienie cin i cout w C++ . . . . . . . . . . . . . . . . . . . . . . . . . . .317

33.1.1.

Teksty, liczby, nowy wiersz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318

33.1.2.

Wczytywanie danych — cin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319

33.1.3.

Konwersja na postać binarną za pomocą unii . . . . . . . . . . . . . . . . . . . 320

33.2. Prosta struktura Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .321
33.3. Struktura danych + funkcje = obiekt . . . . . . . . . . . . . . . . . . . .323
33.4. Prosty obiekt — licznik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .331

rozdział 34. Konstruktory i destruktory . . . . . . . . . . . . . 338

34.1. Konstruktor i jego argumenty . . . . . . . . . . . . . . . . . . . . . . . . . .338
34.2. Destruktor i jego zastosowanie — stos . . . . . . . . . . . . . . . . . . .343

rozdział 35. O dziedziczeniu . . . . . . . . . . . . . . . . . . . . 351

35.1. Na czym polega dziedziczenie? . . . . . . . . . . . . . . . . . . . . . . . .351
35.2. Dziedziczenie złożone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .356

rozdział 36. Metodologia

programowania obiektowego . . . . . . . . . . 360

36.1. Przeciążanie funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .360
36.2. Funkcje wplecione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .361
36.3. Przeciążanie konstruktorów . . . . . . . . . . . . . . . . . . . . . . . . . . .362
36.4. Dostęp do danych za pomocą funkcji kategorii friend . . . . . .364
36.5. Operatory new i delete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .370
36.6. Tworzenie dynamicznych tablic o zmiennej wielkości . . . . . . .371

bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
Skorowidz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376

Wstęp

Programowanie strukturalne i obiektowe. Podręcznik do nauki zawodu technik informatyk

przeznaczony jest dla techników o specjalności

[312][01]/T — Technik informatyk

oraz

dla szkół policealnych o specjalności

[312][01]/SP — Technik informatyk

. Zawiera tre-

ści wynikające z podstawy programowej kształcenia w zawodzie technik informatyk.
Został oparty na programie nauczania

312[01]/T, SP/MENiS/2004.06.14

Podręcznik ma za zadanie ułatwić nauczycielom:

sporządzenie rozkładu zajęć dla poszczególnych klas,

przygotowanie i przeprowadzenie prac kontrolnych, sprawdzianów, zadań reali-

zowanych w trakcie zajęć,
przygotowanie uczniów technikum i słuchaczy PSZ do egzaminu z przygotowa-

nia zawodowego zgodnie z wymaganiami OKE i CKE.

Uczniom podręcznik pozwoli na:

opanowanie,

utrwalenie,

usystematyzowanie,

wiadomości z zakresu metodologii programowania strukturalnego i obiektowego.
Przykłady praktyczne ułatwią pisanie i uruchamianie programów.
Podręcznik podzielono na części dotyczące programowania strukturalnego i progra-
mowania obiektowego.
Część I obejmuje programowanie strukturalne w środowisku tekstowym i graficznym
w języku Pascal. Opisano tu i przedstawiono na przykładach metodykę programowa-
nia strukturalnego, sposoby tworzenia aplikacji graficznych. Przykład z użyciem grafi-
ki dla Windows przy zastosowaniu Delphi umieszczono na nośniku elektronicznym
dołączonym do książki.
Część II obejmuje programowanie strukturalne w języku C, konwersję typów danych,
funkcje, wewnętrzną reprezentację danych w pamięci komputera.

Wstęp

Część III obejmuje programowanie obiektowe w C++ z uwzględnieniem konstrukto-
rów i destruktorów, dziedziczenia oraz dynamicznego tworzenia obiektów za pomocą
operatorów

new

delete

Oprócz ponad 100 praktycznych przykładów w językach Pascal, C i C++ podręcznik
zawiera ćwiczenia i zadania. Wiele dodatkowych zadań i przykładów umieszczono
w Dodatku na nośniku elektronicznym.

Oprócz klawiszy alfanumerycznych na klawiaturze peceta jest sporo klawiszy specjal-
nych. Najlepiej stosować klawisze specjalne zgodnie z ich typowym przeznaczeniem.

13.1.

O klawiszach specjalnych

Ogólnie rzecz biorąc, klawisze specjalne generują zamiast pojedynczego bajtu (jak kla-
wisz z literą) kody dwubajtowe. Zwyczajny klawisz, którego bajt może być zdeszyfro-
wany przy użyciu kodu ASCII, możemy wczytywać tak:

Var Klawisz : Char;

...

Klawisz := ReadKey;

— i porównywać go z zadaną wartością tak:

If (Klawisz = #27) Then ...

lub tak

If (Klawisz = 'A') Then ...

Aby program poprawnie reagował na klawisz (dowolny) naciśnięty przez użytkowni-
ka, możemy posłużyć się funkcją

KeyPressed()

. Ta funkcja tylko sprawdza, czy został

naciśnięty jakikolwiek klawisz (technicznie rzecz biorąc — czy w buforze klawiatu-
ry oczekuje znak), ale nie wczytuje tego znaku z bufora. Oczekujący znak pozostaje
„w kolejce” i najbliższa funkcja

ReadKey()

może go wczytać. Możemy zatem wywo-

ływać funkcję

ReadKey()

tylko wtedy, gdy użytkownik rzeczywiście coś nacisnął. Jeśli

nie, program może dalej robić swoje. Na listingu zaprezentowano program przykłado-
wy reagujący na klawisz z literą A.

Obsługa klawiszy

specjalnych

105

13.1. O klawiszach specjalnych

Listing L1301.PAS

Uses Crt;

Var Znak : Char;

BEGIN

Repeat

Begin

Write('.');

If KeyPressed Then Znak := ReadKey;

If (Znak = 'A') Then Break;

End;

Until (False);

END.

Program będzie drukował kropki, nie czekając na naciśnięcie klawisza, ale jeśli

zo-

stanie naciśnięte, natychmiast posłusznie zareaguje. W podobnie złożony sposób mu-
simy wczytywać kody klawiszy, jeśli chcemy poprawnie odróżnić klawisze zwykłe od
specjalnych i rozpoznać interesujące nas klawisze specjalne. Prosty program wykrywa-
jący takie klawisze może wyglądać na przykład tak jak na listingu L1302.PAS. Zanim
jednak zostanie przytoczony kompletny listing, omówimy pewną sztuczkę techniczną
użytą w tym przykładzie.

Repeat

Begin

Write('.');

If KeyPressed Then Znak := ReadKey;

If (Znak = 'A') Then Break;

End;

Until (False);

Jest to konstrukcja pętli nieskończonej, którą przerywa od wewnątrz instrukcja

Break

(przerwij). Ten fragment kodu jest równoważny zapisowi:

Repeat

Begin

Write('.');

If KeyPressed Then Znak := ReadKey;

End;

Until (Znak = 'A');

Zauważmy, że analogiczną, przerywaną od wewnątrz pętlę programową można skon-
struować, posługując się słowem kluczowym

While

(dopóki). Istotne różnice są jednak

ROZDZIAł 13

Obsługa klawiszy specjalnych

106

dwie. Po pierwsze, zamiast

False

mamy

True

, po drugie, warunek jest sprawdzany na

wejściu do pętli, a nie na wyjściu z niej.

While (True) Do

Begin

Write('.');

If KeyPressed Then Znak := ReadKey;

If (Znak = 'A') Then Break;

End;

Oprócz słowa

Break

, w wielu nowoczesnych językach programowania (nie tylko

w Pascalu, także w C, C++ czy Javie) istnieje jeszcze jedno słowo o podobnym prze-

znaczeniu, stanowiące swoiste uzupełnienie słowa

Break

. Chodzi mianowicie o słowo

Continue

(kontynuować), ale nie użyjemy go jeszcze w tym momencie.

Listing L1302.PAS

Uses Crt;

Var Znak : Char;

BEGIN

ClrScr;

WriteLn('Rozpoznaje klawisze specjalne...');

Repeat

Begin

If KeyPressed Then

Begin

Znak := ReadKey;

If (Znak = #0) Then WriteLn('Klawisz specjalny!');

End;

If (Znak = #27) Then Break;

End;

Until (False);

END.

Ten kod pozwala wykryć m.in. klawisze:

funkcyjne

–

F10

(tabela 13.1),

kursora (strzałki),

Insert

–

PageDown

Sprawdziliśmy, że pierwszy bajt jest

zerem

, został więc pominięty w tabelach 13.1

i 13.2. Ponieważ jednak klawisze sterujące mogą być naciskane łącznie z klawiszami
modyfikującymi (

Shift

Alt

Ctrl

), kodów jest sporo.

107

13.1. O klawiszach specjalnych

tabela 13.1.

Kody klawiszy funkcyjnych F1 – F10

Klawisz

Bez modyfikatora

+Shift

+Ctrl

+Alt

104

105

106

107

108

109

100

110

101

111

102

112

F10

103

113

tabela 13.2.

Kody klawiszy kursora (strzałek)

Klawisz

Bez modyfikatora

+Ctrl

W lewo

115

W prawo

116

W górę

160

W dół

164

Niektóre klawisze specjalne powiązane są z kodami sterującymi ASCII (zakres od 0
do 31) i w związku z tym nie generują kodu dwubajtowego, lecz jednobajtowy. Takie
znaki sterujące wraz z odpowiadającą im kombinacją (np.

Ctrl+C

Ctrl+Z

)

podano w tabeli 13.3.

tabela 13.3.

Jednobajtowe znaki sterujące

Oznaczenie

Kod

Działanie

^@ (NUL)

Puste miejsce

^C (Break)

Przerwij (ETX — koniec tekstu)

^G (Bell)

Beep

^H (BackSpace)

Cofnij kursor

^I (Horizontal Tab)

Tabulacja

^J (Line Feed)

O jeden wiersz w dół

^L (Form Feed)

O stronę w dół

ciąg dalszy na następnej stronie

ROZDZIAł 13

Obsługa klawiszy specjalnych

108

tabela 13.3.

Jednobajtowe znaki sterujące — ciąg dalszy

^M (CR)

Kursor na początek wiersza

^P (Del)

Usuń znak

^Z (EOF)

Koniec pliku tekstowego

^] (Esc)

Esc

Spacja

Odstęp

Ctrl+Enter

Jak ^J

Przechodzenie między kolejnymi oknami Turbo Pascala możesz realizować za pomo-
cą klawisza

Alt+

numer okna, na przykład

Alt+1

Alt+2

(tabela 13.4). Dzieje się tak,

ponieważ klawisze cyfr także w połączeniu z klawiszem

Alt

generują specjalne kody

dwubajtowe. Ostatnia, dodatkowa kombinacja zamieszczona w tej tabeli (

Shift+Tab

)

jest często stosowana do przechodzenia między elementami sterującymi okienek dia-
logowych (zob. także rysunek 22.3).

tabela 13.4.

Kody dwubajtowe tworzone z wykorzystaniem klawisza Alt

Klawisze

Kod

Klawisze

Kod

Alt+1

0 120

Alt+7

0 126

Alt+2

0 121

Alt+8

0 127

Alt+3

0 122

Alt+9

0 128

Alt+4

0 123

Alt+0

0 129

Alt+5

0 124

Alt+-

0 130

Alt+6

0 125

Shift+Tab

0 15

W tabeli 13.5 zebrane zostały niektóre specjalne klawisze sterujące i ich kody.

tabela 13.5.

Kody specjalnych klawiszy sterujących

Klawisz

Bez modyfikatora

+Shift

+Ctrl

Home

0 71

End

0 79

0 117

PageUp

0 73

0 132

PageDown

0 81

0 118

Insert

0 82

0 165

Del

0 83

0 166

Enter

13, 10

Działanie innych kombinacji można sprawdzić za pomocą programu testującego.

109

13.1. O klawiszach specjalnych

Listing L1303.PAS

Uses Crt;

Var Znak : Char;

BEGIN

ClrScr;

WriteLn('Wprowadz klawisz lub kombinacje klawiszy: ');

Repeat

Znak := ReadKey;

If ( Ord(Znak) In [1..31] ) Then WriteLn('Znak sterujacy 1..31.');

If ( Ord(Znak) In [32..127] ) Then Write(#13+#10+'Zwykly znak: ');

If ( Ord(Znak) In [128..170] ) Then WriteLn('Rozszerzony kod ASCII');

If ( Ord(Znak) In [171..255] ) Then WriteLn('Znak semigraficzny');

If ( Ord(Znak) In [32..255] ) Then Write(Znak);

If (Znak = #0) Then

Begin

Znak := ReadKey;

If ( Ord(Znak) In [59..68] ) Then WriteLn('Klawisz F', Ord(Znak) - 58)

Else

Write(#13+#10+'Inny klawisz specjalny...');

End;

Until (Znak = #27);

END.

Wyjaśnijmy konstrukcję wyrażenia warunkowego:

If ( Ord(Znak) In [1..31] ) Then WriteLn('Znak sterujacy 1..31.');

Funkcja

Ord(Znak)

, której nazwa pochodzi od

ORDering number

(numer kolejny /

porządkowy), zwraca numer w kodzie ASCII wczytanego znaku przechowywanego
w zmiennej

Znak

. Ten numer jest następnie porównywany z zadanym zakresem:

... In [1..31]

Jeśli liczba należy do przedziału 1 – 31, następuje wykonanie tego, co znajduje się po

Then

(tu: wydrukowanie stosownego komunikatu).

Oto druga, nieco bardziej skomplikowana konstrukcja:

... Then WriteLn('Klawisz F', Ord(Znak) - 58)

Jest to wywołanie procedury wyprowadzającej na ekran z dwoma parametrami. Pierw-
szy parametr — łańcuch znaków — jest oczywisty:

WriteLn( 'Klawisz F', ..... );

Drugi stanowi wyrażenie, którego wartość program musi obliczyć, a następnie wypro-
wadzić wynik na ekran:

WriteLn('.............', Ord(Znak)

58 );

ROZDZIAł 13

Obsługa klawiszy specjalnych

110

Skoro klawisze funkcyjne mają kody, na przykład

—

0 59

—

0 60

, to po

odjęciu od kodu liczby 58 uzyskamy dodatkową informację — numer klawisza funk-
cyjnego:

59 - 58 = 1

-->

60 - 58 = 2

-->

, itd.

I ostatnia sztuczka techniczna zastosowana w programie. Parametry przekazywane
przy wywołaniu funkcji lub procedury mogą być wyrażeniami. Jeśli takie wyrażenie
jest wyrażeniem arytmetycznym typu

Write( 2+3 )

, wszystko jest oczywiste. Wyniki

takich wyrażeń obliczane są najpierw, a następnie to te właśnie wyniki przekazywane
są jako parametry procedurze. W naszym przypadku wyrażenie ma postać:

Write(#13+#10+'Zwykly znak: ');

Oznacza ono dodawanie łańcuchów znakowych. Zapis

#13+#10+'Zwykly znak: '

oznacza: „Do napisu ‘Zwykły znak: ’ dodaj na początku kod specjalny 13, 10, czyli
przed wyprowadzeniem napisu przenieś kursor na początek nowego wiersza”.
Posługując się programem tego typu, możemy wykrywać naciśnięcie dowolnej kombi-
nacji klawiszy, jeśli tylko ma ona własny unikalny kod.

13.2.

Instrukcje While i Case

Rozważanie kolejnych możliwych wariantów można przeprowadzić za pomocą tzw.
drabinki, posługując się konstrukcjami warunkowymi typu:

If ( warunek1 ) Then ... Else If ( warunek2 ) Then ... Else ...

Jednak często znacznie wygodniejsze bywa zastosowanie słowa kluczowego

Case

(wariant). Sposób zastosowania tej instrukcji przedstawiony został na prostym przy-
kładzie.

Listing L1304.PAS

Uses Crt;

Var Znak : Char;

BEGIN

ClrScr;

While (Znak <> #27) Do

Begin

Znak := ReadKey;

Case Znak Of

'A'..'Z', 'a'..'z': WriteLn('Litera');

'0'..'9': WriteLn('Cyfra');

'+', '-', '*', '/': WriteLn('Operator');

111

13.2. Instrukcje While i Case

Else WriteLn('Znak Specjalny');

End;

END.

Zwróćmy uwagę, że konstrukcja:

Case ZMIENNA Of

wariant1: instrukcje;

wariant2: instrukcje;

....

Else

instrukcje;

End;

— musi być zakończona własnym słowem

End

. Instrukcja pętli

While

sprawdza wa-

runek na początku (na wejściu) i wykonuje pętlę programową, dopóki warunek jest
spełniony.

While (warunek) Do

Begin

....

End;

A oto poprzedni przykład zmodyfikowany za pomocą konstrukcji

Case

Listing L1305.PAS

Uses Crt;

Var Znak : Char;

BEGIN

ClrScr;

Write(Ord(Znak));

ReadKey;

ClrScr;

WriteLn('Wprowadz klawisz lub kombinacje klawiszy: ');

While (Znak <> #27) Do

Begin

Znak := ReadKey;

Case (Ord(Znak)) Of

1..31: WriteLn('Znak sterujacy 1..31.');

32..127: Write(#13+#10+'Zwykly znak.');

ROZDZIAł 13

Obsługa klawiszy specjalnych

112

128..170: WriteLn('Rozszerzony kod ASCII');

171..255: WriteLn('Znak semigraficzny');

{ 32..255: Write(Znak); <-- Dublowanie! }

End;

If (Znak = #0) Then

Begin

Znak := ReadKey;

Case (Ord(Znak)) Of

59..68: WriteLn('Klawisz F', Ord(Znak) - 58)

Else

Write(#13+#10+'Inny klawisz specjalny...');

End;

END.

Dodana na początku sekwencja:

ClrScr;

Write(Ord(Znak));

ReadKey;

— ma na celu pokazanie, że już w chwili, gdy warunek wykonania pętli jest sprawdzany:

While (Znak <> #27) Do

Begin

Znak := ReadKey;

— zmienna

Znak

ma nadaną automatycznie przez kompilator Pascala wartość począt-

kową = 0. Gdyby tak nie było (nie wszystkie kompilatory wstępnie zerują zmienne),
zmienna

Znak

mogłaby mieć nieokreśloną przypadkową wartość. Jest to efekt o tyle

niebezpieczny, że praktyka niezainicjowania zmiennej przed jej użyciem może spowo-
dować wadliwą pracę programu. Prawidłowa praktyka powinna wyglądać tak:

Znak := #0;

While (Znak <> #27) Do

Begin

Znak := ReadKey;

...

Drugi efekt uboczny, na jaki należy tu zwrócić uwagę, to zagadnienie nakładania
się lub wyłączności zakresów wartości. Jest to cecha zależna od wersji kompilatora.

113

13.2. Instrukcje While i Case

W Turbo Pascalu 7 i w Delphi przedziały wartości rozpatrywane wewnątrz instrukcji

Case

nie mogą się nakładać:

32..127: Write(#13+#10+'Zwykly znak.');

128..170: WriteLn('Rozszerzony kod ASCII');

171..255: WriteLn('Znak semigraficzny');

{ 32..255: Write(Znak); <-- Dublowanie! }

Dlatego właśnie ta część programu musiała zostać ujęta w nawiasy i stać się komen-
tarzem.
Klawisze kursora można w wygodny sposób zastosować także do zmiany prędkości
animacji grafiki. Oto fragment kodu, w którym strzałki przyspieszają lub spowalniają
przełączanie stron.

Zwloka := 100;

If (KeyPressed) Then

Begin

Ch := ReadKey;

If (Ch = #0) Then

Ch := ReadKey;

Case (Ord(Ch)) Of

75 : Inc (Zwloka);

77 : Dec (Zwloka);

End;

...

SetVisualPage(P1);

Delay(Zwloka);

SetVisualPage(P2);

Delay(Zwloka);

...

Narysuj schematy blokowe programów przykładowych.

Skonstruuj program, który sprawdzi, czy klawiatura numeryczna generuje

kody inne niż zwyczajne klawisze cyfr.
Porównaj schematy blokowe instrukcji pętli

For

While

Repeat-Until

Czy każdą instrukcję pętli typu

For

można zastąpić konstrukcją

While

lub

Repeat-Until

ĆWICZENIA