okladka

Zbiór rozwiązań dla programistów C++

  • Operacje na klasach i obiektach
  • Obsługa błędów i wyjątków
  • Przetwarzanie dokumentów XML

C++ jest jednym z najpopularniejszych języków programowania. Jego implementacje dostępne są praktycznie dla wszystkich platform systemowych. Programiści posługujący się językiem C++ napisali setki tysięcy aplikacji. Codziennie jednak stają przed koniecznością rozwiązywania podobnych problemów, związanych na przykład z przetwarzaniem dat, manipulowaniem ciągami tekstowymi czy stosowaniem standardowych kontenerów. W takich sytuacjach na pewno zadają sobie pytanie -- czy warto ponownie wymyślać koło? Przecież gotowe rozwiązania znacznie przyspieszyłyby pracę.

Książka "C++. Receptury" może pełnić funkcję skarbnicy porad dla programistów. Znajdziesz w niej rozwiązania problemów, z jakimi spotykasz się w codziennej pracy. Każda analiza uzupełniona jest przykładowym kodem źródłowym, który można wykorzystać we własnych projektach. Autorzy położyli szczególny nacisk na prostotę i przenośność kodu oraz wykorzystanie, tam gdzie to możliwe, biblioteki standardowej.

  • Kompilowanie aplikacji
  • Właściwa organizacja kodu źródłowego
  • Operacje na liczbach, tekstach i datach
  • Stosowanie kontenerów
  • Programowanie obiektowe
  • Przetwarzanie plików
  • Strumienie
  • Operacje matematyczne i statystyczne
  • Wielowątkowość i biblioteka Boost
  • Praca z dokumentami XML

Przyspiesz pracę nad aplikacją,
stosując gotowe i sprawdzone rozwiązania.


Wstęp (9)
1. Tworzenie aplikacji w języku C++ (15)
  • 1.0. Wprowadzenie do systemów kompilacji (15)
  • 1.1. Pobieranie i instalowanie GCC (28)
  • 1.2. Kompilowanie programu "Hello, World!" w wierszu poleceń (31)
  • 1.3. Kompilowanie biblioteki statycznej w wierszu poleceń (36)
  • 1.4. Kompilowanie biblioteki dynamicznej w wierszu poleceń (38)
  • 1.5. Kompilowanie aplikacji wieloskładnikowej w wierszu poleceń (45)
  • 1.6. Instalowanie pakietu Boost.Build (50)
  • 1.7. Kompilowanie programu "Hello, World!" za pomocą Boost.Build (52)
  • 1.8. Kompilowanie biblioteki statycznej za pomocą Boost.Build (56)
  • 1.9. Kompilowanie biblioteki dynamicznej za pomocą Boost.Build (57)
  • 1.10. Kompilowanie aplikacji wieloskładnikowej za pomocą Boost.Build (58)
  • 1.11. Kompilowanie biblioteki statycznej w IDE (61)
  • 1.12. Kompilowanie biblioteki dynamicznej w IDE (64)
  • 1.13. Kompilowanie aplikacji wieloskładnikowej w IDE (68)
  • 1.14. Pobieranie i instalowanie GNU make (73)
  • 1.15. Kompilowanie programu "Hello, World!" za pomocą GNU make (75)
  • 1.16. Kompilowanie biblioteki statycznej za pomocą GNU make (82)
  • 1.17. Kompilowanie biblioteki dynamicznej za pomocą GNU make (87)
  • 1.18. Kompilowanie aplikacji wieloskładnikowej za pomocą GNU make (88)
  • 1.19. Definiowanie symboli (makrodefinicji) (92)
  • 1.20. Ustalanie opcji wiersza polecenia w IDE (94)
  • 1.21. Kompilacja próbna (95)
  • 1.22. Kompilacja ostateczna (98)
  • 1.23. Wybieranie wersji biblioteki wykonawczej (101)
  • 1.24. Wymuszanie zgodności ze standardem języka C++ (104)
  • 1.25. Automatyzacja konsolidacji pliku źródłowego z wybraną biblioteką (107)
  • 1.26. Korzystanie z szablonów eksportowanych (109)
2. Organizacja kodu (113)
  • 2.0. Wprowadzenie (113)
  • 2.1. Gwarantowanie jednokrotnego włączenia pliku nagłówkowego (114)
  • 2.2. Gwarantowanie obecności jednego egzemplarza zmiennej dla wielu plików źródłowych (116)
  • 2.3. Ograniczanie włączania nagłówków za pomocą deklaracji zapowiadających (117)
  • 2.4. Unikanie kolizji nazw za pomocą przestrzeni nazw (119)
  • 2.5. Włączanie pliku funkcji inline (125)
3. Liczby (127)
  • 3.0. Wprowadzenie (127)
  • 3.1. Konwersja ciągu na typ liczbowy (127)
  • 3.2. Konwersja liczb na ciągi (130)
  • 3.3. Sprawdzanie, czy ciąg zawiera poprawną liczbę (133)
  • 3.4. Porównywanie wartości zmiennoprzecinkowych w zadanym zakresie dokładności (135)
  • 3.5. Przetwarzanie ciągu zawierającego liczbę w zapisie naukowym (137)
  • 3.6. Konwersja pomiędzy typami liczbowymi (139)
  • 3.7. Określanie granicznych wartości typów liczbowych (141)
4. Ciągi i teksty (145)
  • 4.0. Wprowadzenie (145)
  • 4.1. Dopełnianie ciągu (146)
  • 4.2. Przycinanie ciągu (147)
  • 4.3. Zapisywanie ciągów w sekwencji (152)
  • 4.4. Określanie długości ciągu (155)
  • 4.5. Odwracanie ciągu (157)
  • 4.6. Podział ciągu (158)
  • 4.7. Wyodrębnianie elementów leksykalnych (160)
  • 4.8. Scalanie sekwencji ciągów (163)
  • 4.9. Wyszukiwanie w ciągach (165)
  • 4.10. Szukanie n-tego wystąpienia podciągu (168)
  • 4.11. Usuwanie podciągu z ciągu (169)
  • 4.12. Zmiana wielkości liter w ciągu (171)
  • 4.13. Porównywanie ciągów bez uwzględniania wielkości liter (173)
  • 4.14. Wyszukiwanie w ciągu bez uwzględniania wielkości liter (175)
  • 4.15. Zamiana tabulacji na spacje w pliku tekstowym (177)
  • 4.16. Zawijanie wierszy w pliku tekstowym (179)
  • 4.17. Zliczanie znaków, słów i wierszy w pliku tekstowym (181)
  • 4.18. Zliczanie wystąpień poszczególnych słów w pliku tekstowym (184)
  • 4.19. Ustawianie marginesów w pliku tekstowym (186)
  • 4.20. Justowanie tekstu w pliku (189)
  • 4.21. Eliminowanie nadmiarowych znaków odstępu w pliku tekstowym (191)
  • 4.22. Autokorekta tekstu przy zmianach bufora (192)
  • 4.23. Wczytywanie danych z pliku wartości rozdzielanych przecinkami (195)
  • 4.24. Podział ciągu na podstawie wyrażeń regularnych (197)
5. Daty i godziny (199)
  • 5.0. Wprowadzenie (199)
  • 5.1. Odczytywanie bieżącej daty i godziny (199)
  • 5.2. Formatowanie ciągów reprezentujących daty i godziny (202)
  • 5.3. Arytmetyka dat i godzin (204)
  • 5.4. Konwersja pomiędzy strefami czasowymi (206)
  • 5.5. Określanie numeru dnia w roku (207)
  • 5.6. Definiowanie typów wartości ograniczonych do zakresu (209)
6. Gospodarowanie danymi - kontenery (213)
  • 6.0. Wprowadzenie (213)
  • 6.1. Kontenery zamiast tablic (214)
  • 6.2. Efektywne stosowanie wektorów (218)
  • 6.3. Kopiowanie wektora (222)
  • 6.4. Przechowywanie wskaźników w wektorze (224)
  • 6.5. Przechowywanie obiektów na liście (225)
  • 6.6. Kojarzenie danych z ciągami znaków (230)
  • 6.7. Kontenery haszowane (235)
  • 6.8. Sekwencje uporządkowane (240)
  • 6.9. Kontenery w kontenerach (243)
