Thinking in C Edycja polska thicpp, helion
[ Pobierz całość w formacie PDF ]
IDZ DO
Thinking in C++.
SPIS TRECI
Edycja polska
KATALOG KSI¥¯EK
Autor: Bruce Eckel
T³umaczenie: Piotr Imiela
ISBN: 83-7197-709-3
Tytu³ orygina³
Format: B5, stron: 642
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
DODAJ DO KOSZYKA
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 dowiadczenie 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 przeledzisz 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êtnoci na ka¿dym etapie nauki
•
kod ród³owy zawarty w ksi¹¿ce zgodnie z wieloma kompilorami (w tym
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWOCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
z darmowym kompilatorem GNU C++)
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treci
Wstp ............................................................................................. 13
Co nowego w drugim wydaniu?........................................................................................13
Zawarto drugiego tomu ksiki...............................................................................14
Skd wzi drugi tom ksiki? ...................................................................................14
Wymagania wstpne .........................................................................................................14
Nauka jzyka C++.............................................................................................................15
Cele....................................................................................................................................16
Zawarto rozdziałów .......................................................................................................17
*wiczenia..........................................................................................................................21
Rozwizania wicze...................................................................................................21
Kod 0ródłowy....................................................................................................................21
Standardy jzyka ...............................................................................................................22
Obsługa jzyka............................................................................................................23
Błdy .................................................................................................................................23
Okładka .............................................................................................................................24
Rozdział 1. Wprowadzenie do obiektów.............................................................. 25
Postp abstrakcji................................................................................................................26
Obiekt posiada interfejs.....................................................................................................27
Ukryta implementacja .......................................................................................................30
Wykorzystywanie istniejcej implementacji.....................................................................31
Dziedziczenie — wykorzystywanie istniejcego interfejsu..............................................32
Relacje typu „jest” i „jest podobny do”......................................................................35
Zastpowanie obiektówprzy uyciu polimorfizmu...........................................................36
Tworzenie i niszczenie obiektów......................................................................................40
Obsługa wyjtkó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 jdro ..............................................................................................52
Etap 4. Iteracje przez przypadki uycia......................................................................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 dziki szablonom .............................................61
Obsługa błdów ..........................................................................................................61
Programowanie na wielk skal..................................................................................61
Strategie przejcia .............................................................................................................62
Wskazówki..................................................................................................................62
Problemy z zarzdzaniem ...........................................................................................64
Podsumowanie ..................................................................................................................66
Rozdział 2. Tworzeniei uywanie obiektów.......................................................... 67
Proces tłumaczenia jzyka ................................................................................................68
Interpretery..................................................................................................................68
Kompilatory................................................................................................................68
Proces kompilacji........................................................................................................69
Narzdzia do rozłcznej kompilacji..................................................................................71
Deklaracje i definicje..................................................................................................71
Łczenie......................................................................................................................76
Uywanie bibliotek.....................................................................................................76
Twój pierwszy program w C++ ........................................................................................78
Uywanie klasy strumieni wejcia-wyjcia ................................................................78
Przestrzenie nazw........................................................................................................79
Podstawy struktury programu.....................................................................................80
„Witaj, wiecie!”.........................................................................................................81
Uruchamianie kompilatora..........................................................................................82
Wicej o strumieniach wejcia-wyjcia ............................................................................82
Łczenie tablic znakowych.........................................................................................83
Odczytywanie wejcia ................................................................................................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. Jzyk C w C++................................................................................. 95
Tworzenie funkcji .............................................................................................................95
Wartoci zwracane przez funkcje ...............................................................................97
Uywanie bibliotek funkcji jzyka C..........................................................................98
Tworzenie własnych bibliotekza pomoc programu zarzdzajcego 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
Uywanie i naduywanie instrukcji goto..................................................................105
Rekurencja ................................................................................................................106
Wprowadzenie do operatorów ........................................................................................107
Priorytety...................................................................................................................107
Automatyczna inkrementacja i dekrementacja.........................................................108
Spis treci
7
Wprowadzenie do typów danych....................................................................................108
Podstawowe typy wbudowane..................................................................................109
bool, true i false.........................................................................................................110
Specyfikatory............................................................................................................111
Wprowadzenie do wska0ników ................................................................................112
Modyfikacja obiektów zewntrznych.......................................................................115
Wprowadzenie do referencji.....................................................................................117
Wska0niki i referencje jako modyfikatory................................................................118
Zasig ..............................................................................................................................120
Definiowanie zmiennych „w locie”..........................................................................120
Specyfikacja przydziału pamici.....................................................................................122
Zmienne globalne......................................................................................................122
Zmienne lokalne........................................................................................................124
static..........................................................................................................................124
extern.........................................................................................................................126
Stałe...........................................................................................................................127
volatile.......................................................................................................................129
Operatory i ich uywanie ................................................................................................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
Najczstsze pułapkizwizane z uywaniem 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łoonych ...........................................................................................144
Nadawanie typom nowych nazw za pomoc typedef...............................................144
Łczenie zmiennych w struktury ..............................................................................145
Zwikszanie przejrzystoci programówza pomoc wylicze....................................148
Oszczdzanie pamici za pomoc unii .....................................................................150
Tablice.......................................................................................................................151
Wskazówki dotyczce uruchamiania programów...........................................................159
Znaczniki uruchomieniowe.......................................................................................160
Przekształcanie zmiennych i wyrae. w ła.cuchy...................................................162
Makroinstrukcja assert( ) jzyka C ...........................................................................162
Adresy funkcji.................................................................................................................163
Definicja wska0nika do funkcji ................................................................................163
Skomplikowane deklaracje i definicje......................................................................164
Wykorzystywanie wska0ników do funkcji...............................................................165
Tablice wska0ników do funkcji ................................................................................166
Make — zarzdzanie rozłczn kompilacj....................................................................167
Działanie programu make.........................................................................................168
Pliki makefile uywane w ksice............................................................................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ł pamici.................................................................................183
Błdne załoenia.......................................................................................................186
Na czym polega problem?...............................................................................................188
Podstawowy obiekt .........................................................................................................188
Czym s obiekty? ............................................................................................................194
Tworzenieabstrakcyjnych typów danych........................................................................195
Szczegóły dotyczce obiektów........................................................................................196
Zasady uywania 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
Zagniedone struktury...................................................................................................202
Zasig globalny.........................................................................................................206
Podsumowanie ................................................................................................................206
*wiczenia........................................................................................................................207
Rozdział 5. Ukrywanie implementacji ............................................................... 211
Okrelanie ogranicze......................................................................................................211
Kontrola dostpu w C++.................................................................................................212
Specyfikator protected ..............................................................................................214
Przyjaciele.......................................................................................................................214
Zagniedeni przyjaciele ..........................................................................................216
Czy jest to „czyste”?.................................................................................................218
Struktura pamici obiektów ............................................................................................219
Klasy................................................................................................................................219
Modyfikacja programu Stash, wykorzystujca kontrol dostpu.............................222
Modyfikacja stosu, wykorzystujca kontrol dostpu..............................................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 sprztanie....................................................................................232
Eliminacja bloku definicji...............................................................................................233
Ptle for.....................................................................................................................235
Przydzielanie pamici...............................................................................................236
Klasa Stash z konstruktorami i destruktorami.................................................................237
Klasa Stack z konstruktorami i destruktorami ................................................................240
Inicjalizacja agregatowa..................................................................................................242
Konstruktory domylne...................................................................................................245
Podsumowanie ................................................................................................................246
*wiczenia........................................................................................................................246
Rozdział 7. Przeci.anie nazw funkcji i argumenty domy2lne............................. 249
Dalsze uzupełnienia nazw...............................................................................................250
Przecianie na podstawie zwracanych wartoci......................................................251
Łczenie bezpieczne dla typów ................................................................................252
[ Pobierz całość w formacie PDF ]