.:$$:.

• Demonstruje praktyczne techniki stosowane przez zawodowych programistów
• Zawiera poprawny, gruntownie przetestowany przykładowy kod źródłowy programów oraz przykłady zaczerpnięte z praktyki
• Skoncentrowana na nowoczesnych technologiach, które muszą poznać programiści
• Zawiera rady profesjonalistów, które pozwolą czytelnikowi tworzyć najlepsze programy

Książka Wiktora Shterna zatytułowana "C++. Inżynieria programowania" stosuje wyjątkowy sposób nauki języka C++ przeznaczony dla programistów mających doświadczenie w dowolnym języku programowania: prezentuje możliwość zastosowania w C++ najlepszych technik programistycznych oraz metodologii inżynierii programowania. Nawet jeżeli już wcześniej wykorzystywałeś język C++, ta wyczerpująca książka przedstawi sposób tworzenia poprawniejszego kodu, łatwiejszego do utrzymania i modyfikacji.

Książka niniejsza uczy zasad programowania obiektowego przed samą nauką języka, co pozwala wykorzystać wszystkie zalety OOP do tworzenia poprawnych aplikacji. Udoskonalisz znajomość kluczowych składników standardu ANSI/ISO C++ rozpatrywanych z punktu widzenia inżyniera: klas, metod, modyfikatorów const, dynamicznego zarządzania pamięcią, złożeń klas, dziedziczenia, polimorfizmu, operacji wejścia-wyjścia i wielu innych. Jeżeli pragniesz tworzyć w języku C++ najlepsze programy, musisz projektować, myśleć i programować stosując najlepsze obecnie praktyki inżynierii programowania. Lektura książki "C++. Inżynieria programowania" pomoże Ci w tym.

Książka "C++. Inżynieria programowania" kładzie nacisk na:

• Prezentację zastosowań zasad inżynierii programowania w programach pisanych w C++
• Tworzenie kodu łatwego do późniejszych modyfikacji
• Praktyczne zrozumienie zasad programowania obiektowego przed nauką samego języka
• Przedstawienie najnowszych cech standardu ANSI/ISO C++
• Zaprezentowanie setek realistycznych przykładów kodu programów

• Co odróżnia tę książkę od innych książek o C++? (15)
• Dla kogo jest przeznaczona ta książka? (17)
• Jak korzystać z tej książki? (17)
• Konwencje stosowane w książce (18)
• Dostęp do kodów źródłowych (19)

• Źródła kryzysu oprogramowania (24)
• Rozwiązanie 1. - wyeliminowanie programistów (28)
• Rozwiązanie 2. - ulepszone techniki zarządzania (30)
• Metoda wodospadu (31)
• Szybkie tworzenie prototypu (32)
• Rozwiązanie 3. - projektowanie złożonego i rozwlekłego języka (33)
• Podejście zorientowane obiektowo - czy dostaniemy coś za nic? (34)
• Na czym polega praca projektanta? (35)
• Jakość projektu - spójność (37)
• Jakość projektu - łączność (37)
• Jakość projektu - wiązanie danych i funkcji (38)
• Jakość projektu - ukrywanie informacji i kapsułkowanie (40)
• Sprawa projektowania - konflikty nazewnictwa (41)
• Sprawa projektowania - inicjalizacja obiektu (42)
• Czym jest obiekt? (43)
• Zalety stosowania obiektów (44)
• Charakterystyka języka C++ (45)
• Cele języka C - wydajność, czytelność, piękno i przenośność (45)
• Cele języka C++ - klasy ze wsteczną zgodnością z C (47)
• Podsumowanie (50)

• Podstawowa struktura programu (54)
• Dyrektywy preprocesora (56)
• Komentarze (60)
• Deklaracje i definicje (63)
• Instrukcje i wyrażenia (69)
• Funkcje i wywołania funkcji (77)
• Klasy (86)
• Praca z narzędziami programistycznymi (90)
• Podsumowanie (94)

• Wartości i ich typy (96)
• Typy całkowitoliczbowe (98)
• Kwalifikatory typu całkowitoliczbowego (100)
• Znaki (104)
• Wartości logiczne (106)
• Typy liczb zmiennoprzecinkowych (107)
• Praca z wyrażeniami C++ (109)
• Operatory o wysokim priorytecie (110)
• Operatory arytmetyczne (111)
• Operatory przesunięcia (114)
• Bitowe operatory logiczne (115)
• Operatory relacji i równości (118)
• Operatory logiczne (120)
• Operatory przypisania (122)
• Operator warunkowy (123)
• Operator przecinkowy (124)
• Wyrażenia mieszane - ukryte zagrożenia (125)
• Podsumowanie (131)

• Instrukcje i wyrażenia (134)
• Instrukcje warunkowe (136)
• Standardowe formy instrukcji warunkowych (136)
• Częste błędy w instrukcjach warunkowych (140)
• Zagnieżdżone instrukcje warunkowe i ich optymalizacja (152)
• Iteracje (158)
• Zastosowanie pętli WHILE (159)
• Iteracje w pętli DO-WHILE (167)
• Iteracje w pętli FOR (170)
• Instrukcje skoków w C++ (173)
• Instrukcja BREAK (174)
• Instrukcja CONTINUE (177)
• Instrukcja GOTO (178)
• Instrukcje skoków RETURN i EXIT (179)
• Instrukcja SWITCH (183)
• Podsumowanie (186)

• Tablice jako agregaty homogeniczne (188)
• Tablice jako wektory wartości (188)
• Definiowanie tablic C++ (190)
• Operacje na tablicach (193)
• Sprawdzanie poprawności indeksów (194)
• Tablice wielowymiarowe (197)
• Definiowanie tablic znaków (200)
• Operacje na tablicach znaków (202)
• Funkcje łańcuchowe a błędy pamięci (204)
• Dwuwymiarowe tablice znaków (208)
• Przepełnienie tablic w algorytmach je wypełniających (210)
• Definiowanie typów tablicowych (214)
• Struktury jako agregaty heterogeniczne (216)
• Definiowanie struktur jako typów zdefiniowanych przez programistę (216)
• Tworzenie i inicjalizowanie zmiennych strukturalnych (217)
• Struktury hierarchiczne i ich komponenty (219)
• Operacje na zmiennych strukturalnych (220)
• Definiowanie struktur w programach złożonych z wielu plików (222)
• Unie, typy wyliczeniowe i pola bitowe (223)
• Unie (223)
• Typy wyliczeniowe (227)
• Pola bitowe (229)
• Podsumowanie (233)

• Zasięg nazw jako narzędzie współpracy (236)
• Zasięgi leksykalne C++ (236)
• Konflikty nazw w tym samym zasięgu (237)
• Stosowanie takich samych nazw w zasięgach niezależnych (241)
• Stosowanie takich samych nazw w zasięgach zagnieżdżonych (241)
• Zasięg zmiennych pętli (246)
• Zarządzanie pamięcią - klasy pamięci (246)
• Zmienne automatyczne (248)
• Zmienne zewnętrzne (251)
• Zmienne statyczne (257)
• Zarządzanie pamięcią - zastosowanie sterty (261)
• Wskaźniki C++ jako zmienne o określonym typie (263)
• Alokowanie pamięci na stercie (268)
• Tablice i wskaźniki (273)
• Tablice dynamiczne (276)
• Struktury dynamiczne (290)
• Operacje wejścia i wyjścia na plikach (300)
• Zapisywanie do pliku (301)
• Odczyt z pliku (304)
• Plikowe obiekty wejścia-wyjścia (308)
• Podsumowanie (311)

• Funkcje w C++ jako narzędzie modularyzacji programu (317)
• Deklaracje funkcji (318)
• Definicje funkcji (319)
• Wywołania funkcji (320)
• Promocja i konwersja argumentów funkcji (323)
• Przekazywanie parametrów do funkcji w C++ (326)
• Przekazanie parametru przez wartość (326)
• Przekazanie parametrów poprzez wskaźnik (328)
• Przekazanie parametrów do funkcji charakterystycznej dla C++ - poprzez referencję (336)
• Struktury (341)
• Tablice (348)
• Więcej o konwersjach typów (352)
• Zwracanie wartości z funkcji (355)
• Funkcje wplecione - inline (361)
• Parametry funkcji z wartościami domyślnymi (364)
• Przeciążanie nazw funkcji (370)
• Podsumowanie (377)

• Kohezja (385)
• Sprzęganie (386)
• Niejawne sprzężenie (386)
• Jawne sprzężenie (390)
• Jak zredukować intensywność sprzęgania? (395)
• Hermetyzacja danych (400)
• Ukrywanie danych (407)
• Większy przykład hermetyzacji danych (413)
• Wady hermetyzacji danych przy użyciu funkcji (422)
• Podsumowanie (425)

• Podstawowa składnia definicji klasy (430)
• Połączenie danych i operacji (430)
• Eliminowanie konfliktów nazw (435)
• Implementacja kodów metod poza definicją klasy (439)
• Definiowane obiektów przechowywanych w pamięci różnych kategorii (443)
• Kontrolowanie dostępu do komponentów klasy (444)
• Inicjowanie obiektów danej klasy (451)
• Konstruktory - jako metody (452)
• Konstruktory domyślne (455)
• Konstruktory kopiujące (457)
• Konstruktory konwersji (461)
• Destruktory (463)
• Co i kiedy, czyli co naprawdę robią konstruktory i destruktory (468)
• Widoczność nazw w obrębie klasy i przesłanianie nazw przy zagnieżdżaniu (469)
• Zarządzanie pamięcią za pomocą operatorów i wywołań funkcji (472)
• Zastosowanie w kodzie klienta obiektów zwracanych przez funkcje (476)
• Zwrot wskaźników i referencji (476)
• Zwrot obiektów z funkcji (479)
• Więcej o stosowaniu słowa kluczowego const (482)
• Statyczne komponenty klas (488)
• Zastosowanie zmiennych globalnych jako charakterystyk klas (489)
• Czwarte znaczenie słowa kluczowego static (491)
• Inicjowanie statycznych pól danych (492)
• Statyczne metody (493)
• Podsumowanie (497)

• Przeciążanie operatorów (501)
• Ograniczenia w przeciążaniu operatorów (510)
• Które operatory nie mogą być poddane przeciążaniu? (510)
• Ograniczenia typów wartości zwracanych przez funkcje operatorowe (512)
• Ograniczenia liczby parametrów funkcji operatorowych (514)
• Ograniczenia wynikające z priorytetu operatorów (515)
• Przeciążone operatory jako komponenty składowe klas (516)
• Zastępowanie funkcji globalnej metodą należącą do klasy (516)
• Zastosowanie komponentów klas w operacjach łańcuchowych (519)
• Zastosowanie słowa kluczowego const (521)
• Analiza przedmiotowa - ułamki zwykłe (523)
• Mieszane typy danych jako parametry (533)
• Funkcje zaprzyjaźnione "friend" (541)
• Podsumowanie (556)

• Więcej o przekazywaniu obiektów poprzez wartość (559)
• Przeciążanie operatorów w klasach nie będących klasami numerycznymi (566)
• Klasa String (567)
• Dynamiczne zarządzanie pamięcią na stercie (569)
• Ochrona danych na stercie należących do obiektu od strony kodu klienta (574)
• Przeciążony operator konkatenacji łańcuchów znakowych (574)
• Zapobieganie wyciekom pamięci (577)
• Ochrona integralności programu (578)
• Jak "stąd" przejść "tam"? (583)
• Więcej o konstruowaniu kopii obiektów (585)
• Sposób na zachowanie integralności programu (585)
• Semantyka referencji i semantyka wartości (590)
• Konstruktor kopiujący definiowany przez programistę (592)
• Zwrot poprzez wartość (597)
• Ograniczenia skuteczności konstruktorów kopiujących (600)
• Przeciążenie operatora przypisania (601)
• Problem z dodaną przez kompilator obsługą operatora przypisania (602)
• Przeciążenie przypisania - wersja pierwsza (z wyciekiem pamięci) (603)
• Przeciążenie przypisania - wersja następna (samoprzypisanie) (604)
• Przeciążenie przypisania - jeszcze jedna wersja (wyrażenia łańcuchowe) (605)
• Pierwszy środek zapobiegawczy - więcej przeciążania (610)
• Drugi środek zapobiegawczy - zwrot wartości poprzez referencję (611)
• Rozważania praktyczne - jak chcielibyśmy to zaimplementować? (612)
• Podsumowanie (616)

• Wykorzystywanie obiektów jako danych składowych (623)
• Składnia C++ dotycząca złożenia klas (625)
• Dostęp do danych składowych komponentów klasy (626)
• Dostęp do danych składowych parametrów metody (629)
• Inicjalizacja obiektów złożonych (630)
• Wykorzystanie domyślnych konstruktorów komponentów (632)
• Wykorzystanie listy inicjalizującej składowe (638)
• Dane składowe ze specjalnymi właściwościami (644)
• Stałe dane składowe (645)
• Dane składowe określone przez referencje (646)
• Wykorzystywanie obiektów w charakterze danych składowych ich własnej klasy (649)
• Wykorzystywanie statycznych danych składowych w charakterze składowych ich własnych klas (651)
• Klasy kontenerów (654)
• Klasy zagnieżdżone (670)
• Klasy zaprzyjaźnione (673)
• Podsumowanie (676)

• Traktowanie podobnych klas (679)
• Łączenie cech podklas w jednej klasie (681)
• Przekazywanie odpowiedzialności za integralność programu do klasy serwera (683)
• Oddzielenie klas dla każdego rodzaju obiektu serwera (688)
• Wykorzystywanie dziedziczenia w języku C++ w celu łączenia powiązanych klas (691)
• Składnia dziedziczenia w języku C++ (694)
• Różne tryby dziedziczenia z klasy bazowej (695)
• Definiowanie oraz wykorzystywanie obiektów klas bazowych oraz klas pochodnych (699)
• Dostęp do usług klasy bazowej oraz pochodnej (701)
• Dostęp do komponentów bazowych w obiektach klasy pochodnej (706)
• Dziedziczenie publiczne (706)
• Dziedziczenie chronione (711)
• Dziedziczenie prywatne (716)
• Zwiększanie dostępu do składowych bazowych w klasie pochodnej (718)
• Domyślny tryb dziedziczenia (720)
• Reguły zakresu widoczności oraz rozwiązywanie nazw przy stosowaniu dziedziczenia (722)
• Przeciążanie oraz ukrywanie nazw (725)
• Wywoływanie metody klasy bazowej ukrytej przez klasę pochodną (729)
• Wykorzystanie dziedziczenia w celu rozwoju programu (733)
• Konstruktory oraz destruktory klas pochodnych (736)
• Wykorzystanie list inicjalizujących w konstruktorach klas pochodnych (740)
• Destruktory w przypadku dziedziczenia (743)
• Podsumowanie (745)

• Wybór techniki wielokrotnego wykorzystywania kodu (749)
• Przykład relacji typu klient-serwer pomiędzy klasami (749)
• Ponowne wykorzystanie kodu poprzez ludzką inteligencję - po prostu zrób to jeszcze raz (753)
• Ponowne użycie kodu poprzez kupowanie usług (755)
• Ponowne wykorzystanie kodu poprzez dziedziczenie (759)
• Dziedziczenie wraz z ponownym zdefiniowaniem funkcji (764)
• Plusy i minusy dziedziczenia oraz złożenia (766)
• Język UML (768)
• Cele stosowania języka UML (768)
• Podstawy UML - Notacja klas (772)
• Podstawy UML - notacja relacji (773)
• Podstawy UML - notacja dla agregacji oraz uogólnienia (774)
• Podstawy UML - notacja krotności (776)
• Studium przypadku - wypożyczalnia filmów (778)
• Klasy oraz ich skojarzenia (779)
• Widoczność klasy oraz podział odpowiedzialności (796)
• Widoczność klas oraz relacje pomiędzy klasami (797)
• Przekazywanie odpowiedzialności do klas serwera (799)
• Stosowanie dziedziczenia (801)
• Podsumowanie (804)

• Konwersje pomiędzy klasami niepowiązanymi (809)
• Ścisła oraz słaba kontrola typów (812)
• Konstruktory konwertujące (813)
• Rzutowania pomiędzy wskaźnikami (lub referencjami) (815)
• Operatory konwersji (816)
• Konwersje pomiędzy klasami powiązanymi poprzez dziedziczenie (817)
• Konwersje bezpieczne oraz niebezpieczne (818)
• Konwersje wskaźników oraz referencji do obiektów (824)
• Konwersje wskaźników oraz referencji występujących w charakterze argumentów (833)
• Funkcje wirtualne - kolejny nowy pomysł (840)
• Wiązanie dynamiczne - podejście tradycyjne (843)
• Wiązanie dynamiczne - podejście obiektowe (852)
• Wiązanie dynamiczne - funkcje wirtualne (861)
• Wiązanie dynamiczne oraz statyczne (865)
• Funkcje czysto wirtualne (869)
• Funkcje wirtualne - destruktory (873)
• Wielodziedziczenie - kilka klas bazowych (875)
• Wielodziedziczenie - reguły dostępu (877)
• Konwersje pomiędzy klasami (878)
• Wielodziedziczenie - konstruktory oraz destruktory (880)
• Wielodziedziczenie - niejednoznaczności (881)
• Wielodziedziczenie - grafy skierowane (884)
• Czy wielodziedziczenie jest przydatne? (885)
• Podsumowanie (886)

• Przeciążanie operatorów - krótki wstęp (890)
• Operatory jednoargumentowe (898)
• Operatory inkrementacji oraz dekrementacji (899)
• Przyrostkowe operatory przeciążone (907)
• Operatory konwersji (910)
• Operatory indeksowania oraz wywołania funkcji (918)
• Operator indeksowania (918)
• Operator wywołania funkcji (927)
• Operatory wejścia-wyjścia (933)
• Przeciążanie operatora >> (933)
• Przeciążanie operatora << (937)
• Podsumowanie (939)

• Prosty przykład projektowania klas przeznaczonych do wielokrotnego wykorzystania (942)
• Składnia definicji klasy szablonu (951)
• Specyfikacja klasy szablonu (952)
• Konkretyzacja szablonu (953)
• Implementacja funkcji szablonu (955)
• Szablony zagnieżdżone (962)
• Klasy szablonów z wieloma parametrami (963)
• Kilka parametrów określających typ (963)
• Szablony z parametrami określonymi za pomocą stałego wyrażenia (967)
• Związki pomiędzy konkretyzacjami klas szablonów (970)
• Zaprzyjaźnione klasy szablonów (970)
• Zagnieżdżone klasy szablonów (974)
• Szablony ze składowymi statycznymi (977)
• Specjalizacje szablonów (979)
• Funkcje szablonowe (983)
• Podsumowanie (985)

• Prosty przykład obsługi wyjątków (988)
• Składnia wyjątków w języku C++ (995)
• Generowanie wyjątków (997)
• Przechwytywanie wyjątków (998)
• Deklaracja wyjątków (1005)
• Przekazywanie wyjątków (1007)
• Wykorzystywanie wyjątków z obiektami (1011)
• Składnia generowania, deklaracji oraz przechwytywania obiektów (1011)
• Wykorzystywanie dziedziczenia podczas stosowania wyjątków (1015)
• Wyjątki zdefiniowane w bibliotece standardowej (1020)
• Operatory rzutowania (1021)
• Operator static_cast (1022)
• Operator reinterpret_cast (1026)
• Operator const_cast (1026)
• Operator dynamic_cast (1029)
• Operator typeid (1032)
• Podsumowanie (1033)

• C++ jako tradycyjny język programowania (1036)
• Wbudowane typy danych języka C++ (1036)
• Wyrażenia języka C++ (1038)
• Przepływ kontroli w programie C++ (1040)
• C++ jako język modułowy (1041)
• Typy agregacyjne języka C++ - tablice (1042)
• Typy agregacyjne języka C++ - struktury, unie, wyliczenia (1043)
• Funkcje C++ jako narzędzia modularyzacji (1044)
• Funkcje C++ - przekazywanie parametrów (1046)
• Zakres widoczności oraz klasy pamięci w języku C++ (1048)
• C++ jako język obiektowy (1049)
• Klasy języka C++ (1050)
• Konstruktory, destruktory oraz operatory przeciążone (1051)
• Składanie klas oraz dziedziczenie (1052)
• Funkcje wirtualne oraz klasy abstrakcyjne (1054)
• Szablony (1055)
• Wyjątki (1056)
• Język C++ a konkurencja (1058)
• Język C++ a starsze języki programowania (1058)
• Język C++ a Visual Basic (1058)
• Język C++ a C (1059)
• Język C++ a Java (1060)
• Podsumowanie (1062)