7. Algorytmy (247)
  • 7.0. Wprowadzenie (247)
  • 7.1. Przeglądanie zawartości kontenera (248)
  • 7.2. Usuwanie obiektów z kontenera (254)
  • 7.3. Tworzenie sekwencji pseudolosowych (257)
  • 7.4. Porównywanie zakresów (259)
  • 7.5. Scalanie danych (262)
  • 7.6. Sortowanie zakresu elementów (266)
  • 7.7. Partycjonowanie zakresu (268)
  • 7.8. Przetwarzanie sekwencji za pomocą operacji dla zbiorów (270)
  • 7.9. Przekształcanie elementów sekwencji (273)
  • 7.10. Własne algorytmy uogólnione (275)
  • 7.11. Wypisywanie elementów zakresu do strumienia (278)
8. Klasy (283)
  • 8.0. Wprowadzenie (283)
  • 8.1. Inicjalizowanie składowych klas (284)
  • 8.2. Tworzenie obiektów w funkcjach (wzorzec Factory) (287)
  • 8.3. Konstruktory i destruktory w służbie zarządzania zasobami (RAII) (289)
  • 8.4. Automatyczne dodawanie nowych egzemplarzy klasy do kontenera (291)
  • 8.5. Jedna kopia składowej klasy (293)
  • 8.6. Określanie dynamicznego typu obiektu (295)
  • 8.7. Wykrywanie zależności pomiędzy klasami różnych obiektów (297)
  • 8.8. Nadawanie identyfikatorów egzemplarzom klas (298)
  • 8.9. Tworzenie klasy-jedynaka (301)
  • 8.10. Tworzenie interfejsu z abstrakcyjną klasą bazową (303)
  • 8.11. Pisanie szablonu klasy (307)
  • 8.12. Pisanie szablonu funkcji (312)
  • 8.13. Przeciążanie operatorów inkrementacji i dekrementacji (314)
  • 8.14. Przeciążanie operatorów arytmetycznych i operatorów przypisania pod kątem intuicyjności zachowania obiektów klasy (317)
  • 8.15. Wywoływanie funkcji wirtualnej klasy bazowej (323)
9. Wyjątki i bezpieczeństwo (325)
  • 9.0. Wprowadzenie (325)
  • 9.1. Tworzenie klasy wyjątku (325)
  • 9.2. Uodpornianie konstruktora klasy (329)
  • 9.3. Uodpornianie listy inicjalizacyjnej konstruktora (332)
  • 9.4. Uodpornianie metod klasy (335)
  • 9.5. Bezpieczne kopiowanie obiektu (339)
10. Strumienie i pliki (345)
  • 10.0. Wprowadzenie (345)
  • 10.1. Wyrównywanie tekstu w kolumnach (346)
  • 10.2. Formatowanie wartości zmiennoprzecinkowych (350)
  • 10.3. Pisanie własnego manipulatora strumienia (353)
  • 10.4. Adaptacja klasy do zapisu obiektów do strumienia (356)
  • 10.5. Adaptacja klasy do odczytu obiektów ze strumienia (359)
  • 10.6. Pozyskiwanie informacji o pliku (361)
  • 10.7. Kopiowanie pliku (363)
  • 10.8. Usuwanie i zmiana nazwy pliku (366)
  • 10.9. Tymczasowe nazwy plików i pliki tymczasowe (368)
  • 10.10. Tworzenie katalogu (370)
  • 10.11. Usuwanie katalogu (372)
  • 10.12. Przeglądanie zawartości katalogu (374)
  • 10.13. Wyłuskiwanie ciągu rozszerzenia pliku (376)
  • 10.14. Wyłuskiwanie nazwy pliku z ciągu ścieżki dostępu (377)
  • 10.15. Wyłuskiwanie ścieżki dostępu (379)
  • 10.16. Zmiana rozszerzenia nazwy pliku (380)
  • 10.17. Montowanie ścieżek dostępu (381)
