'Opus magnum C++ 11. Programowanie w języku C++. Wydanie II poprawione' – zestaw obejmuje 3 tomy.Jedno C i same plusy!
Dawno, dawno temu, w głębokich latach osiemdziesiątych ubiegłego wieku pewien duński informatyk zainspirowany językiem C opracował jeden z najważniejszych, najbardziej elastycznych i do dziś niezastąpionych języków programowania - C++ . Dziś ten język jest wykorzystywany do tworzenia gier komputerowych, obliczeń naukowych, technicznych, w medycynie, przemyśle i bankowości. NASA posługuje się nim w naziemnej kontroli lotów. Duża część oprogramowania Międzynarodowej Stacji Kosmicznej została napisana w tym języku. Nawet w marsjańskim łaziku Curiosity pracuje program w C++, który analizuje obraz z kamer i planuje dalszą trasę.
Autor tej książki - wybitny specjalista pracujący nad wieloma znaczącymi projektami we francuskich, niemieckich i włoskich instytutach fizyki jądrowej, znany czytelnikom m.in. z genialnej Symfonii C++ - postawił sobie za cel napisanie nowej, przekrojowej książki o tym języku, która w prostym, wręcz przyjacielskim stylu wprowadza czytelnika w fascynujący świat programowania zorientowanego obiektowo. Zobacz, jak potężny jest dzisiaj C++ 11.
Jeżeli chcesz nauczyć się tego języka w łatwy, pogodny, przyjazny sposób, ta książka jest właśnie dla Ciebie.
Dzięki tej książce poznasz:
Proste i złożone typy danych
Instrukcje sterujące
Funkcje i operatory
Wskaźniki
Klasy i dziedziczenie
Obsługę wyjątków
Wyrażenia lambda
Operacje wejścia-wyjścia
Projektowanie orientowane obiektowo
Szablony
Znajdź podobne książki Ostatnio czytane w tej kategorii
Darmowy fragment publikacji:
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości
lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione.
Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie
książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie
praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi
bądź towarowymi ich właścicieli.
Autor oraz Helion SA dołożyli wszelkich starań, by zawarte w tej książce
informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności
ani za ich wykorzystanie, aniza związane z tym ewentualne naruszenie praw
patentowych lub autorskich. Autor oraz Helion SA nie ponoszą również
żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania
informacji zawartych w książce.
Redaktor prowadzący: Małgorzata Kulik
Projekt okładki i opracowanie graficzne książki: Jerzy Grębosz
Zdjęcie Mgławicy Orzeł w grafice na okładce oraz zdjęcia łazika Curiosity
i powierzchni Marsa – wykorzystane w tytułach rozdziałów – dzięki
uprzejmości NASA.
Wydanie drugie
ISBN: 978-83-283-6965-8
Copyright © Jerzy Grębosz 2020
Printed in Poland
Helion SA
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/ocpp12
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Kody źródłowe wybranych przykładów dostępne są pod adresem:
ftp://ftp.helion.pl/przyklady/ocpp12.zip
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis treœci trzech tomów
V
Spis treœci trzech tomów
0 Proszê tego nie czytaæ!........................................................................1
0.1
ZaprzyjaŸnijmy siê! ..............................................................................................................1
1 Startujemy!............................................................................................8
Pierwszy program.................................................................................................................8
1.1
Drugi program ....................................................................................................................13
1.2
1.3
Æwiczenia ...........................................................................................................................18
2 Instrukcje steruj¹ce............................................................................20
Prawda – fa³sz, czyli o warunkach .....................................................................................20
2.1
2.1.1
Wyra¿enie logiczne.........................................................................................................20
Zmienna logiczna bool w roli warunku............................................................................21
2.1.2
Stare dobre sposoby z dawnego C++ ..............................................................................21
2.1.3
Instrukcja warunkowa if......................................................................................................22
2.2
Pêtla while............................................................................................................................26
2.3
Pêtla do...while... ..................................................................................................................27
2.4
Pêtla for ...............................................................................................................................28
2.5
Instrukcja switch ..................................................................................................................31
2.6
Co wybraæ: switch czy if...else?............................................................................................33
2.7
Instrukcja break...................................................................................................................36
2.8
Instrukcja goto.....................................................................................................................37
2.9
Instrukcja continue...............................................................................................................39
2.10
Klamry w instrukcjach steruj¹cych.....................................................................................40
2.11
2.12
Æwiczenia ...........................................................................................................................41
3 Typy .....................................................................................................44
Deklaracje typu...................................................................................................................44
3.1
Systematyka typów z jêzyka C++ ......................................................................................45
3.2
3.3
Typy fundamentalne...........................................................................................................46
Typy przeznaczone do pracy z liczbami ca³kowitymi.....................................................46
3.3.1
Typy do przechowywania znaków alfanumerycznych....................................................47
3.3.2
Typy reprezentuj¹ce liczby zmiennoprzecinkowe ..........................................................47
3.3.3
bool – typ do reprezentacji obiektów logicznych............................................................48
3.3.4
3.3.5
Kwestia dok³adnoœci .......................................................................................................49
Jak poznaæ limity (ograniczenia) typów wbudowanych..................................................51
3.3.6
3.4
Typy o precyzyjnie ¿¹danej szerokoœci ..............................................................................55
Poleć książkęKup książkę VI
3.5
3.6
3.7
3.7.1
3.7.2
3.7.3
3.7.4
3.7.5
3.7.6
3.7.7
3.8
3.9
3.10
3.10.1
3.10.2
3.10.3
3.10.4
3.10.5
3.10.6
3.11
3.12
3.13
3.14
3.15
3.16
3.17
3.17.1
3.17.2
3.18
3.19
3.20
3.21
3.22
Spis treœci trzech tomów
InicjaLIZAcja, czyli nadanie wartoœci w momencie narodzin............................................59
Definiowanie obiektów „w biegu” .....................................................................................60
Sta³e dos³owne....................................................................................................................62
Sta³e dos³owne typu bool .................................................................................................63
Sta³e bêd¹ce liczbami ca³kowitymi .................................................................................63
Sta³e reprezentuj¹ce liczby zmiennoprzecinkowe ...........................................................66
Sta³a dos³owna nullptr – dla wskaŸników.........................................................................67
Sta³e znakowe .................................................................................................................68
Sta³e tekstowe, napisy, albo po prostu stringi .................................................................71
Surowe sta³e tekstowe (napisy, stringi)...........................................................................73
Typy z³o¿one ......................................................................................................................76
Typ void ..............................................................................................................................77
Zakres wa¿noœci nazwy obiektu a czas ¿ycia obiektu ........................................................78
Zakres: lokalny ...............................................................................................................78
Zakres: instrukcja ............................................................................................................79
Zakres: blok funkcji ........................................................................................................79
Zakres: obszar pliku ........................................................................................................80
Zakres: obszar klasy........................................................................................................80
Zakres okreœlony przez przestrzeñ nazw .........................................................................80
Zas³anianie nazw ................................................................................................................85
Specyfikator (przydomek) const .........................................................................................87
Specyfikator (przydomek) constexpr ...................................................................................88
Obiekty register ...................................................................................................................92
Specyfikator volatile ............................................................................................................92
using oraz typedef – tworzenie dodatkowej nazwy typu ......................................................93
Typy wyliczeniowe enum ...................................................................................................96
Dawne zwyk³e enum a nowe zakresowe enum class ......................................................103
Kilka uwag dla wtajemniczonych .................................................................................105
auto, czyli automatyczne rozpoznawanie typu definiowanego obiektu ............................106
decltype – operator do okreœlania typu zadanego wyra¿enia .............................................109
Inicjalizacja z pust¹ klamr¹ { }, czyli wartoœci¹ domnieman¹ .........................................111
Przydomek alignas – adresy równe i równiejsze ...............................................................113
Æwiczenia .........................................................................................................................115
4 Ope ra tory ..........................................................................................119
Operatory arytmetyczne ...................................................................................................119
4.1
Ope ra to r , czyli reszta z dzielenia (modulo) ..............................................................120
4.1.1
4.1.2
Jednoargumentowe ope ra tory + i – ...............................................................................121
Ope ra tory inkrementacji i dekrementacji ......................................................................121
4.1.3
Ope ra to r przypisania = ..................................................................................................123
4.1.4
Operatory logiczne ...........................................................................................................124
4.2
Ope ra tory relacji ...........................................................................................................124
4.2.1
4.2.2
Ope ra tory sumy logicznej || oraz iloczynu logicznego ...........................................125
Wykrzyknik !, czyli ope ra to r negacji ............................................................................126
4.2.3
Operatory bitowe..............................................................................................................127
4.3
Przesuniêcie w lewo ...............................................................................................128
4.3.1
Przesuniêcie w prawo ..............................................................................................129
4.3.2
4.3.3
Bitowe ope ra tory sumy, iloczynu, negacji, ró¿nicy symetrycznej ................................130
Ró¿nica miêdzy operatorami logicznymi a operatorami bitowymi ..................................130
4.4
Pozosta³e operatory przypisania .......................................................................................132
4.5
Operator uzyskiwania adresu (operator )........................................................................133
4.6
Wyra¿enie warunkowe .....................................................................................................134
4.7
Operator sizeof ..................................................................................................................135
4.8
Operator noexcept..............................................................................................................137
4.9
Deklaracja static_assert .....................................................................................................137
4.10
Poleć książkęKup książkę Spis treœci trzech tomów
VII
4.11
4.12
4.12.1
4.12.2
4.12.3
4.12.4
4.12.5
4.12.6
4.13
4.14
4.15
4.16
Operator alignof informuj¹cy o najkorzystniejszym wyrównaniu adresu..........................139
Operatory rzutowania .......................................................................................................141
Rzutowanie wed³ug tradycyjnych (niezalecanych) sposobów ......................................141
Rzutowanie za pomoc¹ nowych operatorów rzutowania ..............................................142
Ope ra to r static_cast ........................................................................................................143
Ope ra to r const_cast........................................................................................................145
Ope ra to r dynamic_cast ...................................................................................................146
Ope ra to r reinterpret_cast.................................................................................................147
Operator: przecinek ..........................................................................................................148
Priorytety operatorów.......................................................................................................148
£¹cznoœæ operatorów........................................................................................................151
Æwiczenia .........................................................................................................................152
5 Typ string i typ vec tor – pierwsza wzmianka ......................................156
Typ std::string do pracy z tekstami ....................................................................................156
5.1
Typ vector – d³ugi rz¹d obiektów......................................................................................161
5.2
Zakresowe for....................................................................................................................169
5.3
5.4
Æwiczenia .........................................................................................................................172
6 Funkcje ..............................................................................................174
Definicja funkcji i jej wywo³anie .....................................................................................174
6.1
Deklaracja funkcji ............................................................................................................175
6.2
6.3
Funkcja czêsto wywo³uje inn¹ funkcjê.............................................................................177
Zwracanie przez funkcjê rezultatu....................................................................................177
6.4
Obie k t tworzony za pomoc¹ auto, a ini cja li zo wany rezultatem funkcji ........................179
6.4.1
O zwracaniu (lub niezwracaniu) rezultatu przez funkcjê main ......................................180
6.4.2
Nowy, alternatywny sposób deklaracji funkcji.................................................................181
6.5
6.6
Stos ...................................................................................................................................183
Przesy³anie argumentów do funkcji przez wartoœæ...........................................................184
6.7
Przesy³anie argumentów przez referencjê.........................................................................185
6.8
Po¿yteczne okreœlenia: l-wartoœæ i r-wartoœæ....................................................................188
6.9
Referencje do l-wartoœci i referencje do r-wartoœci jako argumenty funkcji ....................190
6.10
6.10.1
Który sposób przesy³ania argu men tu do funkcji wybraæ?.............................................197
Kiedy deklaracja funkcji nie jest konieczna? ...................................................................198
6.11
Argumenty domniemane ..................................................................................................199
6.12
Ciekawostki na temat argumentów domniemanych......................................................202
6.12.1
6.13
Nienazwany argument ......................................................................................................207
Funkcje inline (w linii).......................................................................................................208
6.14
6.15
Przypomnienie o zakresie wa¿noœci nazw deklarowanych wewn¹trz funkcji ..................212
6.16 Wybór zakresu wa¿noœci nazwy i czasu ¿ycia obiektu.....................................................212
Obiekty globalne ..........................................................................................................212
6.16.1
6.16.2
Obiekty automatyczne...................................................................................................213
Obiekty lokalne statyczne .............................................................................................214
6.16.3
Funkcje w programie sk³adaj¹cym siê z kilku plików......................................................218
6.17
Nazwy statyczne globalne.............................................................................................222
6.17.1
Funkcja zwracaj¹ca rezultat bêd¹cy referencj¹ l-wartoœci ................................................223
6.18
6.19
Funkcje rekurencyjne .......................................................................................................228
Funkcje biblioteczne.........................................................................................................237
6.20
Funkcje constexpr..............................................................................................................240
6.21
6.21.1 Wymogi, które musi spe³niaæ funkcja constexpr (w standardzie C++11) ......................242
Przyk³ad poka zu j¹cy aspekty funkcji constexpr.............................................................243
6.21.2
Argu men ty funkcji constexpr bêd¹ce referencjami ........................................................252
6.21.3
Definiowanie referencji przy u¿yciu s³owa auto ...............................................................253
6.22
6.22.1
Gdy inicjalizatorem jest wywo³anie funkcji zwracaj¹cej referencjê..............................260
Poleć książkęKup książkę VIII
Spis treœci trzech tomów
6.23
Æwiczenia .........................................................................................................................263
7 Preprocesor ......................................................................................269
Dyrektywa pusta # ............................................................................................................269
7.1
Dyrektywa #define.............................................................................................................269
7.2
Dyrektywa #undef .............................................................................................................271
7.3
Makrodefinicje .................................................................................................................272
7.4
Sklejacz nazw argumentów, czyli operator ## .................................................................274
7.5
7.6
Parametr aktualny makrodefinicji – w postaci tekstu .......................................................275
Dyrektywy kompilacji warunkowej .................................................................................275
7.7
Dyrektywa #error ..............................................................................................................279
7.8
Dyrektywa #line ................................................................................................................280
7.9
7.10 Wstawianie treœci innych plików do tekstu kompilowanego w³aœnie pliku .....................280
7.11
Dyrektywy zale¿ne od implementacji ..............................................................................282
Nazwy predefiniowane .....................................................................................................282
7.12
7.13
Æwiczenia .........................................................................................................................285
8 Tablice ...............................................................................................288
Co to jest tablica ...............................................................................................................288
8.1
Elementy tablicy...............................................................................................................289
8.2
Inicjalizacja tablic.............................................................................................................291
8.3
Przekazywanie tablicy do funkcji.....................................................................................292
8.4
Przyk³ad z tablic¹ elementów typu enum..........................................................................296
8.5
Tablice znakowe...............................................................................................................298
8.6
8.7
Æwiczenia .........................................................................................................................306
9 Tablice wielowymiarowe..................................................................311
Tablica tablic ....................................................................................................................311
9.1
Przyk³ad programu pracuj¹cego z tablic¹ dwuwymiarow¹ ..............................................313
9.2
Gdzie w pamiêci jest dany element tablicy.......................................................................315
9.3
Typ wyra¿eñ zwi¹zanych z tablic¹ wielowymiarow¹.......................................................315
9.4
9.5
Przesy³anie tablic wielowymiarowych do funkcji ............................................................317
Æwiczenia .........................................................................................................................319
9.6
10 Wektory wielowymiarowe................................................................321
Najpierw przypomnienie istotnych tu cech klasy vector ...................................................321
10.1
Jak za pomoc¹ klasy vector budowaæ tablice wielowymiarowe ........................................322
10.2
Funkcja pokazuj¹ca zawartoœæ wektora dwuwymiarowego .............................................323
10.3
Definicja dwuwymiarowego wektora – pustego ..............................................................325
10.4
10.5
Definicja wektora dwuwymiarowego z list¹ inicjalizatorów............................................326
10.6 Wektor dwuwymiarowy o ¿¹danych rozmiarach, choæ bez inicjalizacji ..........................327
Zmiana rozmiaru wektora 2D funkcj¹ resize ....................................................................328
10.7
Zmiany rozmiaru wektora 2D funkcjami push_back, pop_back.........................................329
10.8
Zmniejszanie rozmiaru wektora dwuwymiarowego funkcj¹ pop_back .............................332
10.9
10.10
Funkcje mog¹ce modyfikowaæ treœæ wektora 2D.............................................................332
10.11 Wys³anie rzêdu wektora 2D do funkcji pracuj¹cej z wektorem 1D..................................334
10.12 Ca³oœæ przyk³adu definiuj¹cego wektory dwuwymiarowe ...............................................335
10.13
Po co s¹ dwuwymiarowe wektory nieprostok¹tne............................................................335
10.14 Wektory trójwymiarowe...................................................................................................337
10.15
Sposoby definicji wektora 3D o ustalonych rozmiarach ..................................................340
10.16 Nadawanie pustemu wektorowi 3D wymaganych rozmiarów..........................................344
Zmiana rozmiarów wektora 3D funkcjami resize..........................................................344
10.16.1
Poleć książkęKup książkę Spis treœci trzech tomów
IX
Zmiana rozmiarów wektora 3D funkcjami push_back...................................................346
10.16.2
10.17 Trójwymiarowe wektory 3D – nieprostopad³oœcienne .....................................................347
10.18 Æwiczenia .........................................................................................................................351
11 WskaŸniki – wiadomoœci wstêpne..................................................353
11.1 WskaŸniki mog¹ bardzo u³atwiæ ¿ycie .............................................................................353
Definiowanie wskaŸników ...............................................................................................355
11.2
Praca ze wskaŸnikiem.......................................................................................................356
11.3
Definiowanie wskaŸnika z u¿yciem auto ..........................................................................359
11.4
11.5 Wyra¿enie *wskaŸnik jest l-wartoœci¹ ................................................................................360
Operator rzutowania reinterpret_cast a wskaŸniki..............................................................360
11.6
11.7 WskaŸniki typu void*.........................................................................................................363
11.8
Strza³ na oœlep – wskaŸnik zawsze na coœ wskazuje.........................................................365
11.8.1 WskaŸnik wolno porównaæ z adresem zero – nullptr .....................................................367
Æwiczenia .........................................................................................................................367
11.9
12 Cztery domeny zastosowania wskaŸników ...................................369
12.1
Zastosowanie wskaŸników wobec tablic ..........................................................................369
Æwiczenia z mechaniki ruchu wskaŸnika......................................................................369
12.1.1
U¿ycie wskaŸnika w pracy z tablic¹..............................................................................373
12.1.2
Arytmetyka wskaŸników...............................................................................................377
12.1.3
Porównywanie wskaŸników..........................................................................................379
12.1.4
12.2
Zastosowanie wskaŸników w argumentach funkcji..........................................................380
Jeszcze raz o przesy³aniu tablic do funkcji....................................................................384
12.2.1
Odbieranie tablicy jako wskaŸnika................................................................................384
12.2.2
Argu men t formalny bêd¹cy wskaŸnikiem do obiektu const ..........................................386
12.2.3
Zastosowanie wskaŸników przy dostêpie do konkretnych komórek pamiêci...................389
12.3
12.4
Rezerwacja obszarów pamiêci..........................................................................................390
Ope ra tory new i de lete albo Oratorium Stworzenie Œwiata............................................391
12.4.1
Ope ra to r new a s³owo kluczowe auto.............................................................................395
12.4.2
Ini cja li za cja obiektu tworzonego ope ra torem new.........................................................395
12.4.3
Ope ra torem new mo¿emy tak¿e tworzyæ obiekty sta³e..................................................396
12.4.4
12.4.5
Dynamiczna alokacja tablicy.........................................................................................397
Tablice wielowymiarowe tworzone ope ra torem new ....................................................398
12.4.6
Umiejscawiaj¹cy ope ra to r new ......................................................................................401
12.4.7
„Przychodzimy, odchodzimy – cichuteñko, na...” ........................................................406
12.4.8
12.4.9
Zapas pamiêci to nie studnia bez dna ...........................................................................408
12.4.10 Nowy sposób powiadomienia: rzucenie wyj¹tku std::bad_alloc.....................................409
Funkcja set_new_han dler................................................................................................411
12.4.11
12.5
Æwiczenia .........................................................................................................................413
13 WskaŸniki – runda trzecia................................................................417
Sta³e wskaŸniki.................................................................................................................417
13.1
13.2
Sta³e wskaŸniki a wskaŸniki do sta³ych............................................................................418
13.2.1 Wierzch i g³êbia ............................................................................................................419
Definiowanie wskaŸnika z u¿yciem auto ..........................................................................420
13.3
Sym bol zastêpczy auto a opuszczanie gwiazdki przy definiowaniu wskaŸnika ............423
13.3.1
Sposoby ustawiania wskaŸników .....................................................................................425
13.4
Parada k³amców, czyli o rzutowaniu const_cast................................................................427
13.5
13.6
Tablice wskaŸników .........................................................................................................431
13.7 Wariacje na temat C-stringów .........................................................................................433
Argumenty z linii wywo³ania programu...........................................................................440
13.8
13.9
Æwiczenia .........................................................................................................................443
Poleć książkęKup książkę X
Spis treœci trzech tomów
14 WskaŸniki do funkcji ........................................................................445
14.1 WskaŸnik, który mo¿e wskazywaæ na funkcjê .................................................................445
14.2
Æwiczenia z definiowania wskaŸników do funkcji ..........................................................448
14.3 WskaŸnik do funkcji jako argument innej funkcji............................................................454
Tablica wskaŸników do funkcji........................................................................................458
14.4
U¿ycie deklaracji using i typedef w œwiecie wskaŸników .................................................463
14.5
Alias przydatny w argumencie funkcji..........................................................................463
14.5.1
14.5.2
Alias przydatny w defi ni cji tablicy wskaŸników do funkcji .........................................464
U¿ycie auto lub decltype do automatycznego rozpoznania potrzebnego typu ...................465
14.6
14.7
Æwiczenia .........................................................................................................................467
15 Prze³adowanie nazwy funkcji..........................................................469
Co oznacza prze³adowanie ...............................................................................................469
15.1
Prze³adowanie od kuchni..................................................................................................472
15.2
Jak mo¿emy prze³adowywaæ, a jak siê nie da?.................................................................472
15.3
Czy prze³adowanie nazw funkcji jest technik¹ orientowan¹ obiektowo?.........................475
15.4
15.5
Linkowanie z modu³ami z innych jêzyków .....................................................................476
Prze³adowanie a zakres wa¿noœci deklaracji funkcji ........................................................477
15.6
Rozwa¿ania o identycznoœci lub odmiennoœci typów argumentów..................................479
15.7
Prze³adowanie a typy tworzone z us ing lub typedef oraz typy enum ..............................480
15.7.1
Tablica a wskaŸnik........................................................................................................480
15.7.2
15.7.3
Pewne szczegó³y o tablicach wielowymiarowych.........................................................481
Prze³adowanie a re fe ren cja............................................................................................483
15.7.4
Identycznoœæ typów: T, const T, vol a tile T.......................................................................484
15.7.5
Prze³adowanie a typy: T*, vol a tile T*, const T*.................................................................485
15.7.6
Prze³adowanie a typy: T , vol a tile T , const T ..............................................................486
15.7.7
15.8
Adres funkcji prze³adowanej ............................................................................................487
Zwrot rezultatu bêd¹cego adresem funkcji prze³adowanej............................................489
15.8.1
15.9
Kulisy dopasowywania argumentów do funkcji prze³adowanych....................................491
15.10 Etapy dopasowania ..........................................................................................................492
Etap 1. Dopasowanie dok³adne, bo konwersja niepotrzebna ........................................492
15.10.1
15.10.2
Etap 1a. Dopasowanie dok³adne, bo z tzw. trywialn¹ konwersj¹..................................493
Etap 2. Dopasowanie z awansem (z promocj¹).............................................................494
15.10.3
Etap 3. Próba dopasowania za pomoc¹ konwersji standardowych ...............................496
15.10.4
Etap 4. Dopasowanie z u¿yciem konwersji zdefiniowanych przez u¿ytkownika .........498
15.10.5
15.10.6
Etap 5. Dopasowanie do funkcji z wielokropkiem .......................................................498
15.11 WskaŸników nie dopasowuje siê inaczej ni¿ dos³ownie...................................................498
15.12 Dopasowywanie wywo³añ z kilkoma argumentami .........................................................499
15.13 Æwiczenia .........................................................................................................................500
16 Klasy ..................................................................................................503
Typy definiowane przez u¿ytkownika..............................................................................503
16.1
Sk³adniki klasy .................................................................................................................505
16.2
Sk³adnik bêd¹cy obiektem ...............................................................................................506
16.3
Kapsu³owanie ..................................................................................................................507
16.4
16.5
Ukrywanie informacji.......................................................................................................508
16.6
Klasa a obiekt ...................................................................................................................511
16.7 Wartoœci wstêpne w sk³adnikach nowych obiektów. Inicjalizacja „w klasie” .................513
Funkcje sk³adowe ............................................................................................................516
16.8
Pos³ugiwanie siê funkcjami sk³adowymi ......................................................................516
16.8.1
16.8.2
Definiowanie funkcji sk³adowych ................................................................................517
Jak to w³aœciwie jest? (this)...............................................................................................522
16.9
16.10 Odwo³anie siê do publicznych danych sk³adowych obiektu ............................................524
Poleć książkęKup książkę Spis treœci trzech tomów
XI
16.11 Zas³anianie nazw ..............................................................................................................525
16.11.1 Nie siêgaj z klasy do obiektów globalnych ...................................................................528
16.12
Prze³adowanie i zas³oniêcie równoczeœnie .......................................................................529
16.13 Nowa klasa? Osobny plik!................................................................................................529
16.13.1
Poznajmy praktyczn¹ realizacjê wieloplikowego programu .........................................532
Zasada umieszczania dyrektywy us ing namespace w plikach ........................................544
16.13.2
Przesy³anie do funkcji argumentów bêd¹cych obiektami.................................................544
16.14
Przesy³anie obiektu przez wartoœæ ................................................................................544
16.14.1
16.14.2
Przesy³anie przez referencjê .........................................................................................546
16.15 Konstruktor – pierwsza wzmianka ..................................................................................547
16.16 Destruktor – pierwsza wzmianka .....................................................................................552
16.17
Sk³adnik statyczny............................................................................................................556
16.17.1 Do czego mo¿e siê przydaæ sk³adnik statyczny w klasie?.............................................565
16.18
Statyczna funkcja sk³adowa..............................................................................................565
16.18.1 Dekla ra cja sk³adnika statycznego maj¹ca inicjalizacjê „w klasie”................................570
Funkcje sk³adowe typu const oraz volatile .........................................................................576
16.19
Prze³adowanie a funkcje sk³adowe const i vol a tile..........................................................580
16.19.1
16.20
Struktura ...........................................................................................................................580
16.21 Klasa bêd¹ca agregatem. Klasa bez konstruktora.............................................................581
Funkcje sk³adowe z przydomkiem constexpr ....................................................................583
16.22
Specyfikator mutable .........................................................................................................590
16.23
16.24 Bardziej rozbudowany przyk³ad zastosowania klasy .......................................................591
16.25 Æwiczenia .........................................................................................................................602
17 Biblioteczna klasa std::string ..............................................................607
Rozwi¹zanie przechowywania tekstów musia³o siê znaleŸæ ............................................607
17.1
Klasa std::string to przecie¿ nasz stary znajomy ................................................................609
17.2
Definiowanie obiektów klasy string ..................................................................................610
17.3
U¿ycie operatorów =, +, += w pracy ze stringami.............................................................615
17.4
Pojemnoœæ, rozmiar i d³ugoœæ stringu...............................................................................616
17.5
BliŸniacze funkcje size() i length()..................................................................................616
17.5.1
Funkcja sk³adowa empty................................................................................................617
17.5.2
Funkcja sk³adowa max_size ...........................................................................................617
17.5.3
Funkcja sk³adowa ca pac ity.............................................................................................617
17.5.4
Funkcje sk³adowe re serve i shrink_to_fit .........................................................................619
17.5.5
resize – zmiana d³ugoœci stringu „na si³ê” .....................................................................620
17.5.6
Funkcja sk³adowa clear..................................................................................................622
17.5.7
U¿ycie operatora [ ] oraz funkcji at ...................................................................................622
17.6
Dzia³anie ope ra tora [ ]....................................................................................................623
17.6.1
Dzia³anie funkcji sk³adowej at ......................................................................................624
17.6.2
Przebieganie po wszystkich literach stringu zakresowym for........................................627
17.6.3
Funkcje sk³adowe front i back............................................................................................627
17.7
17.8
Jak umieœciæ w tekœcie liczbê?..........................................................................................628
Jak wczytaæ liczbê ze stringu? ..........................................................................................630
17.9
Praca z fragmentem stringu, czyli z substringiem ............................................................633
17.10
Funkcja sk³adowa substr ...................................................................................................634
17.11
Szukanie zadanego substringu w obiekcie klasy string – funkcje find ...............................635
17.12
17.13
Szukanie rozpoczynane od koñca stringu.........................................................................638
17.14
Szukanie w stringu jednego ze znaków z zadanego zestawu............................................639
17.15 Usuwanie znaków ze stringu – erase i pop_back...............................................................641
17.16 Wstawianie znaków do istniej¹cego stringu – funkcje insert ............................................642
17.17 Zamiana czêœci znaków na inne znaki – replace ...............................................................644
17.18 Zagl¹danie do wnêtrza obiektu klasy string funkcj¹ data ..................................................647
17.19 ZawartoϾ obiektu klasy string a C-string .........................................................................648
Poleć książkęKup książkę XII
Spis treœci trzech tomów
17.20 W porz¹dku alfabetycznym, czyli porównywanie stringów.............................................651
Porównywanie stringów za pomoc¹ funkcji com pare....................................................652
17.20.1
Porównywanie stringów przy u¿yciu operatorów ==, !=, , , =, = ....................656
17.20.2
17.21 Zamiana treœci stringu na ma³e lub wielkie litery .............................................................657
17.22 Kopiowanie treœci obiektu klasy string do tablicy znakowej – funkcja copy .....................659
17.23 Wzajemna zamiana treœci dwóch obiektów klasy string – funkcja swap ...........................660
17.24 Wczytywanie z klawiatury stringu o nieznanej wczeœniej d³ugoœci – getline....................661
Pu³apka, czyli jak getline mo¿e Ciê zaskoczyæ ..............................................................664
17.24.1
Iteratory stringu ................................................................................................................668
17.25
17.25.1
Iterator do obiektu sta³ego.............................................................................................672
Funkcje sk³adowe klasy string pracuj¹ce z iteratorami ..................................................673
17.25.2
17.26 Klasa string korzysta z techniki przenoszenia ...................................................................678
17.27 Bryk, czyli „pamiêæ zewnêtrzna” programisty .................................................................679
17.28 Æwiczenia .........................................................................................................................687
18 Deklaracje przyjaŸni .........................................................................694
Przyjaciele w ¿yciu i w C++.............................................................................................694
18.1
18.2
Przyk³ad: dwie klasy deklaruj¹ przyjaŸñ z t¹ sam¹ funkcj¹..............................................696
18.3 W przyjaŸni trzeba pamiêtaæ o kilku sprawach ................................................................698
Obdarzenie przyjaŸni¹ funkcji sk³adowej innej klasy.......................................................701
18.4
Klasy zaprzyjaŸnione........................................................................................................703
18.5
Konwencja umieszczania deklaracji przyjaŸni w klasie ...................................................705
18.6
Kilka otrzeŸwiaj¹cych s³ów na zakoñczenie.....................................................................705
18.7
18.8
Æwiczenia .........................................................................................................................706
19 Obs³uga sytuacji wyj¹tkowych .......................................................708
Jak daæ znaæ, ¿e coœ siê nie uda³o? ...................................................................................708
19.1
19.2
Pierwszy prosty przyk³ad .................................................................................................710
Kolejnoœæ bloków catch ma znaczenie..............................................................................712
19.3
Który blok catch nadaje siê do z³apania lec¹cego wyj¹tku?..............................................713
19.4
Bloki try mog¹ byæ zagnie¿d¿ane......................................................................................715
19.5
19.6
Obs³uga wyj¹tków w praktycznym programie .................................................................718
Specyfikator noexcept i operator noexcept.........................................................................729
19.7
19.8
Æwiczenia .........................................................................................................................732
20 Klasa-sk³adnik oraz klasa lokalna ..................................................734
Klasa-sk³adnik, czyli gdy w klasie jest zagnie¿d¿ona definicja innej klasy .....................734
20.1
Prawdziwy przyk³ad zagnie¿d¿enia definicji klasy ..........................................................741
20.2
Lokalna definicja klasy.....................................................................................................752
20.3
Lokalne nazwy typów ......................................................................................................755
20.4
20.5
Æwiczenia .........................................................................................................................756
21 Konstruktory i destruktory ..............................................................758
Konstruktor ......................................................................................................................758
21.1
21.1.1
Przyk³ad programu zawieraj¹cego klasê z konstruktorami ...........................................759
Specyfikator (przydomek) explicit .....................................................................................770
21.2
Kiedy i jak wywo³ywany jest konstruktor........................................................................771
21.3
Konstruowanie obiektów lokalnych..............................................................................771
21.3.1
Konstruowanie obiektów globalnych............................................................................772
21.3.2
Konstrukcja obiektów tworzonych ope ra torem new......................................................772
21.3.3
Jawne wywo³anie konstruktora .....................................................................................773
21.3.4
21.3.5
Dalsze sytuacje, gdy pracuje konstruktor......................................................................776
Poleć książkęKup książkę Spis treœci trzech tomów
XIII
Destruktor.........................................................................................................................776
21.4
Jawne wywo³anie destruktora (ogromnie rzadka sytuacja) ...........................................778
21.4.1
Nie rzucajcie wyj¹tków z destruktorów ...........................................................................778
21.5
Konstruktor domniemany.................................................................................................780
21.6
Funkcje sk³adowe z przypiskami = default i = delete .........................................................781
21.7
Konstruktorowa lista inicjalizacyjna sk³adników klasy ...................................................783
21.8
Dla wtajemniczonych: wyj¹tki rzucane z konstruktorowej listy inicjalizacyjnej..........790
21.8.1
Konstruktor deleguj¹cy ....................................................................................................794
21.9
Pomocnicza klasa std::initializer_list – lista inicjalizatorów.................................................801
21.10
Zastosowania niekonstruktorowe..................................................................................801
21.10.1
21.10.2 Konfuzja: lista inicjalizatorów a lista inicjalizacyjna ....................................................810
21.10.3 Konstruktor z argu men tem bêd¹cym klamrow¹ list¹ inicjalizatorów ...........................811
21.11 Konstrukcja obiektu, którego sk³adnikiem jest obiekt innej klasy ...................................816
21.12 Konstruktory niepubliczne? .............................................................................................823
21.13 Konstruktory constexpr mog¹ wytwarzaæ obiekty constexpr..............................................825
21.14 Æwiczenia .........................................................................................................................835
22 Konstruktory: kopiuj¹cy i przenosz¹cy .........................................838
22.1
Konstruktor kopiuj¹cy (albo inicjalizator kopiuj¹cy) ......................................................838
Przyk³ad klasy z konstruktorem kopiuj¹cym....................................................................839
22.2
Kompilatorowi wolno pomin¹æ niepotrzebne kopiowanie ...............................................844
22.3
Dlaczego przez referencjê?...............................................................................................846
22.4
22.5
Konstruktor kopiuj¹cy gwarantuj¹cy nietykalnoœæ ..........................................................847
22.6 Wspó³odpowiedzialnoœæ...................................................................................................848
Konstruktor kopiuj¹cy generowany automatycznie ........................................................848
22.7
Kiedy powinniœmy sami zdefiniowaæ konstruktor kopiuj¹cy? .........................................849
22.8
Referencja do r-wartoœci daje zezwolenie na recykling....................................................856
22.9
Funkcja std::move, która nie przenosi, a tylko rzutuje.......................................................859
22.10
22.11 Odebrana r-wartoœæ staje siê w ciele funkcji l-wartoœci¹ ..................................................861
22.12 Konstruktor przenosz¹cy (inicjalizator przenosz¹cy) .......................................................863
22.12.1 Konstruktor przenosz¹cy generowany przez kom pi la tor ..............................................868
Inne konstruktory generowane auto ma ty cz nie..............................................................868
22.12.2
22.12.3
Zwrot obiektu lokalnego przez wartoœæ? Nie u¿ywamy przenoszenia!.........................869
22.13 Tak zwana „semantyka przenoszenia”..............................................................................870
22.14 Nowe pojêcia dla ambitnych: gl-wartoœæ, x-wartoœæ i pr-wartoœæ ....................................870
decltype – operator rozpoznawania typu bardzo wyszukanych wyra¿eñ...........................873
22.15
22.16 Æwiczenia .........................................................................................................................878
23 Tablice obiektów ..............................................................................880
Definiowanie tablic obiektów i praca z nimi ....................................................................880
23.1
Tablica obiektów definiowana operatorem new................................................................881
23.2
Inicjalizacja tablic obiektów .............................................................................................883
23.3
23.3.1
Ini cja li za cja tablicy, której obiekty s¹ agregatami ........................................................883
23.3.2
Ini cja li za cja tablic, których ele men ty nie s¹ agregatami ...............................................886
23.4 Wektory obiektów ............................................................................................................890
23.4.1 Wektor, którego elementami s¹ obiekty klasy bêd¹cej agregatem ................................892
23.4.2 Wektor, którego elementami s¹ obiekty klasy niebêd¹cej agregatem ...........................894
23.5
Æwiczenia .........................................................................................................................895
24 WskaŸnik do sk³adników klasy ......................................................896
24.1 WskaŸniki zwyk³e – repetytorium ....................................................................................896
24.2 WskaŸnik do pokazywania na sk³adnik-dan¹ ..................................................................897
24.2.1
Przyk³ad zastosowania wskaŸników do sk³adników klasy............................................901
24.3 WskaŸnik do funkcji sk³adowej........................................................................................908
Poleć książkęKup książkę XIV
Spis treœci trzech tomów
Przyk³ad zastosowania wskaŸników do funkcji sk³adowych ........................................910
24.3.1
Tablica wskaŸników do danych sk³adowych klasy .........................................................917
24.4
Tablica wskaŸników do funkcji sk³adowych klasy ..........................................................918
24.5
24.5.1
Przyk³ad tablicy/wektora wskaŸników do funkcji sk³adowych.....................................919
24.6 WskaŸniki do sk³adników statycznych s¹ zwyk³e ............................................................922
Æwiczenia .........................................................................................................................923
24.7
25 Konwersje definiowane przez u¿ytkownika...................................925
25.1
Sformu³owanie problemu .................................................................................................925
Konstruktory konwertuj¹ce ..............................................................................................927
25.2
Kiedy jawnie, kiedy niejawnie ......................................................................................928
25.2.1
Przyk³ad konwersji konstruktorem................................................................................933
25.2.2
Funkcja konwertuj¹ca – operator konwersji.....................................................................935
25.3
25.3.1
Na co funkcja konwertuj¹ca zamieniaæ nie mo¿e..........................................................941
Który wariant konwersji wybraæ?.....................................................................................942
25.4
Sytuacje, w których zachodzi konwersja..........................................................................944
25.5
Zapis jawnego wywo³ania konwersji typów.....................................................................945
25.6
Advocatus zapisu przypominaj¹cego: „wywo³anie funkcji” ........................................945
25.6.1
25.6.2
Advocatus zapisu: „rzutowanie” ..................................................................................946
Nie ca³kiem pasuj¹ce argumenty, czyli konwersje kompilatora przy dopasowaniu ........946
25.7
Kilka rad dotycz¹cych konwersji......................................................................................951
25.8
25.9
Æwiczenia .........................................................................................................................952
26 Prze³adowanie operatorów..............................................................954
Co to znaczy prze³adowaæ operator? ................................................................................954
26.1
26.2
Prze³adowanie operatorów – definicja i trochê teorii .......................................................956
26.3 Moje zabawki ...................................................................................................................960
26.4
Funkcja operatorowa jako funkcja sk³adowa ...................................................................961
Funkcja operatorowa nie musi byæ przyjacielem klasy ....................................................964
26.5
Operatory predefiniowane ................................................................................................964
26.6
Ile operandów ma mieæ ten operator? ..............................................................................965
26.7
Operatory jednooperandowe ............................................................................................965
26.8
26.9
Operatory dwuoperandowe ..............................................................................................968
Przyk³ad na prze³adowanie ope ra tora dwuoperandowego ............................................968
26.9.1
PrzemiennoϾ ...............................................................................................................970
26.9.2
Choæ ope ra tory inne, to nazwê maj¹ tê sam¹ ................................................................971
26.9.3
26.10
Przyk³ad zupe³nie niematematyczny ................................................................................971
26.11 Operatory postinkrementacji i postdekrementacji – koniec z niesprawiedliwoœci¹..........981
Praktyczne rady dotycz¹ce prze³adowania .......................................................................983
26.12
26.13
Pojedynek: operator jako funkcja sk³adowa czy globalna? ..............................................985
26.14 Zas³ona spada, czyli tajemnica operatora ....................................................................986
Sta³e dos³owne definiowane przez u¿ytkownika ..............................................................992
26.15
26.15.1
Przyk³ad: sta³e dos³owne u¿ytkownika odbierane jako gotowane ................................996
26.15.2
Przyk³ad: sta³e dos³owne u¿ytkownika odbierane na surowo .....................................1005
26.16 Æwiczenia .......................................................................................................................1008
27 Prze³adowanie: =, [ ], ( ), – ..............................................................1012
Cztery operatory, które musz¹ byæ niestatycznymi funkcjami sk³adowymi...................1012
27.1
Operator przypisania = (wersja kopiuj¹ca) .....................................................................1012
27.2
Przyk³ad na prze³adowanie (kopiuj¹cego) ope ra tora przypisania ..............................1014
27.2.1
Przypisanie „kaskadowe”............................................................................................1021
27.2.2
Po co i jak zabezpieczamy siê przed przypisaniem a = a.............................................1023
27.2.3
Jak opowiedzieæ potocznie o koniecznoœci istnienia ope ra tora przypisania?..............1024
27.2.4
27.2.5
Kiedy kopiuj¹cy ope ra to r przypisania nie jest generowany auto ma ty cz nie ...............1026
Poleć książkęKup książkę Spis treœci trzech tomów
XV
27.3
27.4
27.5
27.6
27.7
27.7.1
27.8
Przenosz¹cy operator przypisania = ...............................................................................1026
Specjalne funkcje sk³adowe i nierealna prosta zasada....................................................1035
Operator [ ] ......................................................................................................................1036
Operator ().......................................................................................................................1040
Operator – ....................................................................................................................1046
„Sprytny wskaŸnik” wykorzystuje prze³adowanie w³aœnie tego ope ra tora .................1048
Æwiczenia .......................................................................................................................1055
28 Prze³adowanie operatorów new i de lete na u¿ytek klasy...............1057
Po co prze³adowujemy operatory new i new[ ].................................................................1057
28.1
Funkcja operator new i operator new[ ] w klasie K ............................................................1058
28.2
Jak siê deklaruje operatory new i delete w klasie?...........................................................1061
28.3
Przyk³adowy program z prze³adowanymi new i delete ...................................................1063
28.4
Gdy dopuszczamy rzucanie wyj¹tku std::bad_alloc......................................................1064
28.4.1
Po staremu nadal mo¿na..............................................................................................1069
28.4.2
Rezerwacja tablicy obiektów naszej klasy Twektorek ..................................................1069
28.4.3
Nasze w³asne argu men ty wys³ane do ope ra tora new ...................................................1071
28.4.4
28.4.5 X Ope ra tory new i de lete odziedziczone do klasy pochodnej...................................1073
28.4.6
A jednak polimorfizm jest mo¿liwy............................................................................1075
Tworzenie i likwidowanie tablicy obiektów klasy pochodnej ....................................1075
28.4.7
Ope ra tory new, które nie rzuc¹ wyj¹tku std::bad_alloc .................................................1076
28.4.8
Rzut oka wstecz na prze³adowanie operatorów ..............................................................1081
28.5
28.6
Æwiczenia .......................................................................................................................1082
29 Unie i pola bitowe...........................................................................1084
Unia ................
Pobierz darmowy fragment (pdf)
Gdzie kupić całą publikację:
Opus magnum C++ 11. Programowanie w języku C++. Wydanie II poprawione (komplet)
Jerzy Grębosz
Opinie na temat publikacji:
Inne popularne pozycje z tej kategorii:
Czytaj również:
Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką :
