• Kategorie
  • Programowanie . Teoria i praktyka z wykorzystaniem C++

Autor(zy) Bjarne Stroustrup
Miejsce wydania Gliwice
Rok 2020
Wydanie III
Ilość stron 1088
Format B5
Okładka miękka
Brak towaru
149.00 -10% 134.00
Wpisz swój e-mail
Wysyłka w ciągu 1-5 dni
Cena przesyłki 0
Poczta Polska (Pobranie) 0
Odbiór osobisty 0
Poczta Polska 0
Kurier (Pobranie) 20
Kurier 20
Dostępność 0 szt.
ISBN 978-83-283-6312-0.
EAN 9788328363120
Zostaw telefon

Programowanie . Teoria i praktyka z wykorzystaniem C++

Autor(zy): Bjarne Stroustrup.
ISBN: 978-83-283-6312-0.
Miejsce wydania: Gliwice
Rok wydania: 2020
Wydanie :III
Ilość stron: 1088
Format: B5
Okładka: miękka

Zaczerpnij wiedzę o C++ od samego twórcy języka!

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

Wykorzystaj wiedzę Bjarne Stroustrupa i pisz profesjonalne programy w C++!







Wstęp

oSłowo do studentów

oSłowo do nauczycieli

oStandard ISO C++

oPomoc

oPodziękowania

0. Uwagi do czytelnika

o0.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

o0.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ść

o0.3. Programowanie a informatyka

o0.4. Kreatywność i rozwiązywanie problemów

o0.5. Uwagi i komentarze czytelników

o0.6. Bibliografia

o0.7. Noty biograficzne

Bjarne Stroustrup

Lawrence Pete Petersen

1. Komputery, ludzie i programowanie

o1.1. Wstęp

o1.2. Oprogramowanie

o1.3. Ludzie

o1.4. Informatyka

o1.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

o1.6. Ideały dla programistów

oPowtórzenie

Część I. Podstawy

2. Witaj, świecie!

o2.1. Programy

o2.2. Klasyczny pierwszy program

o2.3. Kompilacja

o2.4. Łączenie

o2.5. Środowiska programistyczne

oĆwiczenia

3. Obiekty, typy i wartości

o3.1. Dane wejściowe

o3.2. Zmienne

o3.3. Typy danych wejściowych

o3.4. Operacje i operatory

o3.5. Przypisanie i inicjalizacja

3.5.1. Przykład wykrywania powtarzających się słów

o3.6. Złożone operatory przypisania

3.6.1. Przykład zliczania powtarzających się słów

o3.7. Nazwy

o3.8. Typy i obiekty

o3.9. Kontrola typów

3.9.1. Konwersje bezpieczne dla typów

3.9.2. Konwersje niebezpieczne dla typów

4. Wykonywanie obliczeń

o4.1. Wykonywanie obliczeń

o4.2. Cele i narzędzia

o4.3. Wyrażenia

4.3.1. Wyrażenia stałe

4.3.2. Operatory

4.3.3. Konwersje

o4.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

o4.5. Funkcje

4.5.1. Po co zaprzątać sobie głowę funkcjami

4.5.2. Deklarowanie funkcji

o4.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

o4.7. Właściwości języka

5. Błędy

o5.1. Wstęp

o5.2. Źródła błędów

o5.3. Błędy kompilacji

5.3.1. Błędy składni

5.3.2. Błędy typów

5.3.3. Niebłędy

o5.4. Błędy konsolidacji

o5.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

o5.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

o5.7. Błędy logiczne

o5.8. Szacowanie

o5.9. Debugowanie

5.9.1. Praktyczna rada dotycząca debugowania

o5.10. Warunki wstępne i końcowe

5.10.1. Warunki końcowe

o5.11. Testowanie

6. Pisanie programu

o6.1. Problem

o6.2. Przemyślenie problemu

6.2.1. Etapy rozwoju oprogramowania

6.2.2. Strategia

o6.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

o6.4. Gramatyki

6.4.1. Dygresja gramatyka języka angielskiego

6.4.2. Pisanie gramatyki

o6.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ń

o6.6. Wypróbowywanie pierwszej wersji

o6.7. Wypróbowywanie drugiej wersji

o6.8. Strumienie tokenów

6.8.1. Implementacja typu Token_stream

6.8.2. Wczytywanie tokenów

6.8.3. Wczytywanie liczb

o6.9. Struktura programu

7. Kończenie programu

o7.1. Wprowadzenie

o7.2. Wejście i wyjście

o7.3. Obsługa błędów

o7.4. Liczby ujemne

o7.5. Reszta z dzielenia

o7.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

o7.7. Odzyskiwanie sprawności po wystąpieniu błędu

o7.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.

o8.1. Szczegóły techniczne

o8.2. Deklaracje i definicje

8.2.1. Rodzaje deklaracji

8.2.2. Deklaracje stałych i zmiennych

8.2.3. Domyślna inicjalizacja

o8.3. Pliki nagłówkowe

o8.4. Zakres

o8.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

o8.6. Porządek wykonywania instrukcji

8.6.1. Wartościowanie wyrażeń

8.6.2. Globalna inicjalizacja

o8.7. Przestrzenie nazw

8.7.1. Dyrektywy i deklaracje using

9. Szczegóły techniczne klasy itp.

o9.1. Typy zdefiniowane przez użytkownika

o9.2. Klasy i składowe klas

o9.3. Interfejs i implementacja

o9.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

o9.5. Wyliczenia

9.5.1. Zwykłe wyliczenia

o9.6. Przeciążanie operatorów

o9.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

o9.8. Klasa Date

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

10. Strumienie wejścia i wyjścia

o10.1. Wejście i wyjście

o10.2. Model strumieni wejścia i wyjścia

o10.3. Pliki

o10.4. Otwieranie pliku

o10.5. Odczytywanie i zapisywanie plików

o10.6. Obsługa błędów wejścia i wyjścia

o10.7. Wczytywanie pojedynczej wartości

10.7.1. Rozłożenie problemu na mniejsze części

10.7.2. Oddzielenie warstwy komunikacyjnej od funkcji

o10.8. Definiowanie operatorów wyjściowych

o10.9. Definiowanie operatorów wejściowych

o10.10. Standardowa pętla wejściowa

o10.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

o11.1. Regularność i nieregularność

o11.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

o11.3. Otwieranie plików i pozycjonowanie

11.3.1. Tryby otwierania plików

11.3.2. Pliki binarne

11.3.3. Pozycjonowanie w plikach

o11.4. Strumienie łańcuchowe

o11.5. Wprowadzanie danych wierszami

o11.6. Klasyfikowanie znaków

o11.7. Stosowanie niestandardowych separatorów

o11.8. Zostało jeszcze tyle do poznania

12. Projektowanie klas graficznych

o12.1. Czemu grafika?

o12.2. Model graficzny

o12.3. Pierwszy przykład

o12.4. Biblioteka GUI

o12.5. Współrzędne

o12.6. Figury geometryczne

o12.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

o12.8. Uruchamianie programu

12.8.1. Pliki źródłowe

13. Klasy graficzne

o13.1. Przegląd klas graficznych

o13.2. Klasy Point i Line

o13.3. Klasa Lines

o13.4. Klasa Color

o13.5. Typ Line_style

o13.6. Typ Open_polyline

o13.7. Typ Closed_polyline

o13.8. Typ Polygon

o13.9. Typ Rectangle

o13.10. Wykorzystywanie obiektów bez nazw

o13.11. Typ Text

o13.12. Typ Circle

o13.13. Typ Ellipse

o13.14. Typ Marked_polyline

o13.15. Typ Marks

o13.16. Typ Mark

o13.17. Typ Image

14. Projektowanie klas graficznych

o14.1. Zasady projektowania

14.1.1. Typy

14.1.2. Operacje

14.1.3. Nazewnictwo

14.1.4. Zmienność

o14.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ść

o14.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

o14.4. Zalety programowania obiektowego

15. Graficzne przedstawienie funkcji i danych

o15.1. Wprowadzenie

o15.2. Rysowanie wykresów prostych funkcji

o15.3. Typ Function

15.3.1. Argumenty domyślne

15.3.2. Więcej przykładów

15.3.3. Wyrażenia lambda

o15.4. Typ Axis

o15.5. Wartość przybliżona funkcji wykładniczej

o15.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

o16.1. Różne rodzaje interfejsów użytkownika

o16.2. Przycisk Next

o16.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

o16.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

o16.5. Przykład

o16.6. Inwersja kontroli

o16.7. Dodawanie menu

o16.8. Debugowanie kodu GUI

Część III. Dane i algorytmy

17. Wektory i pamięć wolna

o17.1. Wprowadzenie

o17.2. Podstawowe wiadomości na temat typu vector

o17.3. Pamięć, adresy i wskaźniki

17.3.1. Operator sizeof

o17.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

o17.5. Destruktory

17.5.1. Generowanie destruktorów

17.5.2. Destruktory a pamięć wolna

o17.6. Dostęp do elementów

o17.7. Wskaźniki na obiekty klas

o17.8. Babranie się w typach void* i rzutowanie

o17.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

o17.10. Wskaźnik this

17.10.1. Więcej przykładów użycia typu Link

18. Wektory i tablice

o18.1. Wprowadzenie

o18.2. Inicjalizacja

o18.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

o18.4. Podstawowe operacje

18.4.1. Konstruktory jawne

18.4.2. Debugowanie konstruktorów i destruktorów

o18.5. Uzyskiwanie dostępu do elementów wektora

18.5.1. Problem stałych wektorów

o18.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

o18.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

o19.1. Analiza problemów

o19.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

o19.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

o19.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

o19.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

o20.1. Przechowywanie i przetwarzanie danych

20.1.1. Praca na danych

20.1.2. Uogólnianie kodu

o20.2. Ideały twórcy biblioteki STL

o20.3. Sekwencje i iteratory

20.3.1. Powrót do przykładu

o20.4. Listy powiązane

20.4.1. Operacje list

20.4.2. Iteracja

o20.5. Jeszcze raz uogólnianie wektora

20.5.1. Przeglądanie kontenera

20.5.2. Słowo kluczowe auto

o20.6. Przykład prosty edytor tekstu

20.6.1. Wiersze

20.6.2. Iteracja

o20.7. Typy vector, list oraz string

20.7.1. Funkcje insert() i erase()

o20.8. Dostosowanie wektora do biblioteki STL

o20.9. Dostosowywanie wbudowanych tablic do STL

o20.10. Przegląd kontenerów

20.10.1. Kategorie iteratorów

21. Algorytmy i słowniki

o21.1. Algorytmy biblioteki standardowej

o21.2. Najprostszy algorytm find()

21.2.1. Kilka przykładów z programowania ogólnego

o21.3. Ogólny algorytm wyszukiwania find_if()

o21.4. Obiekty funkcyjne

21.4.1. Abstrakcyjne spojrzenie na obiekty funkcyjne

21.4.2. Predykaty składowych klas

21.4.3. Wyrażenia lambda

o21.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()

o21.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

o21.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()

o21.8. Sortowanie i wyszukiwanie

o21.9. Algorytmy kontenerowe

Część IV. Poszerzanie horyzontów

22. Ideały i historia

o22.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

o22.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

o23.1. Tekst

o23.2. Łańcuchy

o23.3. Strumienie wejścia i wyjścia

o23.4. Słowniki

23.4.1. Szczegóły implementacyjne

o23.5. Problem

o23.6. Wyrażenia regularne

23.6.1. Surowe literały łańcuchowe

o23.7. Wyszukiwanie przy użyciu wyrażeń regularnych

o23.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

o23.9. Dopasowywanie przy użyciu wyrażeń regularnych

o23.10. Źródła

24. Działania na liczbach

o24.1. Wprowadzenie

o24.2. Rozmiar, precyzja i przekroczenie zakresu

24.2.1. Ograniczenia typów liczbowych

o24.3. Tablice

o24.4. Tablice wielowymiarowe w stylu języka C

o24.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

o24.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

o24.7. Liczby losowe

o24.8. Standardowe funkcje matematyczne

o24.9. Liczby zespolone

o24.10. Źródła

25. Programowanie systemów wbudowanych

o25.1. Systemy wbudowane

o25.2. Podstawy

25.2.1. Przewidywalność

25.2.2. Ideały

25.2.3. Życie z awarią

o25.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

o25.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

o25.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

o25.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

o26.1. Czego chcemy

26.1.1. Zastrzeżenie

o26.2. Dowody

o26.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ą

o26.4. Projektowanie pod kątem testowania

o26.5. Debugowanie

o26.6. Wydajność

26.6.1. Kontrolowanie czasu

o26.7. Źródła

27. Język C

o27.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

o27.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

o27.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

o27.4. Pamięć wolna

o27.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

o27.6. Wejście i wyjście nagłówek stdio

27.6.1. Wyjście

27.6.2. Wejście

27.6.3. Pliki

o27.7. Stałe i makra

o27.8. Makra

27.8.1. Makra podobne do funkcji

27.8.2. Makra składniowe

27.8.3. Kompilacja warunkowa

o27.9. Przykład kontenery intruzyjne

Dodatki

A. Zestawienie własności języka

oA.1. Opis ogólny

A.1.1. Terminologia

A.1.2. Uruchamianie i zamykanie programu

A.1.3. Komentarze

oA.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

oA.3. Identyfikatory

A.3.1. Słowa kluczowe

oA.4. Zakres, pamięć oraz czas trwania

A.4.1. Zakres

A.4.2. Rodzaje pamięci

A.4.3. Czas trwania

oA.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

oA.6. Instrukcje

oA.7. Deklaracje

A.7.1. Definicje

oA.8. Typy wbudowane

A.8.1. Wskaźniki

A.8.2. Tablice

A.8.3. Referencje

oA.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

oA.10. Typy zdefiniowane przez użytkownika

A.10.1. Przeciążanie operatorów

oA.11. Wyliczenia

oA.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

oA.13. Szablony

A.13.1. Argumenty szablonowe

A.13.2. Konkretyzacja szablonów

A.13.3. Typy składowe szablonów

oA.14. Wyjątki

oA.15. Przestrzenie nazw

oA.16. Aliasy

oA.17. Dyrektywy preprocesora

A.17.1. Dyrektywa #include

A.17.2. Dyrektywa #define

B. Biblioteka standardowa

oB.1. Przegląd

B.1.1. Pliki nagłówkowe

B.1.2. Przestrzeń nazw std

B.1.3. Styl opisu

oB.2. Obsługa błędów

B.2.1. Wyjątki

oB.3. Iteratory

B.3.1. Model iteratorów

B.3.2. Rodzaje iteratorów

oB.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

oB.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()

oB.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

oB.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

oB.8. Przetwarzanie łańcuchów

B.8.1. Klasyfikacja znaków

B.8.2. Łańcuchy

B.8.3. Dopasowywanie wyrażeń regularnych

oB.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

oB.10. Czas

oB.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

oB.12. Inne biblioteki

C. Podstawy środowiska Visual Studio

oC.1. Uruchamianie programu

oC.2. Instalowanie środowiska Visual Studio

oC.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

oC.4. Później

D. Instalowanie biblioteki FLTK

oD.1. Wprowadzenie

oD.2. Pobieranie biblioteki FLTK z internetu

oD.3. Instalowanie biblioteki FLTK

oD.4. Korzystanie z biblioteki FLTK w Visual Studio

oD.5. Sprawdzanie, czy wszystko działa

E. Implementacja GUI

oE.1. Implementacja wywołań zwrotnych

oE.2. Implementacja klasy Widget

oE.3. Implementacja klasy Window

oE.4. Klasa Vector_ref

oE.5. Przykład widgety

Słowniczek

Bibliografia



Nie ma jeszcze komentarzy ani ocen dla tego produktu.
  • Wydawcy