11. Matematyka, statystyka (385)
  • 11.0. Wprowadzenie (385)
  • 11.1. Określanie liczby elementów w kontenerze (386)
  • 11.2. Wyszukiwanie największej bądź najmniejszej wartości w kontenerze (387)
  • 11.3. Obliczanie sumy i średniej wartości elementów kontenera (390)
  • 11.4. Filtrowanie wartości spoza zadanego zakresu (392)
  • 11.5. Obliczanie wariancji, odchylenia standardowego i innych wskaźników statystycznych (394)
  • 11.6. Generowanie liczb losowych (397)
  • 11.7. Inicjalizacja kontenera liczbami losowymi (399)
  • 11.8. Wektory liczb o dynamicznych rozmiarach (400)
  • 11.9. Wektory liczb o stałych rozmiarach (401)
  • 11.10. Obliczanie iloczynu skalarnego (404)
  • 11.11. Obliczanie długości wektora (405)
  • 11.12. Obliczanie odległości pomiędzy wektorami (406)
  • 11.13. Implementowanie iteratora kroczącego (407)
  • 11.14. Macierze o dynamicznych rozmiarach (411)
  • 11.15. Macierze o stałych rozmiarach (414)
  • 11.16. Mnożenie macierzy (416)
  • 11.17. Szybka transformata Fouriera (418)
  • 11.18. Współrzędne biegunowe (420)
  • 11.19. Arytmetyka zbiorów bitowych (421)
  • 11.20. Reprezentowanie wielkich liczb całkowitych (425)
  • 11.21. Liczby stałoprzecinkowe (429)
12. Wielowątkowość (431)
  • 12.0. Wprowadzenie (431)
  • 12.1. Tworzenie wątku (432)
  • 12.2. Synchronizacja dostępu do zasobu (435)
  • 12.3. Sygnalizacja pomiędzy wątkami (443)
  • 12.4. Jednokrotna inicjalizacja wspólnych zasobów (446)
  • 12.5. Argumenty funkcji wątku (447)
13. Internacjonalizacja (451)
  • 13.0. Wprowadzenie (451)
  • 13.1. Literały Unicode (452)
  • 13.2. Wczytywanie i wypisywanie liczb (453)
  • 13.3. Wczytywanie i wypisywanie dat i godzin (457)
  • 13.4. Wczytywanie i wypisywanie wartości pieniężnych (461)
  • 13.5. Sortowanie ciągów zlokalizowanych (466)
14. XML (469)
  • 14.0. Wprowadzenie (469)
  • 14.1. Przetwarzanie prostych dokumentów XML (470)
  • 14.2. Praca z ciągami Xerces (477)
  • 14.3. Przetwarzanie złożonych dokumentów XML (480)
  • 14.4. Manipulowanie dokumentami XML (489)
  • 14.5. Walidacja dokumentu XML względem definicji DTD (493)
  • 14.6. Walidacja dokumentu XML względem schematu (497)
  • 14.7. Przekształcanie dokumentów XML przy użyciu XSLT (501)
  • 14.8. Obliczanie wartości wyrażenia XPath (506)
  • 14.9. XML w utrwalaniu i odtwarzaniu kolekcji obiektów (512)
15. Różne (517)
  • 15.0. Wprowadzenie (517)
  • 15.1. Wskaźniki funkcji w wywołaniach zwrotnych (517)
  • 15.2. Wskaźniki składowych klas (519)
  • 15.3. Blokowanie modyfikacji argumentu wywołania funkcji (521)
  • 15.4. Blokowanie modyfikacji obiektu w metodzie wywołanej na rzecz tego obiektu (524)
  • 15.5. Operatory niebędące metodami klasy (526)
  • 15.6. Inicjalizacja sekwencji wartościami wymienianymi po przecinkach (528)
Skorowidz (531)