Thinking_in_C_Edycja_polska_thicpp.pdf

(269 KB) Pobierz
IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
Thinking in C++.
Edycja polska
Autor: Bruce Eckel
T³umaczenie: Piotr Imiela
ISBN: 83-7197-709-3
Tytu³ orygina³u:
Thinking in C++
Format: B5, stron: 642
Przyk³ady na ftp: 247 kB
TWÓJ KOSZYK
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
ZAMÓW CENNIK
C++ to jeden z najpopularniejszych jêzyków programowania, w którym napisano szereg
profesjonalnych aplikacji, a nawet kilka systemów operacyjnych. Nie bez przyczyny
uwa¿any jest on za trudny do opanowana, stanowi¹c powa¿ne wyzwanie zarówno dla
programistów, jak dla autorów podrêczników.
Wieloletnie do wiadczenie w nauczaniu programowania Bruce'a Eckela gwarantuje,
¿e po przeczytaniu tej ksi¹¿ki bêdziesz pos³ugiwa³ siê C++ tak sprawnie, jak jêzykiem
polskim. Bruce Eckel to nie tylko autor bestsellerowych podrêczników takich jak:
Thinking in Java, ale równie¿ cz³onek komitetu standaryzuj¹cego C++ i szef firmy
zajmuj¹cy siê szkoleniem programistów. Tworzone przez niego kursy programowania
uznawane s¹ za jedne z najlepszych na wiecie.
•
•
•
•
•
•
poznasz podstawowe i zaawansowane techniki programowania w C++
krok po kroku prze ledzisz konstrukcjê jêzyka
nauczysz siê diagnozowaæ i rozwi¹zywaæ problemy w C++
zwiêz³e, ³atwe do zrozumienia przyk³ady zilustruj¹ przedstawiane zagadnienia
æwiczenia utrwal¹ zdobyte umiejêtno ci na ka¿dym etapie nauki
kod ród³owy zawarty w ksi¹¿ce zgodnie z wieloma kompilorami (w tym
z darmowym kompilatorem GNU C++)
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treści
Wstęp ............................................................................................. 13
Co nowego w drugim wydaniu?........................................................................................13
Zawartość drugiego tomu ksią ki ...............................................................................14
Skąd wziąć drugi tom ksią ki? ...................................................................................14
Wymagania wstępne .........................................................................................................14
Nauka języka C++.............................................................................................................15
Cele....................................................................................................................................16
Zawartość rozdziałów .......................................................................................................17
Ćwiczenia ..........................................................................................................................21
Rozwiązania ćwiczeń..................................................................................................21
Kod źródłowy....................................................................................................................21
Standardy języka ...............................................................................................................22
Obsługa języka............................................................................................................23
Błędy .................................................................................................................................23
Okładka .............................................................................................................................24
Rozdział 1. Wprowadzenie do obiektów .............................................................. 25
Postęp abstrakcji................................................................................................................26
Obiekt posiada interfejs.....................................................................................................27
Ukryta implementacja .......................................................................................................30
Wykorzystywanie istniejącej implementacji.....................................................................31
Dziedziczenie — wykorzystywanie istniejącego interfejsu..............................................32
Relacje typu „jest” i „jest podobny do” ......................................................................35
Zastępowanie obiektówprzy u yciu polimorfizmu ...........................................................36
Tworzenie i niszczenie obiektów ......................................................................................40
Obsługa wyjątków — sposób traktowania błędów ...........................................................41
Analiza i projektowanie ....................................................................................................42
Etap 0. Przygotuj plan.................................................................................................44
Etap 1. Co tworzymy?.................................................................................................45
Etap 2. Jak to zrobimy?...............................................................................................49
Etap 3. Budujemy jądro ..............................................................................................52
Etap 4. Iteracje przez przypadki u ycia ......................................................................53
Etap 5. Ewolucja .........................................................................................................53
Planowanie się opłaca .................................................................................................55
Programowanie ekstremalne .............................................................................................55
Najpierw napisz testy..................................................................................................56
Programowanie w parach............................................................................................57
Dlaczego C++ odnosi sukcesy? ........................................................................................58
Lepsze C......................................................................................................................59
Zacząłeś się ju uczyć.................................................................................................59
6
Thinking in C++. Edycja polska
Efektywność................................................................................................................60
Systemy są łatwiejsze do opisania i do zrozumienia ..................................................60
Maksymalne wykorzystanie bibliotek ........................................................................60
Wielokrotne wykorzystywanie kodu dzięki szablonom .............................................61
Obsługa błędów ..........................................................................................................61
Programowanie na wielką skalę..................................................................................61
Strategie przejścia .............................................................................................................62
Wskazówki..................................................................................................................62
Problemy z zarządzaniem ...........................................................................................64
Podsumowanie ..................................................................................................................66
Rozdział 2. Tworzeniei używanie obiektów.......................................................... 67
Proces tłumaczenia języka ................................................................................................68
Interpretery..................................................................................................................68
Kompilatory ................................................................................................................68
Proces kompilacji........................................................................................................69
Narzędzia do rozłącznej kompilacji ..................................................................................71
Deklaracje i definicje ..................................................................................................71
Łączenie ......................................................................................................................76
U ywanie bibliotek .....................................................................................................76
Twój pierwszy program w C++ ........................................................................................78
U ywanie klasy strumieni wejścia-wyjścia ................................................................78
Przestrzenie nazw........................................................................................................79
Podstawy struktury programu .....................................................................................80
„Witaj, świecie!”.........................................................................................................81
Uruchamianie kompilatora..........................................................................................82
Więcej o strumieniach wejścia-wyjścia ............................................................................82
Łączenie tablic znakowych .........................................................................................83
Odczytywanie wejścia ................................................................................................84
Wywoływanie innych programów..............................................................................84
Wprowadzenie do łańcuchów ...........................................................................................85
Odczytywanie i zapisywanie plików.................................................................................86
Wprowadzenie do wektorów.............................................................................................88
Podsumowanie ..................................................................................................................92
Ćwiczenia ..........................................................................................................................93
Rozdział 3. Język C w C++................................................................................. 95
Tworzenie funkcji .............................................................................................................95
Wartości zwracane przez funkcje ...............................................................................97
U ywanie bibliotek funkcji języka C..........................................................................98
Tworzenie własnych bibliotekza pomocą programu zarządzającego bibliotekami....99
Sterowanie wykonywaniem programu..............................................................................99
Prawda i fałsz..............................................................................................................99
if-else.........................................................................................................................100
while..........................................................................................................................101
do-while ....................................................................................................................101
for..............................................................................................................................102
Słowa kluczowe break i continue .............................................................................103
switch ........................................................................................................................104
U ywanie i nadu ywanie instrukcji goto..................................................................105
Rekurencja ................................................................................................................106
Wprowadzenie do operatorów ........................................................................................107
Priorytety...................................................................................................................107
Automatyczna inkrementacja i dekrementacja .........................................................108
Spis treści
7
Wprowadzenie do typów danych ....................................................................................108
Podstawowe typy wbudowane..................................................................................109
bool, true i false.........................................................................................................110
Specyfikatory ............................................................................................................111
Wprowadzenie do wskaźników ................................................................................112
Modyfikacja obiektów zewnętrznych .......................................................................115
Wprowadzenie do referencji .....................................................................................117
Wskaźniki i referencje jako modyfikatory................................................................118
Zasięg ..............................................................................................................................120
Definiowanie zmiennych „w locie” ..........................................................................120
Specyfikacja przydziału pamięci.....................................................................................122
Zmienne globalne......................................................................................................122
Zmienne lokalne........................................................................................................124
static ..........................................................................................................................124
extern.........................................................................................................................126
Stałe...........................................................................................................................127
volatile.......................................................................................................................129
Operatory i ich u ywanie ................................................................................................129
Przypisanie................................................................................................................130
Operatory matematyczne ..........................................................................................130
Operatory relacji .......................................................................................................131
Operatory logiczne....................................................................................................131
Operatory bitowe ......................................................................................................132
Operatory przesunięć ................................................................................................133
Operatory jednoargumentowe...................................................................................135
Operator trójargumentowy........................................................................................136
Operator przecinkowy...............................................................................................137
Najczęstsze pułapkizwiązane z u ywaniem operatorów ..........................................137
Operatory rzutowania................................................................................................138
Jawne rzutowanie w C++..........................................................................................139
sizeof — samotny operator .......................................................................................143
Słowo kluczowe asm.................................................................................................143
Operatory dosłowne ..................................................................................................144
Tworzenie typów zło onych ...........................................................................................144
Nadawanie typom nowych nazw za pomocą typedef ...............................................144
Łączenie zmiennych w struktury ..............................................................................145
Zwiększanie przejrzystości programówza pomocą wyliczeń ...................................148
Oszczędzanie pamięci za pomocą unii .....................................................................150
Tablice.......................................................................................................................151
Wskazówki dotyczące uruchamiania programów...........................................................159
Znaczniki uruchomieniowe.......................................................................................160
Przekształcanie zmiennych i wyra eń w łańcuchy ...................................................162
Makroinstrukcja assert( ) języka C ...........................................................................162
Adresy funkcji .................................................................................................................163
Definicja wskaźnika do funkcji ................................................................................163
Skomplikowane deklaracje i definicje ......................................................................164
Wykorzystywanie wskaźników do funkcji ...............................................................165
Tablice wskaźników do funkcji ................................................................................166
Make — zarządzanie rozłączną kompilacją....................................................................167
Działanie programu make .........................................................................................168
Pliki makefile u ywane w ksią ce ............................................................................171
Przykładowy plik makefile .......................................................................................171
Podsumowanie ................................................................................................................173
Ćwiczenia ........................................................................................................................173
8
Thinking in C++. Edycja polska
Rozdział 4. Abstrakcja danych ......................................................................... 179
Miniaturowa biblioteka w stylu C...................................................................................180
Dynamiczny przydział pamięci.................................................................................183
Błędne zało enia .......................................................................................................186
Na czym polega problem?...............................................................................................188
Podstawowy obiekt .........................................................................................................188
Czym są obiekty? ............................................................................................................194
Tworzenieabstrakcyjnych typów danych ........................................................................195
Szczegóły dotyczące obiektów........................................................................................196
Zasady u ywania plików nagłówkowych .........................................................................197
Znaczenie plików nagłówkowych.............................................................................198
Problem wielokrotnych deklaracji ............................................................................199
Dyrektywy preprocesora #define, #ifdef i #endif .....................................................200
Standard plików nagłówkowych...............................................................................201
Przestrzenie nazw w plikach nagłówkowych ...........................................................202
Wykorzystywanie plików nagłówkowych w projektach ............................................202
Zagnie d one struktury ...................................................................................................202
Zasięg globalny.........................................................................................................206
Podsumowanie ................................................................................................................206
Ćwiczenia ........................................................................................................................207
Rozdział 5. Ukrywanie implementacji ............................................................... 211
Określanie ograniczeń .....................................................................................................211
Kontrola dostępu w C++ .................................................................................................212
Specyfikator protected ..............................................................................................214
Przyjaciele .......................................................................................................................214
Zagnie d eni przyjaciele ..........................................................................................216
Czy jest to „czyste”? .................................................................................................218
Struktura pamięci obiektów ............................................................................................219
Klasy................................................................................................................................219
Modyfikacja programu Stash, wykorzystująca kontrolę dostępu .............................222
Modyfikacja stosu, wykorzystująca kontrolę dostępu ..............................................223
Klasy-uchwyty ................................................................................................................223
Ukrywanie implementacji.........................................................................................224
Ograniczanie powtórnych kompilacji .......................................................................224
Podsumowanie ................................................................................................................226
Ćwiczenia ........................................................................................................................227
Rozdział 6. Inicjalizacjai końcowe porządki ...................................................... 229
Konstruktor gwarantuje inicjalizację ..............................................................................230
Destruktor gwarantuje sprzątanie....................................................................................232
Eliminacja bloku definicji ...............................................................................................233
Pętle for.....................................................................................................................235
Przydzielanie pamięci ...............................................................................................236
Klasa Stash z konstruktorami i destruktorami.................................................................237
Klasa Stack z konstruktorami i destruktorami ................................................................240
Inicjalizacja agregatowa..................................................................................................242
Konstruktory domyślne ...................................................................................................245
Podsumowanie ................................................................................................................246
Ćwiczenia ........................................................................................................................246
Rozdział 7. Przeciążanie nazw funkcji i argumenty domyślne............................. 249
Dalsze uzupełnienia nazw ...............................................................................................250
Przecią anie na podstawie zwracanych wartości......................................................251
Łączenie bezpieczne dla typów ................................................................................252

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin