wprowadź własne kryteria wyszukiwania książek: (jak szukać?)
Twój koszyk:   0 zł   zamówienie wysyłkowe >>>
Strona główna > opis książki
English version
Książki:

polskie
podział tematyczny
 
anglojęzyczne
podział tematyczny
 
Newsletter:

Zamów informacje o nowościach z wybranego tematu
 
Informacje:

o księgarni

koszty wysyłki

kontakt

Cookies na stronie

 
Szukasz podpowiedzi?
Nie znasz tytułu?
Pomożemy Ci, napisz!


Podaj adres e-mail:


możesz też zadzwonić
+48 512 994 090

PROGRAMOWANIE TEORIA I PRAKTYKA Z WYKORZYSTANIEM C++


STROUSTRUP B.

wydawnictwo: HELION, 2020, wydanie III

cena netto: 151.75 Twoja cena  144,16 zł + 5% vat - dodaj do koszyka

Programowanie

Teoria i praktyka z wykorzystaniem C++


  • Jak zacząć pracę w zintegrowanym środowisku programistycznym?
  • Jak profesjonalnie tworzyć programy użytkowe?
  • Jak korzystać z biblioteki graficznego interfejsu użytkownika?

Jeśli zależy Ci na tym, aby zdobyć rzetelną wiedzę i perfekcyjne umiejętności programowania z użyciem języka C++, powinieneś uczyć się od wybitnego eksperta i twórcy tego języka - Bjarne Stroustrupa, który jako pierwszy zaprojektował i zaimplementował C++. Podręcznik, który trzymasz w ręku, daje Ci szansę odkrycia wszelkich tajników tego języka, obszernie opisanego w międzynarodowym standardzie i obsługującego najważniejsze techniki programistyczne. C++ umożliwia pisanie wydajnego i eleganckiego kodu, a większość technik w nim stosowanych można przenieść do innych języków programowania.

Książka Programowanie w C++. Teoria i praktyka zawiera szczegółowy opis pojęć i technik programistycznych, a także samego języka C++, oraz przykłady kodu. Znajdziesz tu również omówienia zagadnień zaawansowanych, takich jak przetwarzanie tekstu i testowanie.

Z tego podręcznika dowiesz się, na czym polega wywoływanie funkcji przeciążonych i dopasowywanie wyrażeń regularnych. Zobaczysz też, jaki powinien być standard kodowania. Poznasz sposoby projektowania klas graficznych i systemów wbudowanych, tajniki implementacji, wykorzystywania funkcji oraz indywidualizacji operacji wejścia i wyjścia. Korzystając z tego przewodnika, nauczysz się od samego mistrza pisać doskonałe, wydajne i łatwe w utrzymaniu programy.

  • Techniki programistyczne
  • Infrastruktura algorytmiczna
  • Biblioteka standardowa C++
  • Instrukcje sterujące i obsługa błędów
  • Implementacja i wykorzystanie funkcji
  • Kontrola typów
  • Interfejsy klas
  • Indywidualizacja operacji wejścia i wyjścia
  • Projektowanie klas graficznych
  • Wektory i pamięć wolna
  • Kontenery i iteratory
  • Programowanie systemów wbudowanych
  • Makra

Wstęp
Słowo do studentów
Słowo do nauczycieli
Standard ISO C++
Pomoc
Podziękowania

0. Uwagi do czytelnika
0.1. Struktura książki
0.1.1. Informacje ogólne
0.1.2. Ćwiczenia, praca domowa itp.
0.1.3. Po przeczytaniu tej książki
0.2. Filozofia nauczania i uczenia się
0.2.1. Kolejność tematów
0.2.2. Programowanie a język programowania
0.2.3. Przenośność
0.3. Programowanie a informatyka
0.4. Kreatywność i rozwiązywanie problemów
0.5. Uwagi i komentarze czytelników
0.6. Bibliografia
0.7. Noty biograficzne
Bjarne Stroustrup
Lawrence Pete Petersen

1. Komputery, ludzie i programowanie
1.1. Wstęp
1.2. Oprogramowanie
1.3. Ludzie
1.4. Informatyka
1.5. Komputery są wszędzie
1.5.1. Komputery z ekranem i bez
1.5.2. Transport
1.5.3. Telekomunikacja
1.5.4. Medycyna
1.5.5. Informacja
1.5.6. Sięgamy w kosmos
1.5.7. I co z tego
1.6. Ideały dla programistów
Powtórzenie

Część I. Podstawy

2. Witaj, świecie!
2.1. Programy
2.2. Klasyczny pierwszy program
2.3. Kompilacja
2.4. Łączenie
2.5. Środowiska programistyczne
Ćwiczenia

3. Obiekty, typy i wartości
3.1. Dane wejściowe
3.2. Zmienne
3.3. Typy danych wejściowych
3.4. Operacje i operatory
3.5. Przypisanie i inicjalizacja
3.5.1. Przykład wykrywania powtarzających się słów
3.6. Złożone operatory przypisania
3.6.1. Przykład zliczania powtarzających się słów
3.7. Nazwy
3.8. Typy i obiekty
3.9. Kontrola typów
3.9.1. Konwersje bezpieczne dla typów
3.9.2. Konwersje niebezpieczne dla typów

4. Wykonywanie obliczeń
4.1. Wykonywanie obliczeń
4.2. Cele i narzędzia
4.3. Wyrażenia
4.3.1. Wyrażenia stałe
4.3.2. Operatory
4.3.3. Konwersje
4.4. Instrukcje
4.4.1. Selekcja
4.4.1.1. Instrukcje if
4.4.1.2. Instrukcje switch
4.4.1.3. Instrukcja switch od strony technicznej
4.4.2. Iteracja
4.4.2.1. Instrukcje while
4.4.2.2. Bloki
4.4.2.3. Instrukcje for
4.5. Funkcje
4.5.1. Po co zaprzątać sobie głowę funkcjami
4.5.2. Deklarowanie funkcji
4.6. Wektor
4.6.1. Przeglądanie zawartości wektora
4.6.2. Powiększanie wektora
4.6.3. Przykład wczytywania liczb do programu
4.6.4. Przykład z użyciem tekstu
4.7. Właściwości języka

5. Błędy
5.1. Wstęp
5.2. Źródła błędów
5.3. Błędy kompilacji
5.3.1. Błędy składni
5.3.2. Błędy typów
5.3.3. Niebłędy
5.4. Błędy konsolidacji
5.5. Błędy czasu wykonania
5.5.1. Rozwiązywanie problemu przez wywołującego
5.5.2. Rozwiązywanie problemu przez wywoływanego
5.5.3. Raportowanie błędów
5.6. Wyjątki
5.6.1. Nieprawidłowe argumenty
5.6.2. Błędy zakresu
5.6.3. Nieprawidłowe dane wejściowe
5.6.4. Błędy zawężania zakresu
5.7. Błędy logiczne
5.8. Szacowanie
5.9. Debugowanie
5.9.1. Praktyczna rada dotycząca debugowania
5.10. Warunki wstępne i końcowe
5.10.1. Warunki końcowe
5.11. Testowanie

6. Pisanie programu
6.1. Problem
6.2. Przemyślenie problemu
6.2.1. Etapy rozwoju oprogramowania
6.2.2. Strategia
6.3. Wracając do kalkulatora
6.3.1. Pierwsza próba
6.3.2. Tokeny
6.3.3. Implementowanie tokenów
6.3.4. Używanie tokenów
6.3.5. Powrót do tablicy
6.4. Gramatyki
6.4.1. Dygresja gramatyka języka angielskiego
6.4.2. Pisanie gramatyki
6.5. Zamiana gramatyki w kod
6.5.1. Implementowanie zasad gramatyki
6.5.2. Wyrażenia
6.5.2.1. Wyrażenia pierwsza próba
6.5.2.2. Wyrażenia druga próba
6.5.2.3. Wyrażenia do trzech razy sztuka
6.5.3. Składniki
6.5.4. Podstawowe elementy wyrażeń
6.6. Wypróbowywanie pierwszej wersji
6.7. Wypróbowywanie drugiej wersji
6.8. Strumienie tokenów
6.8.1. Implementacja typu Token_stream
6.8.2. Wczytywanie tokenów
6.8.3. Wczytywanie liczb
6.9. Struktura programu

7. Kończenie programu
7.1. Wprowadzenie
7.2. Wejście i wyjście
7.3. Obsługa błędów
7.4. Liczby ujemne
7.5. Reszta z dzielenia
7.6. Oczyszczanie kodu
7.6.1. Stałe symboliczne
7.6.2. Użycie funkcji
7.6.3. Układ kodu
7.6.4. Komentarze
7.7. Odzyskiwanie sprawności po wystąpieniu błędu
7.8. Zmienne
7.8.1. Zmienne i definicje
7.8.2. Wprowadzanie nazw
7.8.3. Nazwy predefiniowane
7.8.4. Czy to już koniec?

8. Szczegóły techniczne funkcje itp.
8.1. Szczegóły techniczne
8.2. Deklaracje i definicje
8.2.1. Rodzaje deklaracji
8.2.2. Deklaracje stałych i zmiennych
8.2.3. Domyślna inicjalizacja
8.3. Pliki nagłówkowe
8.4. Zakres
8.5. Wywoływanie i wartość zwrotna funkcji
8.5.1. Deklarowanie argumentów i typu zwrotnego
8.5.2. Zwracanie wartości
8.5.3. Przekazywanie przez wartość
8.5.4. Przekazywanie argumentów przez stałą referencję
8.5.5. Przekazywanie przez referencję
8.5.6. Przekazywanie przez wartość a przez referencję
8.5.7. Sprawdzanie argumentów i konwersja
8.5.8. Implementacja wywołań funkcji
8.5.9. Funkcje constexpr
8.6. Porządek wykonywania instrukcji
8.6.1. Wartościowanie wyrażeń
8.6.2. Globalna inicjalizacja
8.7. Przestrzenie nazw
8.7.1. Dyrektywy i deklaracje using

9. Szczegóły techniczne klasy itp.
9.1. Typy zdefiniowane przez użytkownika
9.2. Klasy i składowe klas
9.3. Interfejs i implementacja
9.4. Tworzenie klas
9.4.1. Struktury i funkcje
9.4.2. Funkcje składowe i konstruktory
9.4.3. Ukrywanie szczegółów
9.4.4. Definiowanie funkcji składowych
9.4.5. Odwoływanie się do bieżącego obiektu
9.4.6. Raportowanie błędów
9.5. Wyliczenia
9.5.1. Zwykłe wyliczenia
9.6. Przeciążanie operatorów
9.7. Interfejsy klas
9.7.1. Typy argumentów
9.7.2. Kopiowanie
9.7.3. Konstruktory domyślne
9.7.4. Stałe funkcje składowe
9.7.5. Składowe i funkcje pomocnicze
9.8. Klasa Date

Część II. Wejście i wyjście

10. Strumienie wejścia i wyjścia
10.1. Wejście i wyjście
10.2. Model strumieni wejścia i wyjścia
10.3. Pliki
10.4. Otwieranie pliku
10.5. Odczytywanie i zapisywanie plików
10.6. Obsługa błędów wejścia i wyjścia
10.7. Wczytywanie pojedynczej wartości
10.7.1. Rozłożenie problemu na mniejsze części
10.7.2. Oddzielenie warstwy komunikacyjnej od funkcji
10.8. Definiowanie operatorów wyjściowych
10.9. Definiowanie operatorów wejściowych
10.10. Standardowa pętla wejściowa
10.11. Wczytywanie pliku strukturalnego
10.11.1. Reprezentacja danych w pamięci
10.11.2. Odczytywanie struktur wartości
10.11.3. Zmienianie reprezentacji

11. Indywidualizacja operacji wejścia i wyjścia
11.1. Regularność i nieregularność
11.2. Formatowanie danych wyjściowych
11.2.1. Wysyłanie na wyjście liczb całkowitych
11.2.2. Przyjmowanie na wejściu liczb całkowitych
11.2.3. Wysyłanie na wyjście liczb zmiennoprzecinkowych
11.2.4. Precyzja
11.2.5. Pola
11.3. Otwieranie plików i pozycjonowanie
11.3.1. Tryby otwierania plików
11.3.2. Pliki binarne
11.3.3. Pozycjonowanie w plikach
11.4. Strumienie łańcuchowe
11.5. Wprowadzanie danych wierszami
11.6. Klasyfikowanie znaków
11.7. Stosowanie niestandardowych separatorów
11.8. Zostało jeszcze tyle do poznania

12. Projektowanie klas graficznych
12.1. Czemu grafika?
12.2. Model graficzny
12.3. Pierwszy przykład
12.4. Biblioteka GUI
12.5. Współrzędne
12.6. Figury geometryczne
12.7. Używanie klas figur geometrycznych
12.7.1. Nagłówki graficzne i funkcja main
12.7.2. Prawie puste okno
12.7.3. Klasa Axis
12.7.4. Rysowanie wykresu funkcji
12.7.5. Wielokąty
12.7.6. Prostokąty
12.7.7. Wypełnianie kolorem
12.7.8. Tekst
12.7.9. Obrazy
12.7.10. Jeszcze więcej grafik
12.8. Uruchamianie programu
12.8.1. Pliki źródłowe

13. Klasy graficzne
13.1. Przegląd klas graficznych
13.2. Klasy Point i Line
13.3. Klasa Lines
13.4. Klasa Color
13.5. Typ Line_style
13.6. Typ Open_polyline
13.7. Typ Closed_polyline
13.8. Typ Polygon
13.9. Typ Rectangle
13.10. Wykorzystywanie obiektów bez nazw
13.11. Typ Text
13.12. Typ Circle
13.13. Typ Ellipse
13.14. Typ Marked_polyline
13.15. Typ Marks
13.16. Typ Mark
13.17. Typ Image

14. Projektowanie klas graficznych
14.1. Zasady projektowania
14.1.1. Typy
14.1.2. Operacje
14.1.3. Nazewnictwo
14.1.4. Zmienność
14.2. Klasa Shape
14.2.1. Klasa abstrakcyjna
14.2.2. Kontrola dostępu
14.2.3. Rysowanie figur
14.2.4. Kopiowanie i zmienność
14.3. Klasy bazowe i pochodne
14.3.1. Układ obiektu
14.3.2. Tworzenie podklas i definiowanie funkcji wirtualnych
14.3.3. Przesłanianie
14.3.4. Dostęp
14.3.5. Czyste funkcje wirtualne
14.4. Zalety programowania obiektowego

15. Graficzne przedstawienie funkcji i danych
15.1. Wprowadzenie
15.2. Rysowanie wykresów prostych funkcji
15.3. Typ Function
15.3.1. Argumenty domyślne
15.3.2. Więcej przykładów
15.3.3. Wyrażenia lambda
15.4. Typ Axis
15.5. Wartość przybliżona funkcji wykładniczej
15.6. Przedstawianie danych na wykresach
15.6.1. Odczyt danych z pliku
15.6.2. Układ ogólny
15.6.3. Skalowanie danych
15.6.4. Budowanie wykresu

16. Graficzne interfejsy użytkownika
16.1. Różne rodzaje interfejsów użytkownika
16.2. Przycisk Next
16.3. Proste okno
16.3.1. Funkcje zwrotne
16.3.2. Pętla oczekująca
16.3.3. Wyrażenie lambda jako wywołanie zwrotne
16.4. Typ Button i inne pochodne typu Widget
16.4.1. Widgety
16.4.2. Przyciski
16.4.3. Widgety In_box i Out_box
16.4.4. Menu
16.5. Przykład
16.6. Inwersja kontroli
16.7. Dodawanie menu
16.8. Debugowanie kodu GUI

Część III. Dane i algorytmy

17. Wektory i pamięć wolna
17.1. Wprowadzenie
17.2. Podstawowe wiadomości na temat typu vector
17.3. Pamięć, adresy i wskaźniki
17.3.1. Operator sizeof
17.4. Pamięć wolna a wskaźniki
17.4.1. Alokacja obiektów w pamięci wolnej
17.4.2. Dostęp poprzez wskaźniki
17.4.3. Zakresy
17.4.4. Inicjalizacja
17.4.5. Wskaźnik zerowy
17.4.6. Dealokacja pamięci wolnej
17.5. Destruktory
17.5.1. Generowanie destruktorów
17.5.2. Destruktory a pamięć wolna
17.6. Dostęp do elementów
17.7. Wskaźniki na obiekty klas
17.8. Babranie się w typach void* i rzutowanie
17.9. Wskaźniki i referencje
17.9.1. Wskaźniki i referencje jako parametry
17.9.2. Wskaźniki, referencje i dziedziczenie
17.9.3. Przykład listy
17.9.4. Operacje na listach
17.9.5. Zastosowania list
17.10. Wskaźnik this
17.10.1. Więcej przykładów użycia typu Link

18. Wektory i tablice
18.1. Wprowadzenie
18.2. Inicjalizacja
18.3. Kopiowanie
18.3.1. Konstruktory kopiujące
18.3.2. Przypisywanie z kopiowaniem
18.3.3. Terminologia związana z kopiowaniem
18.3.4. Przenoszenie
18.4. Podstawowe operacje
18.4.1. Konstruktory jawne
18.4.2. Debugowanie konstruktorów i destruktorów
18.5. Uzyskiwanie dostępu do elementów wektora
18.5.1. Problem stałych wektorów
18.6. Tablice
18.6.1. Wskaźniki na elementy tablicy
18.6.2. Wskaźniki i tablice
18.6.3. Inicjalizowanie tablic
18.6.4. Problemy ze wskaźnikami
18.7. Przykłady palindrom
18.7.1. Wykorzystanie łańcuchów
18.7.2. Wykorzystanie tablic
18.7.3. Wykorzystanie wskaźników

19. Wektory, szablony i wyjątki
19.1. Analiza problemów
19.2. Zmienianie rozmiaru
19.2.1. Reprezentacja
19.2.2. Rezerwacja pamięci i pojemność kontenera
19.2.3. Zmienianie rozmiaru
19.2.4. Funkcja push_back()
19.2.5. Przypisywanie
19.2.6. Podsumowanie dotychczasowej pracy nad typem vector
19.3. Szablony
19.3.1. Typy jako parametry szablonów
19.3.2. Programowanie ogólne
19.3.3. Koncepcje
19.3.4. Kontenery a dziedziczenie
19.3.5. Liczby całkowite jako parametry szablonów
19.3.6. Dedukcja argumentów szablonu
19.3.7. Uogólnianie wektora
19.4. Sprawdzanie zakresu i wyjątki
19.4.1. Dygresja uwagi projektowe
19.4.1.1. Zgodność
19.4.1.2. Wydajność
19.4.1.3. Ograniczenia
19.4.1.4. Opcjonalne sprawdzanie
19.4.2. Wyznanie na temat makr
19.5. Zasoby i wyjątki
19.5.1. Potencjalne problemy z zarządzaniem zasobami
19.5.2. Zajmowanie zasobów jest inicjalizacją
19.5.3. Gwarancje
19.5.4. Obiekt unique_ptr
19.5.5. Zwrot przez przeniesienie
19.5.6. Technika RAII dla wektora

20. Kontenery i iteratory
20.1. Przechowywanie i przetwarzanie danych
20.1.1. Praca na danych
20.1.2. Uogólnianie kodu
20.2. Ideały twórcy biblioteki STL
20.3. Sekwencje i iteratory
20.3.1. Powrót do przykładu
20.4. Listy powiązane
20.4.1. Operacje list
20.4.2. Iteracja
20.5. Jeszcze raz uogólnianie wektora
20.5.1. Przeglądanie kontenera
20.5.2. Słowo kluczowe auto
20.6. Przykład prosty edytor tekstu
20.6.1. Wiersze
20.6.2. Iteracja
20.7. Typy vector, list oraz string
20.7.1. Funkcje insert() i erase()
20.8. Dostosowanie wektora do biblioteki STL
20.9. Dostosowywanie wbudowanych tablic do STL
20.10. Przegląd kontenerów
20.10.1. Kategorie iteratorów

21. Algorytmy i słowniki
21.1. Algorytmy biblioteki standardowej
21.2. Najprostszy algorytm find()
21.2.1. Kilka przykładów z programowania ogólnego
21.3. Ogólny algorytm wyszukiwania find_if()
21.4. Obiekty funkcyjne
21.4.1. Abstrakcyjne spojrzenie na obiekty funkcyjne
21.4.2. Predykaty składowych klas
21.4.3. Wyrażenia lambda
21.5. Algorytmy numeryczne
21.5.1. Akumulacja
21.5.2. Uogólnianie funkcji accumulate()
21.5.3. Iloczyn skalarny
21.5.4. Uogólnianie funkcji inner_product()
21.6. Kontenery asocjacyjne
21.6.1. Słowniki
21.6.2. Opis ogólny kontenera map
21.6.3. Jeszcze jeden przykład zastosowania słownika
21.6.4. Kontener unordered_map
21.6.5. Zbiory
21.7. Kopiowanie
21.7.1. Funkcja copy()
21.7.2. Iteratory strumieni
21.7.3. Utrzymywanie porządku przy użyciu kontenera set
21.7.4. Funkcja copy_if()
21.8. Sortowanie i wyszukiwanie
21.9. Algorytmy kontenerowe

Część IV. Poszerzanie horyzontów

22. Ideały i historia
22.1. Historia, ideały i profesjonalizm
22.1.1. Cele i filozofie języków programowania
22.1.2. Ideały programistyczne
22.1.2.1. Czego chcemy
22.1.2.2. Ogólne podejścia
22.1.2.3. Bezpośrednie wyrażanie myśli
22.1.2.4. Poziom abstrakcji
22.1.2.5. Modułowość
22.1.2.6. Spójność i minimalizm
22.1.3. Style i paradygmaty
22.2. Krótka historia języków programowania
22.2.1. Pierwsze języki
Źródła
22.2.2. Korzenie nowoczesnych języków programowania
22.2.2.1. Fortran
Źródła
22.2.2.2. COBOL
Źródła
22.2.2.3. Lisp
Źródła
22.2.3. Rodzina Algol
22.2.3.1. Algol60
Źródła
22.2.3.2. Pascal
Źródła
22.2.3.3. Ada
Źródła
22.2.4. Simula
Źródła
22.2.5. C
Źródła
22.2.6. C++
Źródła
22.2.7. Dziś
22.2.8. Źródła informacji

23. Przetwarzanie tekstu
23.1. Tekst
23.2. Łańcuchy
23.3. Strumienie wejścia i wyjścia
23.4. Słowniki
23.4.1. Szczegóły implementacyjne
23.5. Problem
23.6. Wyrażenia regularne
23.6.1. Surowe literały łańcuchowe
23.7. Wyszukiwanie przy użyciu wyrażeń regularnych
23.8. Składnia wyrażeń regularnych
23.8.1. Znaki i znaki specjalne
23.8.2. Rodzaje znaków
23.8.3. Powtórzenia
23.8.4. Grupowanie
23.8.5. Alternatywa
23.8.6. Zbiory i przedziały znaków
23.8.7. Błędy w wyrażeniach regularnych
23.9. Dopasowywanie przy użyciu wyrażeń regularnych
23.10. Źródła

24. Działania na liczbach
24.1. Wprowadzenie
24.2. Rozmiar, precyzja i przekroczenie zakresu
24.2.1. Ograniczenia typów liczbowych
24.3. Tablice
24.4. Tablice wielowymiarowe w stylu języka C
24.5. Biblioteka Matrix
24.5.1. Wymiary i dostęp
24.5.2. Macierze jednowymiarowe
24.5.3. Macierze dwuwymiarowe
24.5.4. Wejście i wyjście macierzy
24.5.5. Macierze trójwymiarowe
24.6. Przykład rozwiązywanie równań liniowych
24.6.1. Klasyczna eliminacja Gaussa
24.6.2. Wybór elementu centralnego
24.6.3. Testowanie
24.7. Liczby losowe
24.8. Standardowe funkcje matematyczne
24.9. Liczby zespolone
24.10. Źródła

25. Programowanie systemów wbudowanych
25.1. Systemy wbudowane
25.2. Podstawy
25.2.1. Przewidywalność
25.2.2. Ideały
25.2.3. Życie z awarią
25.3. Zarządzanie pamięcią
25.3.1. Problemy z pamięcią wolną
25.3.2. Alternatywy dla ogólnej pamięci wolnej
25.3.3. Przykład zastosowania puli
25.3.4. Przykład użycia stosu
25.4. Adresy, wskaźniki i tablice
25.4.1. Niekontrolowane konwersje
25.4.2. Problem źle działające interfejsy
25.4.3. Rozwiązanie klasa interfejsu
25.4.4. Dziedziczenie a kontenery
25.5. Bity, bajty i słowa
25.5.1. Bity i operacje na bitach
25.5.2. Klasa bitset
25.5.3. Liczby ze znakiem i bez znaku
25.5.4. Manipulowanie bitami
25.5.5. Pola bitowe
25.5.6. Przykład proste szyfrowanie
25.6. Standardy pisania kodu
25.6.1. Jaki powinien być standard kodowania
25.6.2. Przykładowe zasady
25.6.3. Prawdziwe standardy kodowania

26. Testowanie
26.1. Czego chcemy
26.1.1. Zastrzeżenie
26.2. Dowody
26.3. Testowanie
26.3.1. Testowanie regresyjne
26.3.2. Testowanie jednostkowe
26.3.2.1. Strategia testowania
26.3.2.2. Prosta uprząż testowa
26.3.2.3. Sekwencje losowe
26.3.3. Algorytmy i niealgorytmy
26.3.3.1. Zależności
26.3.3.2. Zarządzanie zasobami
26.3.3.3. Pętle
26.3.3.4. Rozgałęzianie
26.3.4. Testy systemowe
26.3.5. Znajdowanie założeń, które się nie potwierdzają
26.4. Projektowanie pod kątem testowania
26.5. Debugowanie
26.6. Wydajność
26.6.1. Kontrolowanie czasu
26.7. Źródła

27. Język C
27.1. C i C++ to rodzeństwo
27.1.1. Zgodność języków C i C++
Źródła
27.1.2. Co jest w języku C++, czego nie ma w C
27.1.3. Biblioteka standardowa języka C
27.2. Funkcje
27.2.1. Brak możliwości przeciążania nazw funkcji
27.2.2. Sprawdzanie typów argumentów funkcji
27.2.3. Definicje funkcji
27.2.4. Wywoływanie C z poziomu C++ i C++ z poziomu C
27.2.5. Wskaźniki na funkcje
27.3. Mniej ważne różnice między językami
27.3.1. Przestrzeń znaczników struktur
27.3.2. Słowa kluczowe
27.3.3. Definicje
27.3.4. Rzutowanie w stylu języka C
27.3.5. Konwersja typu void*
27.3.6. Typ enum
27.3.7. Przestrzenie nazw
27.4. Pamięć wolna
27.5. Łańcuchy w stylu języka C
27.5.1. Łańcuchy w stylu języka C i const
27.5.2. Operacje na bajtach
27.5.3. Przykład funkcja strcpy()
27.5.4. Kwestia stylu
27.6. Wejście i wyjście nagłówek stdio
27.6.1. Wyjście
27.6.2. Wejście
27.6.3. Pliki
27.7. Stałe i makra
27.8. Makra
27.8.1. Makra podobne do funkcji
27.8.2. Makra składniowe
27.8.3. Kompilacja warunkowa
27.9. Przykład kontenery intruzyjne
Dodatki

A. Zestawienie własności języka
A.1. Opis ogólny
A.1.1. Terminologia
A.1.2. Uruchamianie i zamykanie programu
A.1.3. Komentarze
A.2. Literały
A.2.1. Literały całkowitoliczbowe
A.2.1.1. Systemy liczbowe
A.2.2. Literały liczb zmiennoprzecinkowych
A.2.3. Literały logiczne
A.2.4. Literały znakowe
A.2.5. Literały łańcuchowe
A.2.6. Literał wskaźnikowy
A.3. Identyfikatory
A.3.1. Słowa kluczowe
A.4. Zakres, pamięć oraz czas trwania
A.4.1. Zakres
A.4.2. Rodzaje pamięci
A.4.3. Czas trwania
A.5. Wyrażenia
A.5.1. Definiowanie operatorów przez użytkownika
A.5.2. Niejawna konwersja typów
A.5.2.1. Promocje
A.5.2.2. Konwersje
A.5.2.3. Konwersje zdefiniowane przez użytkownika
A.5.3. Wyrażenia stałe
A.5.4. Operator sizeof
A.5.5. Wyrażenia logiczne
A.5.6. Operatory new i delete
A.5.7. Rzutowanie
A.6. Instrukcje
A.7. Deklaracje
A.7.1. Definicje
A.8. Typy wbudowane
A.8.1. Wskaźniki
A.8.2. Tablice
A.8.3. Referencje
A.9. Funkcje
A.9.1. Wywoływanie funkcji przeciążonych
A.9.2. Argumenty domyślne
A.9.3. Niepodawanie listy argumentów
A.9.4. Instrukcje dla konsolidatora
A.10. Typy zdefiniowane przez użytkownika
A.10.1. Przeciążanie operatorów
A.11. Wyliczenia
A.12. Klasy
A.12.1. Dostęp do składowych
A.12.1.1. Wskaźnik this
A.12.1.2. Przyjaciele
A.12.2. Definiowanie składowych klas
A.12.3. Konstruowanie, usuwanie i kopiowanie obiektów
A.12.3.1. Destruktory
A.12.3.2. Kopiowanie
A.12.3.3. Przenoszenie
A.12.4. Klasy pochodne
A.12.4.1. Funkcje wirtualne
A.12.4.2. Klasy abstrakcyjne
A.12.4.3. Operacje generowane
A.12.5. Pola bitowe
A.12.6. Unie
A.13. Szablony
A.13.1. Argumenty szablonowe
A.13.2. Konkretyzacja szablonów
A.13.3. Typy składowe szablonów
A.14. Wyjątki
A.15. Przestrzenie nazw
A.16. Aliasy
A.17. Dyrektywy preprocesora
A.17.1. Dyrektywa #include
A.17.2. Dyrektywa #define

