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

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:

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.

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

• 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)

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

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

• 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)

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

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

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

• 9.1. Czcionki w trybie graficznym (77)
• 9.2. Inkrementacja i dekrementacja, specyfika If-Then-Else w Pascalu (80)

• 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)

• 11.1. Tabela kodów ASCII (92)

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

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

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

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

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

• 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)

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

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

• 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)

• 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)

• 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)

• 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)

• 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)

• 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)

• 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)

• 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)

• 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)

• 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)

• 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)

• 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)

• 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)

• 34.1. Konstruktor i jego argumenty (338)
• 34.2. Destruktor i jego zastosowanie - stos (343)

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

• 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)