C++ i Qt. Wprowadzenie do wzorców projektowych. Wydanie II - ebook

Najlepsze wzorce dla C++ i Qt!

Język C++ przez długie lata był liderem wśród języków programowania i wciąż jest rozwijany. Qt to zestaw bibliotek pozwalający na tworzenie atrakcyjnego interfejsu użytkownika, działającego w różnych systemach operacyjnych - Windows, Mac OS X oraz Linux. Projekt jest intensywnie rozwijany od 1992 roku, a najnowsza wersja daje nawet możliwość tworzenia aplikacji internetowych czy mobilnych. Wykorzystanie możliwości C++ oraz potencjału Qt może dać niezwykłe efekty!

W trakcie lektury nauczysz się podstaw języka C++ i zgłębisz tajniki bibliotek Qt. Zdobędziesz interesujące informacje na temat wykorzystania kontenerów, metaobiektów, metawłaściwości i mechanizmu refleksji. Dowiesz się, jak wykorzystać wzorzec MVC (ang. Model-View-Controller) oraz w jaki sposób opanować problemy związane z programowaniem współbieżnym. Ponadto nauczysz się panować nad wskaźnikami i unikać typowych problemów związanych z dostępem do pamięci. Książka ta jest doskonałą pozycją dla wszystkich programistów C++, którzy chcą wzbogacić swój warsztat o bibliotekę Qt.

Dzięki tej książce:
- poznasz podstawy C++ oraz Qt
- opanujesz programowanie współbieżne
- zrozumiesz wzorzec MVC
- zbudujesz interesującą aplikację przy użyciu C++ i Qt

Wykorzystaj moc duetu: C++ i Qt!

Słowo wstępne (13)

Przedmowa (17)

Przedmowa do wydania drugiego (19)

Podziękowania (21)

O autorach (25)

CZĘŚĆ I. WZORCE PROJEKTOWE I QT (27)

Rozdział 1. Wprowadzenie do C++ (29)

• 1.1. Przegląd języka C++ (29)
• 1.2. Krótka historia C++ (30)
• 1.3. Pierwszy przykład (30)
• 1.4. Standardowe wejście i wyjście (33)
• 1.5. Wprowadzenie do funkcji (36)
• 1.6. qmake, pliki projektu i Makefile (41)
• 1.7. Pomocne zasoby w internecie (46)
• 1.8. Łańcuchy znaków (47)
• 1.9. Strumienie (48)
• 1.10. Strumienie do plików (50)
• 1.11. Okienka dialogowe Qt (54)
• 1.12. Identyfikatory, typy i literały (57)
• 1.13. Typy proste (59)
• 1.14. Słowo kluczowe const (69)
• 1.15. Wskaźniki i dostęp do pamięci (70)
• 1.16. Referencje (75)
• 1.17. Różnica pomiędzy const* a *const (76)
• 1.18. Powtórka (79)

Rozdział 2. Pierwsza klasa (81)

• 2.1. Na początku było struct (81)
• 2.2. Definicje klas (82)
• 2.3. Modyfikatory dostępu do składowych (85)
• 2.4. Enkapsulacja (87)
• 2.5. Wprowadzenie do UML (87)
• 2.6. Przyjaciele klasy (89)
• 2.7. Konstruktory (90)
• 2.8. Destruktory (92)
• 2.9. Słowo kluczowe static (93)
• 2.10. Deklaracje i definicje klas (97)
• 2.11. Konstruktory kopiujące i operatory przypisania (99)
• 2.12. Konwersje (101)
• 2.13. Funkcje składowe const (104)
• 2.14. Podobiekty (105)
• 2.15. Ćwiczenia: klasy (107)
• 2.16. Pytania sprawdzające znajomość rozdziału (114)

Rozdział 3. Wprowadzenie do Qt (119)

• 3.1. Styl i konwencje nazewnicze (119)
• 3.2. Moduł Qt Core (121)
• 3.3. Qt Creator: zintegrowane środowisko programistyczne dla Qt (124)
• 3.4. Ćwiczenia: wprowadzenie do Qt (125)
• 3.5. Powtórka (126)

Rozdział 4. Listy (127)

• 4.1. Wprowadzenie do kontenerów (127)
• 4.2. Iteratory (128)
• 4.3. Relacje (133)
• 4.4. Ćwiczenia: relacje (135)
• 4.5. Powtórka (137)

Rozdział 5. Funkcje (139)

• 5.1. Przeładowywanie funkcji (139)
• 5.2. Argumenty opcjonalne (142)
• 5.3. Przeładowywanie operatorów (144)
• 5.4. Przekazywanie parametrów przez wartość (148)
• 5.5. Przekazywanie parametrów przez referencję (149)
• 5.6. Referencje do const (152)
• 5.7. Wartości zwracane przez funkcje (154)
• 5.8. Zwracanie referencji przez funkcje (154)
• 5.9. Przeładowywanie w oparciu o const (155)
• 5.10. Funkcje inline (157)
• 5.11. Funkcje z listą argumentów o zmiennej długości (161)
• 5.12. Ćwiczenia: szyfrowanie (162)
• 5.13. Powtórka (164)

Rozdział 6. Dziedziczenie i polimorfizm (165)

• 6.1. Proste dziedziczenie (165)
• 6.2. Dziedziczenie i polimorfizm (172)
• 6.3. Dziedziczenie z abstrakcyjnej klasy bazowej (177)
• 6.4. Projektowanie dziedziczenia (182)
• 6.5. Przeładowywanie, ukrywanie i przesłanianie (184)
• 6.6. Konstruktory, destruktory i kopiujące operatory przypisania (186)
• 6.7. Przetwarzanie argumentów z wiersza poleceń (190)
• 6.8. Kontenery (195)
• 6.9. Kontenery zarządzające, kompozycja i agregacja (197)
• 6.10. Kontenery wskaźników (200)
• 6.11. Powtórka (215)

Rozdział 7. Biblioteki i wzorce projektowe (221)

• 7.1. Budowanie i używanie bibliotek (222)
• 7.2. Ćwiczenie: instalowanie bibliotek (229)
• 7.3. Frameworki i komponenty (231)
• 7.4. Wzorce projektowe (233)
• 7.5. Powtórka (240)

Rozdział 8. Klasy QObject i QApplication, sygnały i sloty (243)

• 8.1. Wartości i obiekty (246)
• 8.2. Rodzice i dzieci: wzorzec Kompozyt (247)
• 8.3. Pętla zdarzeń w QApplication (253)
• 8.4. QObject i moc w pigułce (255)
• 8.5. Sygnały i sloty (255)
• 8.6. Cykl życia QObject (257)
• 8.7. QTestLib (258)
• 8.8. Ćwiczenia: QObject, QApplication, sygnały i sloty (261)
• 8.9. Powtórka (261)

Rozdział 9. Widżety i projektowanie interfejsów (263)

• 9.1. Kategorie widżetów (264)
• 9.2. Designer: wprowadzenie (266)
• 9.3. Okna dialogowe (269)
• 9.4. Układ formularza (271)
• 9.5. Ikonki, obrazki i zasoby (273)
• 9.6. Układ widżetów (276)
• 9.7. Integracja okienek z kodem (283)
• 9.8. Ćwiczenia: formularze wejściowe (288)
• 9.9. O pętli zdarzeń raz jeszcze (289)
• 9.10. Zdarzenia rysowania (297)
• 9.11. Powtórka (299)

Rozdział 10. Główne okna i akcje (301)

• 10.1. QAction, QMenu, QMenuBar (302)
• 10.2. Obszary i dokowanie (309)
• 10.3. QSettings: konfiguracja aplikacji (311)
• 10.4. Schowek i transfer danych (314)
• 10.5. Wzorzec Polecenie (315)
• 10.6. Umiędzynarodawianie i funkcja tr() (322)
• 10.7. Ćwiczenia: Główne okna i akcje (323)
• 10.8. Powtórka (323)

Rozdział 11. Uogólnienia i kontenery (325)

• 11.1. Typy uogólnione i szablony (325)
• 11.2. Typy uogólnione, algorytmy i operatory (331)
• 11.3. Przykład sortowania mapy (333)
• 11.4. Funktory i wskaźniki na funkcje (336)
• 11.5. Wzorzec Pyłek: klasy współdzielone przez domniemanie (338)
• 11.6. Ćwiczenia: typy uogólnione (342)
• 11.7. Powtórka (343)

Rozdział 12. Metaobiekty, metawłaściwości i mechanizm refleksji (345)

• 12.1. Wzorzec Metaobiekt i klasa QMetaObject (345)
• 12.2. Identyfikacja typu i qobject_cast (347)
• 12.3. Macro Q_PROPERTY: opis właściwości QObject (349)
• 12.4. Klasa QVariant: dostęp do właściwości (352)
• 12.5. Dynamiczne właściwości (355)
• 12.6. Deklarowanie i rejestrowanie metatypów (358)
• 12.7. Funkcja invokeMethod() (360)
• 12.8. Ćwiczenia: refleksja (361)
• 12.9. Powtórka (361)

Rozdział 13. Modele i widoki (363)

• 13.1. Model-View-Controller (MVC) (364)
• 13.2. Modele i widoki Qt (365)
• 13.3. Modele tabel (375)
• 13.4. Modele drzewiaste (384)
• 13.5. Inteligentne wskaźniki (387)
• 13.6. Ćwiczenia: modele i widoki (390)
• 13.7. Powtórka (391)

Rozdział 14. Walidacja i wyrażenia regularne (393)

• 14.1. Maski wprowadzania danych (393)
• 14.2. Walidatory (396)
• 14.3. Wyrażenia regularne (398)
• 14.4. Walidacja wyrażeń regularnych (406)
• 14.5. Podklasy QValidator (407)
• 14.6. Ćwiczenia: walidacja i wyrażenia regularne (410)
• 14.7. Powtórka (411)

Rozdział 15. Parsowanie XML (413)

• 15.1. Parsery XML w Qt (415)
• 15.2. Parsowanie SAX (417)
• 15.3. XML, struktury drzewiaste i DOM (421)
• 15.4. Strumienie XML (429)
• 15.5. Powtórka (431)

Rozdział 16. Więcej wzorców projektowych (433)

• 16.1. Wzorce konstrukcyjne (433)
• 16.2. Wzorzec Pamiątka (442)
• 16.3. Wzorzec Fasada (447)
• 16.4. Powtórka (453)

Rozdział 17. Współbieżność (455)

• 17.1. QProcess i zarządzanie procesami (455)
• 17.2. QThread i QtConcurrent (468)
• 17.3. Ćwiczenia: QThread i QtConcurrent (480)
• 17.4. Powtórka (481)

Rozdział 18. Programowanie baz danych (483)

• 18.1. Dostęp do bazy danych z Qt: QSqlDatabase (485)
• 18.2. Zapytania i zestawy wyników (488)
• 18.3. Modele baz danych (490)
• 18.4. Powtórka (491)

CZĘŚĆ II. PODSTAWY JĘZYKA C++ (493)

Rozdział 19. Typy i wyrażenia (495)

• 19.1. Operatory (495)
• 19.2. Instrukcje i struktury kontroli (500)
• 19.3. Ewaluacja wyrażeń logicznych (506)
• 19.4. Typy wyliczeniowe (507)
• 19.5. Typy całkowite ze znakiem i bez znaku (509)
• 19.6. Standardowa konwersja wyrażeń (511)
• 19.7. Konwersje jawne (514)
• 19.8. Rzutuj bezpiecznie, używając rzutowania ANSI C++ (515)
• 19.9. Przeciążanie operatorów specjalnych (520)
• 19.10. Identyfikacja typów w czasie wykonania programu (525)
• 19.11. Operatory wyboru składowych (527)
• 19.12. Ćwiczenia: typy i wyrażenia (529)
• 19.13. Powtórka (530)

Rozdział 20. Zakres identyfikatorów i klasa pamięci (531)

• 20.1. Deklaracje i definicje (531)
• 20.2. Zakres identyfikatorów (532)
• 20.3. Klasa pamięci (540)
• 20.4. Przestrzenie nazw (544)
• 20.5. Powtórka (548)

Rozdział 21. Dostęp do pamięci (549)

• 21.1. Patologia wskaźników (550)
• 21.2. Patologia wskaźników na stercie (552)
• 21.3. Dostęp do pamięci: podsumowanie (554)
• 21.4. Wprowadzenie do tablic (555)
• 21.5. Arytmetyka wskaźników (556)
• 21.6. Tablice, funkcje i wartości zwracane (557)
• 21.7. Różne rodzaje tablic (559)
• 21.8. Dozwolone operacje na wskaźnikach (559)
• 21.9. Tablice i pamięć: ważne informacje (561)
• 21.10. Ćwiczenia: dostęp do pamięci (562)
• 21.11. Powtórka (563)

Rozdział 22. Szczegółowo o dziedziczeniu (565)

• 22.1. Wskaźniki wirtualne i tablice wirtualne (565)
• 22.2. Polimorfizm i destruktory wirtualne (568)
• 22.3. Wielokrotne dziedziczenie (571)
• 22.4. Dziedziczenie publiczne, chronione i prywatne (577)
• 22.5. Powtórka (579)

CZĘŚĆ III. ZADANIA PROGRAMISTYCZNE (581)

Rozdział 23. Ćwiczenia: szafa grająca (583)

• 23.1. Lista odtwarzania (584)
• 23.2. Listy odtwarzania (585)
• 23.3. Wybór źródła (586)
• 23.4. Listy odtwarzania w bazie danych (587)
• 23.5. Rozszerzenie przykładu Star Delegates (587)
• 23.6. Sortowanie, filtrowanie i edycja list odtwarzania (588)

Dodatek A. Słowa kluczowe języka C++ (589)

Dodatek B. Standardowe nagłówki (591)

Dodatek C. Narzędzia pracy programisty (593)

Dodatek D. Przewodnik Alana: Debian w pigułce dla programistów (615)

Dodatek E. Konfiguracja C++/Qt (621)

Bibliografia (629)

Skorowidz (631)