Katalog książek

Wydawnictwo Helion

Helion SA
ul. Kościuszki 1c
44-100 Gliwice
tel. (32) 230-98-63




© Helion 1991-2016

Lauret zaufanych opinii
C++ i Qt. Wprowadzenie do wzorcó...

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

Autorzy: ,

Ocena:
   4/6  Opinie  (5)
Stron: 640 Stron (w wersji papierowej): 640
Ksiazka drukowana Druk (oprawa: miękka) 3w1 w pakiecie: PdfPDF ePubePub MobiMobi
Wydawca: Helion
Cena:
89,00 zł
Dodaj do koszyka
Kup terazstrzalka

Druk
Książka drukowana
niedostępna
eBook
Pdf ePub Mobi
89,00 zł

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)

Najczęściej kupowane razem ebooki:
C++ i Qt. Wprowadzenie do wzorców projektowych. Wydanie II plus Aplikacje internetowe z Django. Najlepsze receptury plus Java. Kompendium programisty. Wydanie IX
Cena zestawu: 235,45 zł 277,00 zł
Oszczędzasz: 41,55 zł (15%)
Dodaj do koszyka
zestaw0 C++ i Qt. Wprowadzenie do wzorców projektowych. Wydanie II
Osoby, które kupowały książkę, często kupowały też:
Cena: 43,90 zł
Cena: 39,00 zł
Cena: 47,00 zł
6
(0)
5
(1)
4
(2)
3
(2)
2
(0)
1
(0)

Liczba ocen: 5

Średnia ocena
czytelników

  


okladka
  Ocena : 5 

Niewiele jest książek o QT - perełka.
  Ocena : 4 

Porządna książka omawiająca i podstawy i kwestie bardziej zaawansowane w programowaniu C++ z Qt. Wymagana jest od czytelnika praktyka i znajomość zagadnień podstawowych i średnio zaawansowanych w C++. Listingi w książce pokazują wyłącznie omawiane zagadnienia, więc resztę programu trzeba sobie wyobrazić, co dla programisty z pewną praktyką nie jest wielkim problemem. Książka pod każdym większym omawianym zagadnieniem zawiera ćwiczenia poszerzające zakres opisywanego materiału.
  Ocena : 4 

Książka dobra. Jedyna uwaga to brak osiągania celu edukowania od podstaw C++. Jest to raczej książka dla osób programujących już w C++. Jeśli przyjąć takie założenie, początkowe rozdziały (które nie kształcą umiejętności programowania w C++), są niepotrzebne. Niemniej jednak w połączeniu z bogatą dokumentacją Qt, umożliwia rozpoczęcie programowania z użyciem tego frameworka.
  Ocena : 3 

Już po przeczytaniu spisu treści i fragmentu książki wiem, że jej nie kupię, najbardziej podoba mi się: "Patologia wskaźników na stercie". Książka może i dobra ale tłumaczenie wszytko psuje. Niestety wiele dobrych książek z waszego wydawnictwa tłumaczą osoby nie znające się na dziedzinie, z której tekst tłumaczą.
  Ocena : 3 

Przykłady pobrane z ftp źle przygotowane (nie dają się poprawnie skompilować należy je poprawiać). Przykłady w książce są niedbale opisane. Osoby, które znają dobrze C++ będą także miały problem z przyswojeniem wiedzy zawartej w książce.