Деталі електронної книги

Język C++. Pierwsze starcie

Język C++. Pierwsze starcie

Zbigniew Koza

Eлектронна книга

Poznaj tajniki programowania w C++

  • Jak skonstruowany jest program w języku C++?
  • Na czym polega programowanie obiektowe?
  • Jak korzystać z bibliotek?

C++ to jeden z najpopularniejszych języków programowania. Stosowany jest zarówno przez profesjonalistów, jak i hobbystów. Wszyscy jego użytkownicy doceniają elastyczność, ogromne możliwości i szybkość działania napisanych w nim programów. Ogromną zaletą C++ jest to, że nie wymusza na programistach stosowania określonego stylu programowania. Z racji swoich możliwości jest to język bardzo złożony, a efektywne programowanie w nim wymaga poznania wielu technik i pojęć oraz umiejętności wykorzystania tej wiedzy w praktyce.

Książka "C++. Pierwsze starcie" to podręcznik, dzięki któremu opanujesz zasady programowania w tym języku i zdobędziesz solidne podstawy do dalszego rozwijania swoich umiejętności. Znajdziesz w niej opis aktualnego standardu C++ oraz omówienia narzędzi programistycznych i bibliotek. Poznasz elementy języka, zasady programowania obiektowego i tworzenia złożonych aplikacji. Przeczytasz o szablonach, bibliotece STL i obsłudze błędów. Dowiesz się, jak stosować biblioteki przy tworzeniu aplikacji dla systemów Windows i Linux.

  • Struktura programu w C++
  • Elementy języka
  • Korzystanie z funkcji
  • Programowanie obiektowe
  • Dynamiczne struktury danych
  • Stosowanie bibliotek
  • Szablony
  • Biblioteka STL
  • Obsługa błędów

Zrób pierwszy krok na drodze do profesjonalnego tworzenia oprogramowania.

Wstęp

Rozdział 1. Pierwszy program w C++

  • Dla kogo jest ta książka?    (13)
  • Rys historyczny    (13)
    • Dlaczego C++?    (14)
    • C++ a C    (16)
    • Aktualny standard języka    (16)
  • Zanim napiszesz swój pierwszy program    (16)
    • Środowisko programistyczne    (16)
  • Pierwszy program    (18)
    • Kompilacja kodu źródłowego    (18)
    • Błędy kompilacji    (19)
    • Uruchamianie programu w środowisku Dev-C++    (20)
    • Struktura prostego programu w C++    (20)
  • Obiekt std::cout i literały    (21)
  • Definiowanie obiektów    (22)
  • Identyfikatory, słowa kluczowe i dyrektywy    (24)
  • Zapis programu    (24)
  • Cztery działania matematyczne i typ double    (25)
  • Jeszcze więcej matematyki    (26)
  • Upraszczanie zapisu obiektów i funkcji biblioteki standardowej    (28)
  • Źródła informacji    (28)
  • Q & A    (29)
  • Pytania przeglądowe    (30)
  • Problemy    (30)

Rozdział 2. Wyrażenia i instrukcje

  • Instrukcje sterujące    (31)
    • Instrukcja if... else...    (31)
  • Pętle    (33)
    • Pętla for    (33)
    • Pętle while i do    (35)
    • Instrukcje break i continue    (35)
  • Typy wbudowane    (36)
    • Typy całkowite    (36)
    • Typy zmiennopozycyjne    (38)
    • Typ logiczny    (40)
    • Zapis literałów całkowitych i zmiennopozycyjnych    (40)
  • Wyrażenia arytmetyczne, promocje i konwersje standardowe    (41)
  • Tworzenie obiektów stałych    (43)
    • Modyfikator const    (43)
  • Popularne typy standardowe    (44)
    • Strumienie    (44)
    • Napisy    (46)
    • Wektory    (47)
    • Słowniki    (49)
  • Obiekty lokalne i globalne. Zasięg. Przesłanianie    (50)
  • Operatory    (51)
    • Priorytet operatorów    (53)
    • Łączność operatorów    (53)
    • Wartość operatorów    (53)
    • Opis wybranych operatorów    (53)
    • Operatorowe patologie    (57)
  • Wyrażenia i instrukcje    (57)
  • Q & A    (58)
  • Pytania przeglądowe    (58)
  • Problemy    (58)

Rozdział 3. Funkcje

  • Referencje    (61)
  • Funkcje swobodne    (62)
    • Definiowanie funkcji    (62)
    • Funkcje, które nie obliczają wartości    (63)
  • Po co są funkcje?    (64)
  • Funkcje składowe - wprowadzenie    (66)
  • Argumenty funkcji    (66)
    • Przekazywanie argumentów przez wartość    (66)
    • Przekazywanie argumentów przez referencję    (67)
    • Przekazywanie argumentów przez stałą referencję    (67)
  • Funkcje zwracające referencję    (69)
  • Operatory jako funkcje swobodne    (70)
  • Stos funkcji    (73)
  • Funkcje otwarte (inline)    (75)
  • Funkcje jako argumenty innych funkcji    (77)
  • Rekurencja    (77)
  • Argumenty domyślne    (78)
  • Lokalne obiekty statyczne    (79)
  • Funkcja main    (81)
    • Argumenty funkcji main    (81)
    • Wartość funkcji main    (81)
  • Polimorfizm nazw funkcji    (82)
  • Deklaracja a definicja funkcji    (82)
  • Q & A    (83)
  • Pytania przeglądowe    (83)
  • Problemy    (83)

Rozdział 4. Tablice i wskaźniki

  • Wskaźniki    (85)
    • Definiowanie wskaźników    (85)
    • Wskaźniki typu void*, czyli wycieczka w stronę C    (87)
    • Wskaźnik zerowy    (87)
    • Czym grozi nieumiejętne użycie wskaźników?    (87)
    • Wskaźniki stałe i wskaźniki na stałe    (88)
    • Wskaźniki na wskaźniki    (89)
  • Tablice    (89)
    • Tablice wielowymiarowe    (90)
    • Inicjalizacja tablic    (91)
    • Zastosowanie operatora sizeof do tablic    (91)
    • Tablice a wskaźniki    (92)
    • Tablice wskaźników i wskaźniki na tablice    (92)
    • Tablice jako argumenty funkcji    (93)
    • Teksty literalne i tablice znaków    (94)
    • Porównanie tablic i wektorów    (95)
  • Pamięć wolna (sterta)    (96)
  • Q & A    (98)
  • Pytania przeglądowe    (98)
  • Problemy    (99)

Rozdział 5. Klasy i obiekty

  • Struktury    (101)
    • Podstawowe zasady definiowania i używania struktur    (101)
    • Inicjalizacja struktur    (103)
    • Dostęp do składowych poprzez wskaźnik    (103)
  • Co to są klasy?    (104)
  • Definiowanie klas    (104)
    • Klasa jako ,,zmodyfikowana'' struktura    (104)
    • Konstruktory    (104)
    • Destruktor    (108)
  • Funkcje składowe (metody)    (109)
    • Metody i metody stałe    (110)
    • Przeciążanie operatorów w klasie    (111)
    • Konstruktor kopiujący i operator =    (111)
    • Wskaźnik this    (114)
  • Udostępnianie składowych    (115)
    • Sekcje public i private    (115)
    • Funkcje i klasy zaprzyjaźnione    (116)
  • Interfejs i implementacja    (117)
    • Podział definicji klasy na interfejs i implementację    (117)
  • Kontrakty, niezmienniki i asercje    (120)
    • Kontrakty    (120)
    • Niezmienniki    (121)
  • Hermetyzacja danych    (122)
  • Różnice między klasami i strukturami    (122)
  • Dygresja: składowe statyczne    (123)
  • Pytania przeglądowe    (124)
  • Problemy    (125)

Rozdział 6. Dynamiczne struktury danych

  • Stos na bazie tablicy dynamicznej    (127)
    • Interfejs stosu    (127)
    • Implementacja stosu    (128)
    • Test stosu    (133)
  • Stos na bazie listy pojedynczo wiązanej    (134)
    • Rekurencyjne struktury danych    (135)
    • Interfejs klasy    (135)
    • Implementacja    (136)
  • Dygresja: przestrzenie nazw i zagnieżdżanie definicji klas    (137)
  • Q & A    (139)
  • Pytania przeglądowe    (139)
  • Problemy    (140)

Rozdział 7. Dziedziczenie i polimorfizm

  • Dziedziczenie    (141)
    • Do czego służy dziedziczenie?    (141)
    • Definiowanie klasy pochodnej    (143)
    • Inicjalizacja klasy bazowej    (144)
    • Relacje ,,X ma Y'', ,,X jest Y'' oraz ,,X zarządza Y''    (146)
    • Kolejność inicjalizacji i destrukcji obiektu    (148)
    • Sekcja protected    (148)
    • Zastępowanie (overridnig) funkcji składowych    (149)
  • Polimorfizm    (151)
    • Niedoskonałości ,,zwykłego'' dziedziczenia    (151)
    • Definiowanie metod polimorficznych    (153)
    • vtable    (155)
    • Dygresja: klasy abstrakcyjne    (155)
  • Jak to się robi w Qt?    (157)
  • Q & A    (161)
  • Pytania przeglądowe    (161)
  • Problemy    (162)

Rozdział 8. Strumienie

  • Strumienie buforowane i niebuforowane    (163)
  • Klawiatura, konsola, plik, strumień napisowy    (164)
  • Stan strumienia    (166)
  • Manipulatory i formatowanie strumienia    (167)
    • Manipulator std::setw    (167)
    • Manipulator std::setprecision    (168)
  • Strumienie wyjścia    (169)
  • Strumienie wejścia    (169)
    • Funkcje składowe get i getline    (170)
    • Inne funkcje operujące na strumieniach wejściowych    (170)
  • Przykład    (171)
  • Pytania przeglądowe    (173)
  • Problemy    (174)

Rozdział 9. Biblioteki

  • Podział programu na pliki    (175)
    • Zasady kompilacji programów podzielonych na pliki    (176)
    • Przygotowanie plików źródłowych i nagłówkowych    (177)
    • Kompilacja za pomocą wiersza poleceń    (178)
    • Kompilacja za pomocą programu make    (179)
    • Kompilacja za pomocą projektów    (181)
    • Automatyzacja tworzenia pliku Makefile    (183)
  • Używanie gotowych bibliotek    (184)
    • Dekorowanie nazw i deklaracja extern "C"    (184)
    • Przykłady    (185)
  • Kompilacja i instalacja programów lub bibliotek z plików źródłowych    (188)
    • Przykłady    (188)
    • Systemy kontroli wersji    (189)
  • Pytania przeglądowe    (190)
  • Problemy    (190)

Rozdział 10. Preprocesor i szablony

  • Preprocesor    (191)
    • Rola preprocesora w C++    (191)
    • Dyrektywy preprocesora    (192)
    • Przykład    (195)
    • Podsumowanie    (197)
  • Szablony    (197)
    • Szablony klas    (197)
    • Szablony funkcji składowych    (200)
    • Szablony funkcji swobodnych    (201)
    • Specjalizacja szablonu    (202)
    • Używanie szablonów funkcji do upraszczania pracy z szablonami klas    (202)
    • Gdzie umieszczać definicje szablonów?    (203)
    • Szablony a programowanie generyczne    (204)
    • Dygresja: konstrukcja typedef    (204)
  • Pytania przeglądowe    (205)
  • Problemy    (206)

Rozdział 11. Wprowadzenie do STL

  • Co to jest STL?    (207)
  • Pojemniki    (208)
  • Iteratory    (208)
    • Co to są iteratory?    (208)
    • Przykład użycia iteratorów    (209)
    • Rodzaje iteratorów    (210)
  • Algorytmy    (211)
    • Co to są algorytmy?    (211)
    • Funktory    (212)
    • Obiekty funkcyjne    (213)
    • Wartości pobierane i zwracane przez algorytmy    (215)
    • Obiekty funkcyjne a efektywność szablonów funkcji    (216)
  • Wektory (std::vector)    (218)
    • Opis szablonu std::vector    (218)
    • Przykłady    (221)
  • Liczby zespolone    (222)
  • Napisy (std::string)    (223)
  • Q & A    (224)
  • Pytania przeglądowe    (225)
  • Problemy    (225)

Rozdział 12. Pojemniki i algorytmy

  • Przegląd pojemników STL    (227)
    • Słowniki    (228)
    • Zbiory    (232)
    • Wielosłowniki i wielozbiory    (233)
    • Słowniki i zbiory mieszające    (233)
    • Kolejki o dwóch końcach    (235)
    • Listy    (235)
    • Stosy, kolejki i kolejki priorytetowe    (236)
    • Wektory i zbiory bitów    (237)
    • Wektory numeryczne (std::valarray)    (238)
  • Przegląd algorytmów swobodnych    (239)
    • Algorytmy niemodyfikujące    (240)
    • Algorytmy modyfikujące    (241)
    • Sortowanie    (245)
    • Algorytmy numeryczne    (245)
    • Inne algorytmy    (246)
    • Przykład    (246)
  • Kontrola poprawności użycia STL    (246)
  • Składniki dodatkowe    (248)
  • Q & A    (248)
  • Pytania przeglądowe    (248)
  • Problemy    (249)

Rozdział 13. Obsługa błędów

  • Rodzaje błędów    (251)
  • Analiza błędów składniowych: koncepty    (252)
  • Wykrywanie błędów logicznych: debuger    (254)
    • Debuger gdb    (255)
  • Obsługa błędów czasu wykonania: wyjątki    (257)
    • Zgłaszanie wyjątków    (259)
    • Wyłapywanie wyjątków    (260)
    • Wyjątki z metodami wirtualnymi    (261)
    • Specyfikacja wyjątków    (262)
    • Zwijanie stosu    (263)
    • Wyjątki a gospodarka zasobami    (264)
    • Przykład zastosowania wyjątków    (265)
  • Q & A    (267)
  • Pytania przeglądowe    (267)
  • Problemy    (268)

Rozdział 14. Co dalej?

  • Problemy    (272)

Dodatki

  • Wybrane opcje kompilatora g++    (273)
  • Dodatkowe elementy języka    (275)
    • Instrukcja goto    (275)
    • Instrukcja switch    (275)
  • Zgodność języka C++ z językiem C    (276)
  • Przyszłość języka C++    (277)
  • Źródła informacji w internecie    (278)

Skorowidz

  • Назва: Język C++. Pierwsze starcie
  • Автор: Zbigniew Koza
  • ISBN: 978-83-246-4507-7, 9788324645077
  • Дата видання: 2012-01-18
  • Формат: Eлектронна книга
  • Ідентифікатор видання: jcppps
  • Видавець: Helion