B. Biblioteka standardowa
B.1. Przegląd
B.1.1. Pliki nagłówkowe
B.1.2. Przestrzeń nazw std
B.1.3. Styl opisu
B.2. Obsługa błędów
B.2.1. Wyjątki
B.3. Iteratory
B.3.1. Model iteratorów
B.3.2. Rodzaje iteratorów
B.4. Kontenery
B.4.1. Przegląd
B.4.2. Typy składowych
B.4.3. Konstruktory, destruktory i przypisania
B.4.4. Iteratory
B.4.5. Dostęp do elementów
B.4.6. Operacje stosów i kolejek
B.4.7. Operacje listowe
B.4.8. Rozmiar i pojemność
B.4.9. Inne operacje
B.4.10. Operacje kontenerów asocjacyjnych
B.5. Algorytmy
B.5.1. Algorytmy niemodyfikujące sekwencji
B.5.2. Algorytmy modyfikujące sekwencje
B.5.3. Algorytmy pomocnicze
B.5.4. Sortowanie i wyszukiwanie
B.5.5. Algorytmy działające na zbiorach
B.5.6. Sterty
B.5.7. Permutacje
B.5.8. Funkcje min() i max()
B.6. Biblioteka STL
B.6.1. Wstawianie
B.6.2. Obiekty funkcyjne
B.6.3. Typy pair i tuple
B.6.4. initializer_list
B.6.5. Wskaźniki do zarządzania zasobami
B.7. Strumienie wejścia i wyjścia
B.7.1. Hierarchia strumieni wejścia i wyjścia
B.7.2. Obsługa błędów
B.7.3. Operacje wejściowe
B.7.4. Operacje wyjściowe
B.7.5. Formatowanie
B.7.6. Standardowe manipulatory
B.8. Przetwarzanie łańcuchów
B.8.1. Klasyfikacja znaków
B.8.2. Łańcuchy
B.8.3. Dopasowywanie wyrażeń regularnych
B.9. Obliczenia
B.9.1. Limity typów liczbowych
B.9.2. Standardowe funkcje matematyczne
B.9.3. Liczby zespolone
B.9.4. Typ valarray
B.9.5. Ogólne algorytmy numeryczne
B.9.6. Liczby losowe
B.10. Czas
B.11. Funkcje biblioteki standardowej C
B.11.1. Pliki
B.11.2. Rodzina funkcji printf()
B.11.3. Łańcuchy w stylu języka C
B.11.4. Pamięć
B.11.5. Daty i czas
B.11.6. Pozostałe funkcje
B.12. Inne biblioteki

C. Podstawy środowiska Visual Studio
C.1. Uruchamianie programu
C.2. Instalowanie środowiska Visual Studio
C.3. Tworzenie i uruchamianie programu
C.3.1. Utwórz nowy projekt
C.3.2. Używanie pliku nagłówkowego std_lib_facilities.h
C.3.3. Dodaj plik źródłowy C++ do projektu
C.3.4. Wprowadź kod źródłowy
C.3.5. Budowanie programu wykonywalnego
C.3.6. Uruchamianie programu
C.3.7. Zapisywanie programu
C.4. Później

D. Instalowanie biblioteki FLTK
D.1. Wprowadzenie
D.2. Pobieranie biblioteki FLTK z internetu
D.3. Instalowanie biblioteki FLTK
D.4. Korzystanie z biblioteki FLTK w Visual Studio
D.5. Sprawdzanie, czy wszystko działa

E. Implementacja GUI
E.1. Implementacja wywołań zwrotnych
E.2. Implementacja klasy Widget
E.3. Implementacja klasy Window
E.4. Klasa Vector_ref
E.5. Przykład widgety

Słowniczek
Bibliografia

1088 stron, oprawa miękka

Po otrzymaniu zamówienia poinformujemy pocztą e-mail lub telefonicznie,
czy wybrany tytuł polskojęzyczny lub anglojęzyczny jest aktualnie na półce księgarni.

 
Wszelkie prawa zastrzeżone PROPRESS sp. z o.o. www.bankowa.pl 2000-2020