Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00276 009766 11028735 na godz. na dobę w sumie
C++ dla każdego - książka
C++ dla każdego - książka
Autor: Liczba stron: 712
Wydawca: Helion Język publikacji: polski
ISBN: 83-7197-538-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).
Materiał zawarty w tej książce to podstawowe zagadnienia i koncepcje związane z programowaniem w C++, tak więc nie musisz posiadać żadnego doświadczenia w programowaniu w tym języku. Liczne przykłady składni oraz szczegółowa analiza kodu stanowią doskonały przewodnik na początku podróży, której celem jest opanowanie programowania w języku C++. Bez względu na to, czy jesteś początkujący, czy też posiadasz pewne doświadczenie w programowaniu, przekonasz się, że dzięki przejrzystej organizacji tej książki nauka C++ będzie szybka i łatwa.

Książka ta stanowi wprowadzenie do programowania w języku C++. Nie koncentruje się na konkretnej implementacji, lecz raczej opisuje standard ANSI/ISO; znajdziesz w niej również omówienie biblioteki STL (Standard Template Library). Jeśli nawet nie masz doświadczenia w pisaniu programów, to dzięki tej książce:

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TRE(cid:140)CI SPIS TRE(cid:140)CI C++ dla ka¿dego KATALOG KSI¥flEK KATALOG KSI¥flEK KATALOG ONLINE KATALOG ONLINE ZAM(cid:211)W DRUKOWANY KATALOG ZAM(cid:211)W DRUKOWANY KATALOG Autor: Jesse Liberty T‡umaczenie: Marcin Pancewicz ISBN: 83-7197-538-4 Tytu‡ orygina‡u: Fourth Edition Format: B5, stron: 712 Teach Yourself C++ in 21 Days. TW(cid:211)J KOSZYK TW(cid:211)J KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAM(cid:211)W INFORMACJE ZAM(cid:211)W INFORMACJE O NOWO(cid:140)CIACH O NOWO(cid:140)CIACH ZAM(cid:211)W CENNIK ZAM(cid:211)W CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥flEK ONLINE FRAGMENTY KSI¥flEK ONLINE Materia‡ zawarty w tej ksi„¿ce to podstawowe zagadnienia i koncepcje zwi„zane z(cid:160) programowaniem w C++, tak wiŒc nie musisz posiada(cid:230) ¿adnego do(cid:156)wiadczenia w(cid:160) programowaniu w tym jŒzyku. Liczne przyk‡ady sk‡adni oraz szczeg(cid:243)‡owa analiza kodu stanowi„ doskona‡y przewodnik na pocz„tku podr(cid:243)¿y, kt(cid:243)rej celem jest opanowanie programowania w jŒzyku C++. Bez wzglŒdu na to, czy jeste(cid:156) pocz„tkuj„cy, czy te¿ posiadasz pewne do(cid:156)wiadczenie w programowaniu, przekonasz siŒ, ¿e dziŒki przejrzystej organizacji tej ksi„¿ki nauka C++ bŒdzie szybka i ‡atwa. Ksi„¿ka ta stanowi wprowadzenie do programowania w jŒzyku C++. Nie koncentruje siŒ na konkretnej implementacji, lecz raczej opisuje standard ANSI/ISO; znajdziesz w(cid:160) niej r(cid:243)wnie¿ om(cid:243)wienie biblioteki STL (Standard Template Library). Je(cid:156)li nawet nie masz do(cid:156)wiadczenia w pisaniu program(cid:243)w, to dziŒki tej ksi„¿ce: BŒdziesz tworzy‡ szybkie i wydajne programy w C++. Zrozumiesz standard ANSI/ISO i skorzystasz z wprowadzonych w nim zmian. Opanujesz zaawansowane programowanie z u¿yciem funkcji, tablic, zmiennych i(cid:160) wska(cid:159)nik(cid:243)w. Poznasz C++ oraz obiektowo zorientowane projektowanie, programowanie i(cid:160) analizŒ. Nauczysz siŒ wzbogaca(cid:230) swoje programy za pomoc„ dziedziczenia i(cid:160) polimorfizmu. BŒdziesz m(cid:243)g‡ korzysta(cid:230) z dowolnego kompilatora zgodnego ze standardem ANSI/ISO C++. Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl O Autorze ...........................................................................................................15 Wstęp ................................................................................................................17 Część I ..........................................................................................19 Rozdział 1. Zaczynamy ......................................................................................21 Wprowadzenie...................................................................................................................21 Krótka historia języka C++ ...............................................................................................21 Rozwiązywanie problemów........................................................................................22 Programowanie proceduralne, strukturalne i obiektowe ............................................23 C++ i programowanie zorientowane obiektowo.........................................................25 Jak ewoluowało C++.........................................................................................................26 Czy należy najpierw poznać C? ........................................................................................26 C++ a Java i C# .................................................................................................................27 Standard ANSI ..................................................................................................................27 Przygotowanie do programowania....................................................................................28 Twoje środowisko programowania ...................................................................................28 Tworzenie programu .........................................................................................................29 Tworzenie pliku obiektowego za pomocą kompilatora ..............................................29 Tworzenie pliku wykonywalnego za pomocą linkera ................................................30 Cykl tworzenia programu..................................................................................................30 HELLO.cpp — twój pierwszy program w C++................................................................32 Zaczynamy pracę z kompilatorem ....................................................................................34 Budowanie projektu Hello World...............................................................................34 Błędy kompilacji ...............................................................................................................36 Rozdział 2. Anatomia programu C++ ..................................................................37 Prosty program ..................................................................................................................37 Rzut oka na obiekt cout.....................................................................................................39 Używanie przestrzeni nazw standardowych .....................................................................41 Komentarze .......................................................................................................................43 Rodzaje komentarzy....................................................................................................44 Używanie komentarzy ................................................................................................44 Jeszcze jedna uwaga na temat komentarzy.................................................................45 Funkcje ..............................................................................................................................45 Korzystanie z funkcji ..................................................................................................46 2 C++ dla każdego Rozdział 3. Zmienne i stałe................................................................................49 Czym jest zmienna? ..........................................................................................................49 Dane są przechowywane w pamięci ...........................................................................49 Przydzielanie pamięci .................................................................................................50 Rozmiar liczb całkowitych .........................................................................................51 Zapis ze znakiem i bez znaku .....................................................................................52 Podstawowe typy zmiennych......................................................................................53 Definiowanie zmiennej .....................................................................................................54 Uwzględnianie wielkości liter.....................................................................................55 Słowa kluczowe ..........................................................................................................56 Tworzenie kilku zmienych jednocześnie ..........................................................................56 Przypisywanie zmiennym wartości...................................................................................56 typedef...............................................................................................................................58 Kiedy używać typu short, a kiedy typu long? ...................................................................59 Zawinięcie liczby całkowitej bez znaku .....................................................................60 Zawinięcie liczby całkowitej ze znakiem ...................................................................61 Znaki..................................................................................................................................62 Znaki i liczby ..............................................................................................................62 Znaki specjalne ...........................................................................................................63 Stałe...................................................................................................................................64 Literały........................................................................................................................64 Stałe symboliczne .......................................................................................................64 Stałe wyliczeniowe............................................................................................................66 Rozdział 4. Wyrażenia i instrukcje ......................................................................69 Instrukcje...........................................................................................................................69 Białe spacje .................................................................................................................70 Bloki i instrukcje złożone ...........................................................................................70 Wyrażenia..........................................................................................................................70 Operatory...........................................................................................................................72 Operator przypisania...................................................................................................72 Operatory matematyczne ............................................................................................73 Dzielenie całkowite i reszta z dzielenia ......................................................................73 Łączenie operatora przypisania z operatorem matematycznym .......................................74 Inkrementacja i dekrementacja..........................................................................................75 Przedrostki i przyrostki ...............................................................................................75 Kolejność działań ..............................................................................................................77 Zagnieżdżanie nawiasów...................................................................................................78 Prawda i fałsz ....................................................................................................................79 Operatory relacji .........................................................................................................79 Instrukcja if .......................................................................................................................80 Styl wcięć....................................................................................................................83 else ..............................................................................................................................84 Zaawansowane instrukcje if........................................................................................86 Użycie nawiasów klamrowych w zagnieżdżonych instrukcjach if...................................87 Operatory logiczne ............................................................................................................89 Logiczne I ...................................................................................................................90 Logiczne LUB.............................................................................................................90 Logiczne NIE ..............................................................................................................90 Skrócone obliczanie wyrażeń logicznych .........................................................................91 Kolejność operatorów logicznych.....................................................................................91 Kilka słów na temat prawdy i fałszu .................................................................................92 Operator warunkowy (trójelementowy) ............................................................................93 Spis treści 3 Rozdział 5. Funkcje ...........................................................................................95 Czym jest funkcja? ............................................................................................................95 Zwracane wartości, parametry i argumenty ......................................................................96 Deklarowanie i definiowanie funkcji ................................................................................97 Deklarowanie funkcji..................................................................................................97 Prototypy funkcji ........................................................................................................98 Definiowanie funkcji ..................................................................................................99 Wykonywanie funkcji .....................................................................................................100 Zmienne lokalne..............................................................................................................101 Zakres........................................................................................................................102 Zmienne globalne............................................................................................................102 Zmienne globalne: ostrzeżenie........................................................................................104 Kilka słów na temat zmiennych lokalnych .....................................................................104 Instrukcje funkcji.............................................................................................................106 Kilka słów na temat argumentów funkcji .......................................................................106 Użycie funkcji jako parametrów funkcji...................................................................106 Parametry są zmiennymi lokalnymi................................................................................107 Kilka słów na temat zwracanych wartości ......................................................................109 Parametry domyślne........................................................................................................111 Przeciążanie funkcji ........................................................................................................113 Zagadnienia związane z funkcjami .................................................................................116 Funkcje typu inline ...................................................................................................116 Rekurencja ................................................................................................................118 Jak działają funkcje — rzut oka „pod maskę” ................................................................123 Poziomy abstrakcji....................................................................................................123 Podział pamięci.........................................................................................................123 Stos i funkcje.............................................................................................................126 Rozdział 6. Programowanie zorientowane obiektowo.........................................129 Czy C++ jest zorientowane obiektowo? .........................................................................129 Tworzenie nowych typów ...............................................................................................130 Po co tworzyć nowy typ?..........................................................................................131 Klasy i składowe .............................................................................................................131 Deklarowanie klasy...................................................................................................132 Kilka słów o konwencji nazw ...................................................................................132 Definiowanie obiektu................................................................................................133 Klasy a obiekty .........................................................................................................133 Dostęp do składowych klasy ...........................................................................................134 Przypisywać należy obiektom, nie klasom ...............................................................134 Czego nie zadeklarujesz, tego klasa nie będzie miała ..............................................134 Prywatne i publiczne .......................................................................................................135 Oznaczanie danych składowych jako prywatnych ...................................................137 Prywatność a ochrona ...............................................................................................138 Implementowanie metod klasy........................................................................................140 Konstruktory i destruktory ..............................................................................................142 Domyślne konstruktory i destruktory .......................................................................143 Użycie domyślnego konstruktora .............................................................................143 Funkcje składowe const ..................................................................................................146 Interfejs a implementacja ................................................................................................147 Gdzie umieszczać deklaracje klasy i definicje metod.....................................................150 Implementacja inline .......................................................................................................151 Klasy, których danymi składowymi są inne klasy ..........................................................153 Struktury..........................................................................................................................157 Dlaczego dwa słowa kluczowe spełniają tę samą funkcję........................................157 4 C++ dla każdego Rozdział 7. Sterowanie przebiegiem działania programu ....................................159 Pętle.................................................................................................................................159 Początki pętli: instrukcja goto...................................................................................159 Dlaczego nie jest zalecane stosowanie instrukcji goto?............................................160 Pętle while .......................................................................................................................160 Bardziej skomplikowane instrukcje while ................................................................162 continue oraz break ...................................................................................................163 Pętla while (true).......................................................................................................166 Pętla do...while ................................................................................................................167 do...while .........................................................................................................................168 Pętle for ...........................................................................................................................170 Zaawansowane pętle for ...........................................................................................171 Puste pętle for ...........................................................................................................174 Pętle zagnieżdżone....................................................................................................175 Zakres zmiennych w pętlach for ...............................................................................177 Podsumowanie pętli ........................................................................................................178 Instrukcja switch .............................................................................................................180 Użycie instrukcji switch w menu..............................................................................182 Program podsumowujący wiadomości............................................................................186 Część II .......................................................................................191 Rozdział 8. Wskaźniki ......................................................................................193 Czym jest wskaźnik?.......................................................................................................193 Kilka słów na temat pamięci.....................................................................................193 Użycie operatora adresu ( ).....................................................................................194 Przechowywanie adresu we wskaźniku ....................................................................195 Puste i błędne wskaźniki...........................................................................................195 Nazwy wskaźników ..................................................................................................196 Operator wyłuskania .................................................................................................197 Wskaźniki, adresy i zmienne ....................................................................................197 Operowanie danymi poprzez wskaźniki ...................................................................199 Sprawdzanie adresu ..................................................................................................200 Do czego służą wskaźniki? .............................................................................................202 Stos i sterta ......................................................................................................................203 Operator new.............................................................................................................204 delete .........................................................................................................................204 Wycieki pamięci..............................................................................................................206 Tworzenie obiektów na stercie........................................................................................207 Usuwanie obiektów .........................................................................................................207 Dostęp do składowych klasy ...........................................................................................208 Dane składowe na stercie ................................................................................................210 Wskaźnik this ..................................................................................................................212 Utracone wskaźniki .........................................................................................................214 Wskaźniki const ..............................................................................................................217 Wskaźniki const i funkcje składowe const ...............................................................218 Wskaźniki const this .................................................................................................219 Działania arytmetyczne na wskaźnikach — temat dla zaawansowanych.......................220 Rozdział 9. Referencje .....................................................................................223 Czym jest referencja? ......................................................................................................223 Użycie operatora adresu z referencją ..............................................................................225 Nie można zmieniać przypisania referencji..............................................................226 Spis treści 5 Do czego mogą odnosić się referencje? ..........................................................................227 Zerowe wskaźniki i zerowe referencje............................................................................229 Przekazywanie argumentów funkcji przez referencję.....................................................229 Tworzenie funkcji swap() otrzymującej wskaźniki ..................................................231 Implementacja funkcji swap() za pomocą referencji ................................................233 Nagłówki i prototypy funkcji ..........................................................................................234 Zwracanie kilku wartości ................................................................................................235 Zwracanie wartości przez referencję ........................................................................237 Przekazywanie przez referencję zwiększa efektywność działania programu .................238 Przekazywanie wskaźnika const ...............................................................................241 Referencje jako metoda alternatywna.......................................................................243 Kiedy używać wskaźników, a kiedy referencji...............................................................245 Łączenie referencji i wskaźników ...................................................................................246 Nie pozwól funkcji zwracać referencji do obiektu, którego nie ma w zakresie! ............247 Zwracanie referencji do obiektu na stercie .....................................................................249 Wskaźnik, wskaźnik, kto ma wskaźnik?.........................................................................251 Rozdział 10. Funkcje zaawansowane ..................................................................253 Przeciążone funkcje składowe ........................................................................................253 Użycie wartości domyślnych ..........................................................................................255 Wybór pomiędzy wartościami domyślnymi a przeciążaniem funkcji ............................257 Konstruktor domyślny.....................................................................................................258 Przeciążanie konstruktorów ............................................................................................258 Inicjalizowanie obiektów ................................................................................................260 Konstruktor kopiujący.....................................................................................................261 Przeciążanie operatorów .................................................................................................265 Pisanie funkcji inkrementacji....................................................................................266 Przeciążanie operatora przedrostkowego..................................................................267 Zwracanie typów w przeciążonych funkcjach operatorów.......................................268 Zwracanie obiektów tymczasowych bez nadawania im nazw..................................270 Użycie wskaźnika this...............................................................................................271 Dlaczego stała referencja? ........................................................................................273 Przeciążanie operatora przyrostkowego ...................................................................273 Różnica pomiędzy przedrostkiem a przyrostkiem....................................................273 Operator dodawania ..................................................................................................275 Przeciążanie operatora dodawania............................................................................277 Zagadnienia związane z przeciążaniem operatorów.................................................278 Ograniczenia w przeciążaniu operatorów.................................................................278 Co przeciążać? ..........................................................................................................279 Operator przypisania.................................................................................................279 Obsługa konwersji typów danych ...................................................................................282 Operatory konwersji..................................................................................................285 Rozdział 11. Analiza i projektowanie zorientowane obiektowo .............................287 Budowanie modeli...........................................................................................................287 Projektowanie oprogramowania: język modelowania ....................................................288 Projektowanie oprogramowania: proces .........................................................................289 Programowanie ekstremalne ...........................................................................................292 Pomysł.............................................................................................................................292 Analiza wymagań............................................................................................................293 Przypadki użycia.......................................................................................................293 Analiza aplikacji .......................................................................................................303 Analiza systemów .....................................................................................................304 6 C++ dla każdego Tworzenie dokumentacji...........................................................................................304 Wizualizacje..............................................................................................................305 Dokumentacja produktu............................................................................................305 Projektowanie..................................................................................................................306 Czym są klasy? .........................................................................................................306 Przekształcenia..........................................................................................................308 Model statyczny ........................................................................................................309 Model dynamiczny....................................................................................................318 Rozdział 12. Dziedziczenie .................................................................................321 Czym jest dziedziczenie? ................................................................................................321 Dziedziczenie i wyprowadzanie ...............................................................................322 Królestwo zwierząt ...................................................................................................323 Składnia wyprowadzania ..........................................................................................323 Prywatne kontra chronione..............................................................................................325 Konstruktory i destruktory ..............................................................................................327 Przekazywanie argumentów do konstruktorów bazowych.......................................329 Przesłanianie funkcji .......................................................................................................333 Ukrywanie metod klasy bazowej ..............................................................................335 Wywoływanie metod klasy bazowej ........................................................................337 Metody wirtualne ............................................................................................................338 Jak działają funkcje wirtualne...................................................................................342 Nie możesz przejść stąd dotąd ..................................................................................343 Okrajanie...................................................................................................................344 Destruktory wirtualne ...............................................................................................346 Wirtualne konstruktory kopiujące.............................................................................346 Koszt metod wirtualnych ..........................................................................................349 Rozdział 13. Tablice i listy połączone .................................................................351 Czym jest tablica? ...........................................................................................................351 Elementy tablicy..............................................................................................................352 Zapisywanie za końcem tablicy ......................................................................................353 Błąd słupka w płocie .......................................................................................................356 Inicjalizowanie tablic ......................................................................................................356 Deklarowanie tablic.........................................................................................................357 Tablice obiektów .............................................................................................................358 Tablice wielowymiarowe ................................................................................................360 Inicjalizowanie tablic wielowymiarowych......................................................................360 Kilka słów na temat pamięci ...........................................................................................362 Tablice wskaźników........................................................................................................363 Deklarowane tablic na stercie .........................................................................................364 Wskaźnik do tablicy a tablica wskaźników.....................................................................365 Wskaźniki a nazwy tablic................................................................................................365 Usuwanie tablic ze sterty.................................................................................................367 Tablice znaków ...............................................................................................................368 strcpy() oraz strncpy() .....................................................................................................370 Klasy łańcuchów .............................................................................................................371 Listy połączone i inne struktury ......................................................................................378 Analiza listy połączonej ..................................................................................................378 Przeniesienie odpowiedzialności ..............................................................................379 Części składowe ..............................................................................................................379 Czego się nauczyłaś, Dorotko? .......................................................................................388 Klasy tablic......................................................................................................................388 Spis treści 7 Rozdział 14. Polimorfizm....................................................................................391 Problemy z pojedynczym dziedziczeniem ......................................................................391 Przenoszenie w górę .................................................................................................394 Rzutowanie w dół .....................................................................................................394 Połączenie dwóch list................................................................................................397 Dziedziczenie wielokrotne ..............................................................................................397 Części obiektu z dziedziczeniem wielokrotnym.......................................................400 Konstruktory w obiektach dziedziczonych wielokrotnie..........................................401 Eliminowanie niejednoznaczności............................................................................403 Dziedziczenie ze wspólnej klasy bazowej ................................................................404 Dziedziczenie wirtualne............................................................................................408 Problemy z dziedziczeniem wielokrotnym...............................................................411 Mixiny i klasy metod ................................................................................................412 Abstrakcyjne typy danych...............................................................................................413 Czyste funkcje wirtualne...........................................................................................416 Implementowanie czystych funkcji wirtualnych ......................................................417 Złożone hierarchie abstrakcji....................................................................................420 Które typy są abstrakcyjne? ......................................................................................424 Program podsumowujący wiadomości............................................................................425 Część III ......................................................................................435 Rozdział 15. Specjalne klasy i funkcje................................................................437 Statyczne dane składowe.................................................................................................437 Statyczne funkcje składowe ............................................................................................442 Wskaźniki do funkcji ......................................................................................................444 Dlaczego warto używać wskaźników do funkcji? ....................................................447 Tablice wskaźników do funkcji ................................................................................450 Przekazywanie wskaźników do funkcji innym funkcjom ........................................452 Użycie instrukcji typedef ze wskaźnikami do funkcji ..............................................455 Wskaźniki do funkcji składowych ..................................................................................457 Tablice wskaźników do funkcji składowych ............................................................459 Rozdział 16. Dziedziczenie zaawansowane..........................................................463 Zawieranie.......................................................................................................................463 Dostęp do składowych klasy zawieranej ..................................................................469 Filtrowany dostęp do składowych zawieranych .......................................................469 Koszt zawierania.......................................................................................................470 Kopiowanie przez wartość........................................................................................473 Implementowanie poprzez dziedziczenie i zawieranie oraz poprzez delegację .............476 Delegacja...................................................................................................................477 Dziedziczenie prywatne ..................................................................................................485 Klasy zaprzyjaźnione ......................................................................................................493 Funkcje zaprzyjaźnione...................................................................................................501 Funkcje zaprzyjaźnione i przeciążanie operatorów ........................................................501 Przeciążanie operatora wstawiania..................................................................................505 Rozdział 17. Strumienie .....................................................................................511 Przegląd strumieni...........................................................................................................511 Kapsułkowanie..........................................................................................................512 Buforowanie..............................................................................................................512 Strumienie i bufory..........................................................................................................514 Standardowe obiekty wejścia-wyjścia ............................................................................514 8 C++ dla każdego Przekierowywanie ...........................................................................................................515 Wejście z użyciem cin.....................................................................................................516 Łańcuchy...................................................................................................................517 Problemy z łańcuchami.............................................................................................517 Zwracanie referencji do obiektu istream przez operator ......................................520 Inne funkcje składowe w dyspozycji cin.........................................................................520 Wprowadzanie pojedynczych znaków......................................................................521 Odczytywanie łańcuchów z wejścia standardowego ................................................523 Użycie cin.ignore() ...................................................................................................526 peek() oraz putback() ................................................................................................527 Wyjście poprzez cout ......................................................................................................528 Zrzucanie zawartości bufora .....................................................................................528 Powiązane funkcje...........................................................................................................528 Manipulatory, znaczniki oraz instrukcje formatowania..................................................530 Użycie cout.width()...................................................................................................530 Ustawianie znaków wypełnienia...............................................................................531 Funkcja setf() ............................................................................................................532 Strumienie kontra funkcja printf()...................................................................................534 Wejście i wyjście z użyciem plików ...............................................................................537 ofstream...........................................................................................................................538 Stany strumieni .........................................................................................................538 Otwieranie plików dla wejścia i wyjścia ..................................................................538 Zmiana domyślnego zachowania obiektu ofstream w trakcie otwierania pliku .......540 Pliki binarne a pliki tekstowe ..........................................................................................542 Przetwarzanie linii polecenia ..........................................................................................544 Rozdział 18. Przestrzenie nazw ..........................................................................549 Zaczynamy ......................................................................................................................549 Funkcje i klasy są rozpoznawane poprzez nazwy...........................................................550 Tworzenie przestrzeni nazw............................................................................................553 Deklarowanie i definiowanie typów .........................................................................554 Definiowanie funkcji poza przestrzenią nazw ..........................................................554 Dodawanie nowych składowych...............................................................................555 Zagnieżdżanie przestrzeni nazw ...............................................................................555 Używanie przestrzeni nazw.............................................................................................556 Słowo kluczowe using.....................................................................................................558 Dyrektywa using .......................................................................................................558 Deklaracja using........................................................................................................559 Alias przestrzeni nazw ....................................................................................................561 Nienazwana przestrzeń nazw ..........................................................................................561 Standardowa przestrzeń nazw std ...................................................................................562 Rozdział 19. Wzorce ..........................................................................................565 Czym są wzorce?.............................................................................................................565 Typy parametryzowane ...................................................................................................566 Tworzenie egzemplarza wzorca................................................................................566 Definicja wzorca .............................................................................................................566 Użycie nazwy............................................................................................................568 Implementowanie wzorca .........................................................................................568 Funkcje wzorcowe...........................................................................................................571 Wzorce i przyjaciele........................................................................................................572 Niewzorcowe zaprzyjaźnione klasy i funkcje...........................................................572 Ogólne wzorcowe zaprzyjaźnione klasy i funkcje....................................................575 Spis treści 9 Użycie elementów wzorca ..............................................................................................579 Funkcje specjalizowane ............................................................................................582 Wzorce i składowe statyczne ....................................................................................588 Standardowa biblioteka wzorców ...................................................................................591 Kontenery ........................................................................................................................591 Kontenery sekwencyjne ..................................................................................................592 Kontener vector.........................................................................................................592 Kontener list..............................................................................................................598 Kontener deque .........................................................................................................599 Stosy ................................................................................................................................600 Kolejki.............................................................................................................................601 Kontenery asocjacyjne ....................................................................................................601 Kontener map............................................................................................................601 Inne kontenery asocjacyjne.......................................................................................604 Klasy algorytmów ...........................................................................................................604 Bezmutacyjne operacje sekwencyjne .......................................................................605 Mutacyjne algorytmy sekwencyjne ..........................................................................606 Rozdział 20. Wyjątki i obsługa błędów................................................................609 Pluskwy, błędy, pomyłki i „psujący” się kod..................................................................609 Wyjątki......................................................................................................................610 Wyjątki ............................................................................................................................611 Jak używane są wyjątki.............................................................................................611 Użycie bloków try oraz bloków catch.............................................................................616 Wychwytywanie wyjątków.......................................................................................616 Wychwytywanie więcej niż jednego rodzaju wyjątków...........................................617 Hierarchie wyjątków.................................................................................................620 Dane w wyjątkach oraz nazwane obiekty wyjątków ......................................................622 Wyjątki i wzorce .............................................................................................................629 Wyjątki bez błędów.........................................................................................................631 Kilka słów na temat „psującego” się kodu......................................................................632 Pluskwy i odpluskwianie.................................................................................................633 Punkty wstrzymania..................................................................................................633 Śledzenie wartości zmiennych..................................................................................633 Sprawdzanie pamięci ................................................................................................634 Asembler ...................................................................................................................634 Rozdział 21. Co dalej .........................................................................................635 Preprocesor i kompilator .................................................................................................635 Przeglądanie formy pośredniej........................................................................................636 Użycie dyrektywy #define ..............................................................................................636 Użycie #define dla stałych ........................................................................................636 Użycie #define do definiowania symboli .................................................................636 Dyrektywa #else preprocesora..................................................................................637 Dołączanie i wartowniki dołączania ...............................................................................638 Funkcje makro.................................................................................................................640 Po co te wszystkie nawiasy? .....................................................................................641 Makra a funkcje i wzorce..........................................................................................642 Funkcje inline..................................................................................................................642 Manipulacje łańcuchami .................................................................................................644 Zamiana w łańcuch ...................................................................................................644 Konkatenacja.............................................................................................................644 Makra predefiniowane.....................................................................................................645 10 C++ dla każdego Makro assert() .................................................................................................................645 Debuggowanie za pomocą makra assert() ................................................................647 Makro assert() a wyjątki ...........................................................................................647 Efekty uboczne..........................................................................................................648 Niezmienniki klas .....................................................................................................648 Wypisywanie wartości tymczasowych .....................................................................653 Poziomy debuggowania ............................................................................................654 Operacje na bitach...........................................................................................................660 Operator AND...........................................................................................................661 Operator OR..............................................................................................................661 Operator XOR...........................................................................................................661 Operator negacji........................................................................................................661 Ustawianie bitów ......................................................................................................661 Zerowanie bitów .......................................................................................................662 Zmiana stanu bitów na przeciwny ............................................................................662 Pola bitowe................................................................................................................663 Styl ..................................................................................................................................666 Wcięcia .....................................................................................................................666 Nawiasy klamrowe....................................................................................................666 Długość linii..............................................................................................................666 Instrukcje switch .......................................................................................................667 Tekst programu .........................................................................................................667 Nazwy identyfikatorów.............................................................................................668 Komentarze ...............................................................................................................669 Dostęp .......................................................................................................................670 Definicje klas ............................................................................................................670 Dołączanie plików ....................................................................................................670 assert().......................................................................................................................671 const ..........................................................................................................................671 Następne kroki.................................................................................................................671 Gdzie uzyskać pomoc i poradę .................................................................................671 Przejść do C#?...........................................................................................................672 Bądź w kontakcie......................................................................................................672 Program podsumowujący wiadomości............................................................................672 Dodatki .......................................................................................683 Dodatek A Dwójkowo i szesnastkowo..............................................................685 Inne podstawy .................................................................................................................686 Wokół podstaw................................................................................................................686 Dwójkowo.................................................................................................................688 Dlaczego podstawa 2?...............................................................................................689 Bity, bajty, nible........................................................................................................689 Co to jest KB?...........................................................................................................690 Liczby dwójkowe......................................................................................................690 Szesnastkowo ..................................................................................................................691 Dodatek B Słowa kluczowe C++ ......................................................................695 Dodatek C Kolejność operatorów.....................................................................697 Skorowidz.........................................................................................................699 Rozdział 6. Klasy rozszerzają wbudowane w C++ możliwości, ułatwiające rozwiązywanie złożo- nych, „rzeczywistych” problemów. Z tego rozdziału dowiesz się:  czym są klasy i obiekty,  jak definiować nową klasę oraz tworzyć obiekty tej klasy,  czym są funkcje i dane składowe,  czym są konstruktory i jak z nich korzystać. Czy C++ jest zorientowane obiektowo? Język C++ stanowi pomost pomiędzy programowaniem zorientowanym obiektowo a językiem C, najpopularniejszym językiem programowania aplikacji komercyjnych. Celem jego autorów było stworzenie obiektowo zorientowanego języka dla tej szyb- kiej i efektywnej platformy. Język C jest etapem pośrednim pomiędzy wysokopoziomowymi językami aplikacji „firmowych”, takimi jak COBOL, a niskopoziomowym, wysokowydajnym, lecz trud- nym do użycia asemblerem. C wymusza programowanie „strukturalne”, w którym po- szczególne zagadnienia są dzielone na mniejsze jednostki powtarzalnych działań, zwanych funkcjami. Programy, które piszemy na początku dwudziestego pierwszego wieku, są dużo bar- dziej złożone niż te, które były pisane pod koniec wieku dwudziestego. Programy stworzone w językach proceduralnych są trudne w zarządzaniu i konserwacji, a ich 130 Część I rozbudowa jest niemożliwa. Graficzne interfejsy użytkownika, Internet, telefonia cy- frowa i bezprzewodowa oraz wiele innych technologii, znacznie zwiększyły poziom skomplikowania nowych projektów, a wymagania konsumentów dotyczące jakości interfejsu użytkownika wzrosły. W obliczu rosnących wymagań, programiści bacznie przyjrzeli się przemysłowi in- formatycznemu. Wnioski, do jakich doszli, były co najmniej przygnębiające. Opro- gramowanie powstawało z opóźnieniem, posiadało błędy, działało niestabilnie i było drogie. Projekty regularnie przekraczały budżet i trafiały na rynek z opóźnieniem. Koszt obsługi tych projektów był znaczny, zmarnowano ogromne ilości pieniędzy. Jedynym wyjściem z tej sytuacji okazało się tworzenie oprogramowania zorientowa- nego obiektowo. Języki programowania obiektowego stworzyły silne więzy pomiędzy strukturami danych a metodami manipulowania tymi danymi. A co najważniejsze, w programowaniu zorientowanym obiektowo nie już musisz myśleć o strukturach da- nych i manipulujących nimi funkcjami; myślisz o obiektach. Rzeczach. Świat jest wypełniony przedmiotami: samochodami, psami, drzewami, chmurami, kwiatami. Rzeczy. Każda rzecz ma charakterystykę (szybki, przyjazny, brązowy, pu- szysty, ładny). Większość rzeczy cechuje jakieś zachowanie (ruch, szczekanie, wzrost, deszcz, uwiąd). Nie myślimy o danych psa i o tym, jak moglibyśmy nimi ma- nipulować — myślimy o psie jako o rzeczy: do czego jest podobny i co robi. Tworzenie nowych typów Poznałeś już kilka typów zmiennych, m.in. liczby całkowite i znaki. Typ zmiennej dostarcza nam kilka informacji o niej. Na przykład, jeśli zadeklarujesz zmienne /(cid:3) 18 (wysokość) i .8 (szerokość) jako liczby całkowite typu 92712/.736828, wiesz, że w każdej z nich możesz przechować wartość z przedziału od 0 do 65 535 (przy założeniu że typ 92712/.736828 zajmuje dwa bajty pamięci). Są to liczby całkowite bez znaku; próba przechowania w nich czegokolwiek innego powoduje błąd. W zmiennej typu 92712/. 7368 nie możesz umieścić swojego imienia, nie powinieneś nawet próbować. Deklarując te zmienne jako 92712/. 7368 28, wiesz, że możesz dodać do siebie wysokość i szerokość oraz przypisać tę wartość innej zmiennej. Typ zmiennych informuje:  o ich rozmiarze w pamięci,  jaki rodzaj informacji mogą zawierać,  jakie działania można na nich wykonywać. Rozdział 6.  Programowanie zorientowane obiektowo 131 W tradycyjnych językach, takich jak C, typy były wbudowane w język. W C++ pro- gramista może rozszerzyć język, tworząc potrzebne mu typy, zaś każdy z tych nowy
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C++ dla każdego
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ą: