• 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
PP Przesyłka biznesowa pobranie (od 80 zł gratis) 0
Odbiór osobisty 0
PP Przesyłka biznesowa (od 80 zł gratis) 0
Paczkomaty InPost przelew (od 100 zł gratis) 0
Odbiór osobisty 0
Kurier przelew (od 200 zł gratis) 12
Kurier pobranie (od 200 zł gratis) 16
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

◦ 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





Nie ma jeszcze komentarzy ani ocen dla tego produktu.