Twój koszyk : Do zapłaty 0,00 zł Ilość w koszyku: 0

Strona główna » informatyka » Programowanie » C / C++ / Visual C++

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)