Programowanie. Teoria i praktyka z wykorzystaniem C++. Wydanie III (ebook)(audiobook)(audiobook)

Spis treści

• 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

pokaż cały spis treści

ukryj recenzje