Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00139 003248 21535171 na godz. na dobę w sumie
Opus magnum C++ 11. Programowanie w języku C++. Wydanie II poprawione (komplet) - książka
Opus magnum C++ 11. Programowanie w języku C++. Wydanie II poprawione (komplet) - książka
Autor: Liczba stron: 1648
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-6965-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook (-35%), audiobook).

'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:

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)
Autor:

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ą: