C++ dla każdego [PDF]

Zitiervorschau

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

Dedykacja Książka ta jest dedykowana pamięci Davida Levine.

Część 1.

Rozdział 1. Zaczynamy Wprowadzenie Witamy w „C++ dla każdego.” Ten rozdział pomoże ci efektywnie programować w C++. Dowiesz się z niego: ·

dlaczego C++ jest standardowym językiem tworzenia oprogramowania

·

Jakie kroki należy wykonać przy opracowaniu programu w C++

·

w jaki sposób wpisać, skompilować i zbudować swój pierwszy, działający program w C++.

Krótka historia języka C++ Od czasu pierwszych komputerów elektronicznych, zbudowanych do wspomagania artyleryjskich obliczeń trajektorii podczas drugiej wojny światowej, języki programowania przebyły długą drogę. Na początku programiści używali najbardziej prymitywnych instrukcjami komputera: języka maszynowego. Te instrukcje były zapisywane jako długie ciągi zer i jedynek. Dlatego wymyślono tzw. asemblery, zamieniające instrukcje maszynowe na czytelne dla człowieka i łatwiejsze do zapamiętania mnemoniki, takie jak ADD czy MOV. Z czasem pojawiły się języki wyższego poziomu, takie jak BASIC czy COBOL. Te języki umożliwiały stosowanie zapisu przypominającego słowa i zdania, np. LET I = 100. Te instrukcje były tłumaczone przez interpretery i kompilatory na język maszynowy.

1

Interpreter tłumaczy odczytywany program, bezpośrednio zamieniając jego instrukcje (czyli kod) na działania. Kompilator natomiast tłumaczy kod na pewną formę pośrednią. Ten proces jest nazywany kompilacją; w jej wyniku otrzymujemy plik obiektowy. Następnie kompilator wywołuje program łączący (tzw. linker), który zamienia plik obiektowy na program wykonywalny. Ponieważ interpretery odczytują kod programu bezpośrednio i wykonują go na bieżąco, są łatwiejsze w użyciu dla programistów. Obecnie większość programów interpretowanych jest nazywanych skryptami, zaś sam interpreter nosi nazwę Script Engine (w wolnym tłumaczeniu: motor skryptu). Niektóre języki, takie jak Visual Basic, nazywają interpreter biblioteką czasu działania. Java nazywa swój interpreter maszyną wirtualną (VM, Virtual Machine), jednak w pewnych przypadkach taka maszyna wirtualna jest dostarczana przez przeglądarkę WWW (taką jak Internet Explorer lub Netscape). Kompilatory wymagają wprowadzenia dodatkowego kroku związanego z kompilowaniem kodu źródłowego (czytelnego dla człowieka) na kod obiektowy (czytelny dla maszyny). Ten dodatkowy krok jest dość niewygodny, ale dzięki niemu kompilowane programy działają bardzo szybko, gdyż czasochłonne zadanie przetłumaczenia kodu źródłowego na język maszynowy jest wykonywane tylko raz (podczas kompilacji) i nie jest już konieczne podczas działania programu. Kolejną zaletą wielu języków kompilowanych (takich jak C++) jest posiadanie tylko programu wykonywalnego (bez konieczności posiadania interpretera). W przypadku języka interpretowanego, do uruchomienia programu konieczne jest posiadanie interpretera. Przez wiele lat głównym celem programistów było uzyskanie niewielkich fragmentów szybko działającego kodu. Programy musiały być niewielkie, gdyż pamięć była droga; musiały być także szybkie, gdyż droga była również moc obliczeniowa. Gdy komputery stały się mniejsze, tańsze i szybsze, a także gdy spadła cena pamięci, te priorytety uległy zmianie. Obecnie czas pracy programisty jest dużo droższy niż koszty eksploatacji większości komputerów wykorzystywanych w codziennej pracy. Teraz najważniejszy jest dobrze napisany, łatwy w konserwacji kod. Łatwość konserwacji oznacza, że gdy zmienią się wymagania wobec działania programu, program można zmienić i rozbudować, bez ponoszenia większych wydatków.

UWAGA Słowo „program” jest używane w dwóch kontekstach: w odniesieniu do poszczególnych instrukcji (kodu źródłowego), tworzonego przez programistę odniesieniu się do całego programu przyjmujacego postać pliku wykonywalnego. powodować znaczne nieporozumienia, w związku z czym będziemy starać się rozróżnienia pomiędzy kodem źródłowym a plikiem wykonywalnym.

zestawu oraz w Może to dokonać

Rozwiązywanie problemów Problemy, które obecnie rozwiązują programiści, są zupełnie inne niż problemy rozwiązywane dwadzieścia lat temu. W latach osiemdziesiątych programy były tworzone w celu zarządzania

2

dużymi ilościami nie poddanych obróbce danych danych. Zarówno osoby piszące kod, jak i osoby korzystające z programów, zajmowały się komputerami profesjonalnie. Obecnie z komputerów korzysta dużo osób, większość z nich ma niewielkie pojęcie o tym, jak działa program i komputer. Komputery są narzędziem używanym przez ludzi do konkretnej pracy, a nie w celu dodatkowego zmagania się z samym komputerem. Można uważać za ironię, że wraz z pojawieniem się coraz łatwiejszych do opanowania przez ogół użytkowników programów, tworzymy programy, które same w sobie stają się coraz bardziej wymyślne i skomplikowane. Minęły już czasy wpisywania przez użytkownika tajemniczych poleceń po znaku zachęty, które powodowały wyświetlenie strumienia nie przetworzonych danych. Obecne programy korzystają z wymyślnych „przyjaznych interfejsów użytkownika”, posiadających wiele okien, menu, okien dialogowych oraz innych elementów, które wszyscy dobrze znamy. Wraz z rozwojem sieci WWW, komputery wkroczyły w nową erę penetracji rynku; korzysta z nicj więcej osób niż kiedykolwiek, a ich oczekiwania są bardzo duże. Przez kilka lat, jakie upłynęły od czasu pierwszego wydania tej książki, programy stały się bardziej złożone, w związku z czym powstało zapotrzebowanie na pomocne w ich opanowaniu techniki programistyczne. Wraz ze zmianą wymagań dotyczących oprogramowania, zmieniły się także same języki i technika pisania programów. Choć historia tych przemian jest fascynująca, w tej książce skupimy się na transformacjach jakie nastąpiły w trakcie przejścia od programowania proceduralnego do programowania obiektowego.

Programowanie proceduralne, strukturalne i obiektowe Do niedawna program był traktowany jako seria procedur, działających na danych. Procedura (funkcja) jest zestawem specyficznych, wykonywanych jedna po drugiej instrukcji. Dane były całkowicie odseparowane od procedur, zaś zadaniem programisty było zapamiętanie, która funkcja wywołuje inne funkcje, oraz jakie dane były w wyniku tego zmieniane. W celu uniknięcia wielu potencjalnych błędów opracowane zostało programowanie strukturalne. Główną ideą programowania strukturalnego jest: „dziel i rządź.” Program komputerowy może być uważany za zestaw zadań. Każde zadanie, które jest zbyt skomplikowane aby można było je łatwo opisać, jest rozbijane na zestaw mniejszych zadań składowych, aż do momentu gdy, wszystkie zadania są wystarczająco łatwe do zrozumienia. Na przykład, obliczenie przeciętnej pensji przeciętnego pracownika przedsiębiorstwa jest dość złożonym zadaniem. Można je jednak podzielić na następujące podzadania: 1. Obliczenie, ile zarabiają poszczególne osoby. 2. Policzenie ilości pracowników. 3. Zsumowanie wszystkich pensji.

3

4. Podzielenie tej sumy przez ilość pracowników. Sumowanie pensji można podzielić na następujące kroki: 1. Odczytanie danych dotyczących każdego pracownika. 2. Odwołanie się do danych dotyczących pensji. 3. Dodanie pensji do naliczanej sumy. 4. Przejście do danych dotyczących następnego pracownika. Z kolei, uzyskanie danych na temat pracownika można rozbić na: 1. Otwarcie pliku pracowników. 2. Przejście do właściwych danych. 3. Odczyt danych z dysku. Programowanie strukturalne stanowi niezwykle efektywny sposób rozwiązywania złożonych problemów. Jednak pod koniec lat osiemdziesiątych ograniczenia takiej metody programowania objawiły się aż nazbyt jasno. Po pierwsze, w trakcie tworzenia oprogramowania naturalnym dążeniem jest traktowanie danych (na przykład danych pracownika) oraz tego, co można z nimi zrobić (sortować, modyfikować, itd.), jako pojedynczej całości. Niestety, w programowaniu strukturalnym struktury danych są oddzielone od manipulujących nimi funkcji, a w programie strukturalnym nie istnieje naturalny sposób ich połączenia. Programowanie strukturalne jest często nazywane programowaniem proceduralnym, gdyż skupia się na procedurach (a nie na „obiektach”). Po drugie, programiści zmuszeni są wciąż wymyślać nowe rozwiązania starych problemów. Czasem nazywa się to „wymyślaniem koła”; stanowi to przeciwieństwo „ponownego wykorzystania.” Idea ponownego wykorzystania oznacza tworzenie komponentów, posiadających znane wcześniej właściwości, które mogą być w miarę potrzeb dołączane do programu. Pomysł został zapożyczony z rozwiązań sprzętowych — gdy inżynier potrzebuje nowego tranzystora, zwykle nie musi go wymyślać — przegląda duże pudło z tranzystorami i wybiera ten, który spełnia dane wymagania, ewentualnie tylko nieco go modyfikując. Inżynier oprogramowania nie miał podobnej możliwości. Na to zapotrzebowanie próbuje odpowiedzieć programowanie zorientowane obiektowo, dostarcza ono technik zarządzania złożonymi elementami, umożliwia ponowne wykorzystanie komponentów i łączy w logiczną całość dane oraz manipulujące nimi funkcje. Zadaniem programowania zorientowanego obiektowo jest modelowanie „obiektów” (tzn. rzeczy), a nie „danych.” Modelowanymi obiektami mogą być zarówno elementy na ekranie, takie jak przyciski czy pola list, jak i obiekty świata rzeczywistego, np. motocykle, samoloty, koty czy

4

woda. Obiekty posiadają charakterystyki (szybki, obszerny, czarny, mokry) oraz możliwości (przyspieszanie, latanie, mruczenie, bulgotanie). Zadaniem programowania zorientowanego obiektowo jest reprezentacja tych obiektów w języku programowania.

C++ i programowanie zorientowane obiektowo Język C++ wspiera programowanie zorientowane obiektowo, obejmuje swym działaniem trzy podstawy takiego stylu programowania: kapsułkowanie, dziedziczenie oraz polimorfizm.

Kapsułkowanie Gdy inżynier chce dodać do tworzonego urządzenia rezystor, zwykle nie buduje go samodzielnie od początku — podchodzi do pojemnika z rezystorami, sprawdza kolorowe paski, oznaczające właściwości, i wybiera potrzebny element. Z punktu widzenia inżyniera rezystor jest „czarną skrzynką” — nieważny jest sposób w jaki działa (o ile tylko zachowuje się zgodnie ze swoją specyfikacją). Inżynier nie musi zastanawiać się nad wnętrzem rezystora, aby użyć go w swoim projekcie. Właściwość samozawierania się jest nazywana kapsułkowaniem. W kapsułkowaniu możemy zakładać opcję ukrywania danych. Ukrywanie danych jest możliwością, dzięki której obiekt może być używany przez osobę nie posiadającą wiedzy o tym, w jaki sposób działa. Skoro możemy korzystać z lodówki bez znajomości zasad działania kompresora, możemy też użyć dobrze zaprojektowanego obiektu nie znając jego wewnętrznych danych składowych. Sytuacja wygląda podobnie, gdy z rezystora korzysta inżynier: nie musi wiedzieć niczego o jego wewnętrznym stanie. Wszystkie właściwości rezystora są zakapsułkowane w obiekcie rezystora (nie są rozrzucone po całym układzie elektronicznym). Do efektywnego korzystania z rezystora nie jest potrzebna wiedza o sposobie jego działania. Można powiedzieć, że jego dane są ukryte wewnątrz obudowy. C++ wspiera kapsułkowanie poprzez tworzenie typów zdefiniowanych przez użytkownika, zwanych klasami. O tym, jak tworzyć klasy, dowiesz się z rozdziału szóstego, „Programowanie zorientowane obiektowo.” Po stworzeniu, dobrze zdefiniowana klasa działa jako spójna całość — jest używana jako jednostka. Wewnętrzne działanie klasy powinno być ukryte. Użytkownicy dobrze zdefiniowanych klas nie muszą wiedzieć, w jaki sposób one działają; muszą jedynie wiedzieć, jak z nich korzystać.

Dziedziczenie i ponowne wykorzystanie Gdy inżynierowie z Acme Motors chcą zbudować nowy samochód, mają do wyboru dwie możliwości: mogą zacząć od początku lub zmodyfikować istniejący już model. Być może ich model, Gwiazda, jest prawie doskonały, ale chcą do niego dodać turbodoładowanie i sześciobiegową skrzynię biegów. Główny inżynier nie chciałby zaczynać od początku, zamiast tego wolałby zbudować nowy, podobny model, z tym dodatkowym wyposażeniem. Nowy model ma nosić nazwę Kwazar. Kwazar jest rodzajem Gwiazdy, wyposażonym w nowe elementy

5

(według NASA, kwazary są bardzo jasnymi ciałami, wydzielającymi ogromne ilości energii). C++ wspiera dziedziczenie. Można dzięki niemu deklarować nowe typy, będące rozszerzeniem istniejących już typów. Mówi się, że nowa podklasa jest wyprowadzona z istniejącego typu i czasem nazywa się ją typem wyprowadzonym (pochodnym). Kwazar jest wyprowadzony z Gwiazdy i jako taki dziedziczy jej możliwości, ale w razie potrzeby może je uzupełnić lub zmodyfikować. Dziedziczenie i jego zastosowania w C++ zostaną omówione w rozdziale dwunastym, „Dziedziczenie” oraz szesnastym, „Zaawansowane dziedziczenie.”

Polimorfizm Nowy Kwazar może reagować na naciśnięcie pedału gazu inaczej niż Gwiazda. Kwazar może korzystać z wtrysku paliwa i turbodoładowania, natomiast w Gwieździe benzyna po prostu wpływa do gaźnika. Użytkownik jednak nie musi wiedzieć o tych różnicach, po prostu naciska na pedał gazu i samochód robi to, co do niego należy, bez względu na to, jakim jest pojazdem. C++ sprawia że różne obiekty „robią odpowiednie rzeczy” poprzez mechanizm zwany polimorfizmem funkcji i polimorfizmem klas. „Poli” oznacza wiele, zaś „morfizm” oznacza w tym przypadku formę. Pojęcie „polimorfizm” oznacza, że ta sama nazwa może przybierać wiele form, zostanie ono szerzej omówione w rozdziale dziesiątym, „Funkcje zaawansowane” oraz czternastym, „Polimorfizm.”

Jak ewoluowało C++ Gdy powszechnie znane stały się analiza, projektowanie i programowanie zorientowane obiektowo, Bjarne Stroustrup sięgnął do najpopularniejszego języka przenaczonego do tworzenia komercyjnego oprogramowania, C, i rozszerzył go, uzupełniając o elementy umożliwiające programowanie zorientowane obiektowo. Choć C++ stanowi nadzbiór języka C, a wszystkie poprawne programy C są także poprawnymi programami C++, różnica pomiędzy C a C++ jest bardzo znacząca. C++ przez wiele lat czerpało korzyści ze swego pokrewieństwa z C, gdyż programiści mogli łatwo przejść z C do tego nowego języka. Aby w pełni skorzystać z jego zalet, wielu programistów musiał pozbyć się swoich przyzwyczajeń i nauczyć nowego sposobu formułowania i rozwiązywania problemów programistycznych.

Czy należy najpierw poznać C? Natychmiast nasuwa się więc pytanie: skoro C++ jest nadzbiorem C, to czy powinienem najpierw nauczyć się C? Stroustrup i większość innych programistów C++ nie tylko zgadza się, że wcześniejsze poznanie języka C nie jest konieczne, ale także że brak jego znajomości może stanowić pewną zaletę. Programowanie w C opiera się na programowaniu strukturalnym; natomiast C++ jest oparte na programowaniu zorientowanym obiektowo. Poznawanie języka C tylko po to, by „oduczyć” się

6

niepożądanych nawyków nabytych podczas pracy z C, jest błędem. Nie zakładamy że masz jakiekolwiek doświadczenie programistyczne. Jeśli jednak jesteś programistą C, kilka pierwszych rozdziałów tej książki będzie stanowić dla ciebie powtórzenie posiadanych już wiadomości. Prawdziwą pracę nad tworzeniem obiektowo zorientowanego oprogramowania zaczniemy dopiero od rozdziału szóstego.

C++ a Java i C# C++ jest obecnie dominującym językiem oprogramowania komercyjnego. W ostatnich latach pojawiła się dla niego silna konkurencja w postaci Javy, jednak „wahadło wróciło” i wielu programistów, którzy porzucili C++ dla Javy, zaczyna do niego powracać. Języki te są tak podobne, że opanowanie jednego jest równoznaczne z opanowaniem dziewięćdziesięciu procent drugiego. C# jest nowym językiem, opracowanym przez Microsoft dla platformy .Net. C# stanowi w zasadzie podzbiór C++, i choć oba języki różnią się w kilku zasadniczych sprawach, poznanie C++ oznacza poznanie około dziewięćdziesięciu procent C#. Upłynie jeszcze wiele lat, zanim przekonamy się, czy C# będzie poważnym konkurentem dla C++; jednak nawet, gdy tak się stanie, praca włożona w poznanie C++ z pewnością okaże się doskonałą inwestycją.

Standard ANSI Międzynarodowy standard języka C++ został stworzony przez komitet ASC (Accredited Standards Committee), działający w ramach ANSI (American National Standards Institute). Standard C++ jest nazywany standardem ISO (International Standards Organization), standardem NCITS (National Committee for Information Technology Standards), standardem X3 (starsza nazwa NCITS) oraz standardem ANSI/ISO. W tej książce będziemy odwoływali się do standardu ANSI, gdyż to określenie jest najbardziej popularne. Standard ANSI próbuje zapewnić przenośność C++ — zapewnia na przykład to, że kod zgodny ze standardem ANSI napisany dla kompilatora Microsoftu skompiluje się bez błędów w kompilatorze innego producenta. Ponieważ kod w tej książce jest zgodny ze standardem ANSI, powinien kompilować się bez błędów na Macintoshu, w Windows lub w komputerze z procesorem Alpha. Dla większości osób uczących się języka C++, standard ANSI będzie niewidoczny. Ten standard istnieje już od dłuższego czasu i obsługuje go większość głównych producentów. Włożyliśmy wiele trudu, by zapewnić że cały kod w tej książce jest zgodny z ANSI.

Przygotowanie do programowania

7

C++, bardziej niż inne języki, wymaga od programisty zaprojektowania programu przed jego napisaniem. Banalne problemy, takie jak te przedstawiane w kilku pierwszych rozdziałach książki, nie wymagają projektowania. Jednak złożone problemy, z którymi profesjonalni programiści zmagają się każdego dnia, wymagają projektowania; zaś im dokładniejszy i pełniejszy projekt, tym większe prawdopodobieństwo, że program rozwiąże problemy w zaplanowanym czasie, nie przekraczając budżetu. Dobry projekt sprawia także, że program jest w dużym stopniu pozbawiony błędów i łatwy w konserwacji. Obliczono, że połączony koszt debuggowania i konserwacji stanowi co najmniej dziewięćdziesiąt procent kosztów tworzenia oprogramowania. Ponieważ dobry projekt może te koszty zredukować, staje się ważnym czynnikiem wpływającym na ostateczne wydatki związane z tworzenia programu. Pierwszym pytaniem, jakie powinniśmy zadać, przygotowując się do projektowania programu jest: jaki problem ma zostać rozwiązany? Każdy program powinien ustanawiać jasny, dobrze określony celem – przekonasz się, że w tej książce nawet najprostszy program spełnia ten postulat. Drugie pytanie, stawiane przez każdego dobrego programistę, to: czy można to osiągnąć bez konieczności pisania własnego oprogramowania? Ponowne wykorzystanie starego programu, użycie pióra i papieru lub zakup istniejącego oprogramowania, jest często lepszym rozwiązaniem problemu niż pisanie nowego programu. Programista znajdujący takie alternatywy nigdy nie będzie narzekał na brak pracy; znajdowanie najtańszych rozwiązań dzisiejszych problemów otwiera nowe możliwości na przyszłość. Zakładając, że rozumiesz problem, i że wymaga on napisania nowego programu, jesteś gotów do rozpoczęcia projektowania. Proces pełnego zrozumienia problemu (analiza) i znajdowania jego rozwiązania (projekt) stanowi niezbędną podstawę dla pisania komercyjnych aplikacji na najwyższym, profesjonalnym poziomie.

Twoje środowisko programowania Zakładamy, że twój kompilator posiada tryb, w którym może wypisywać tekst bezpośrednio na ekranie, bez konieczności wykorzystania środowiska graficznego, na przykład Windows czy Macintosh. Poszukaj opcji takiej, jak console, console wizard czy easy window lub przejrzyj dokumentację kompilatora. Kompilator może posiadać własny, wbudowany edytor tekstów, lub do tworzenia plików programów możesz użyć komercyjnego edytora lub procesora tekstów. Ważne jest, by bez względu na to, jaki program stosujemy, miał on możliwość zapisywania zwykłych plików tekstowych, nie zawierających osadzonych w tekście kodów i poleceń formatowania. Bezpiecznymi pod tym względem edytorami są na przykład Notatnik w Windows, program Edit w DOS-ie, Brief, Epsilon, Emacs i vi. Wiele komercyjnych procesorów tekstu, takich jak WordPerfect, Word czy tuziny innych, także oferuje możliwość zapisywania zwykłych plików tekstowych. Pliki tworzone za pomocą edytora tekstów są nazywane plikami źródłowymi, w przypadku języka

8

C++ zwykle posiadają nazwy z rozszerzeniem .cpp, .cp lub .c. W tej książce wszystkie pliki źródłowe posiadają rozszerzenie .cpp, ale sprawdź w swoim kompilatorze, jakich plików oczekuje. UWAGA Większość kompilatorów C++ nie „zwraca uwagi” na rozszerzenia nadawane nazwom plików źródłowych, ale jeśli nie określisz tych plików, wiele z nich domyślnie korzysta z rozszerzenia .cpp. Należy jednak zachować ostrożność, gdyż niektóre kompilatory traktują pliki .c jako pliki języka C, zaś pliki .cpp jako pliki języka C++. Sprawdź koniecznie dokumentację kompilatora.

Tak

Nie

Do tworzenia plików źródłowych używaj prostego edytora tekstów lub skorzystaj z edytora wbudowanego w kompilator.

Nie używaj procesora tekstów zapisującego wraz z tekstem specjalne znaki formatujące. Jeśli korzystasz z takiego procesora, zapisuj pliki jako tekst ASCII.

Zapisuj pliki, nadając im rozszerzenie .c, .cp lub .cpp. Sprawdź w dokumentacji kompilatora i linkera, w jaki sposób należy kompilować i budować programy.

Tworzenie programu Choć kod źródłowy w pliku wygląda na niezrozumiały i każdy, kto nie zna C++, będzie miał trudności ze zrozumieniem jego przeznaczenia, kod ten przyjmuje czytelną dla człowieka postać. Plik kodu źródłowego nie jest programem i, w odróżnieniu od pliku wykonywalnego, nie może zostać wykonany (uruchomiony).

Tworzenie pliku obiektowego za pomocą kompilatora Do zamiany kodu źródłowego w program używamy kompilatora. Sposób uruchomienia go i wskazania mu plików źródłowych zależy od konkretnego kompilatora; sprawdź w tym celu posiadaną przez ciebie dokumentację. Gdy kod źródłowy zostanie skompilowany, tworzony jest plik obiektowy. Ten plik ma często rozszerzenie .obj – jednak w dalszym ciągu nie jest to program wykonywalny. Aby zmienić go w program wykonywalny, należy użyć tzw. linkera, czyli programu łączącego.

9

Tworzenie pliku wykonywalnego za pomocą linkera Programy C++ zwykle powstają w wyniku łączenia jednego lub więcej plików .obj z jedną lub więcej bibliotekami. Biblioteka (ang. library) jest zbiorem połączonych plików, dostarczanym wraz z kompilatorem. Może też zostać nabyta osobno lub stworzona i skompilowana samodzielnie. Wszystkie kompilatory C++ są dostarczane wraz z bibliotekami użytecznych funkcji (lub procedur) oraz klas, które można zastosować w programie. O klasach i funkcjach porozmawiamy szczegółowo w następnych rozdziałach. Kroki konieczne do stworzenia pliku wykonywalnego to: 1. Stworzenie pliku kodu źródłowego z rozszerzeniem .cpp. 2. Skompilowanie kodu źródłowego do pliku z rozszerzeniem .obj. 3. Połączenie pliku .obj z wymaganymi bibliotekami w celu stworzenia programu wykonywalnego.

Cykl tworzenia programu Gdyby każdy program zadziałał już przy pierwszej próbie uruchomienia, wtedy pełny cykl tworzenia wyglądałby następująco: pisanie programu, kompilowanie kodu źródłowego, łączenie plików .obj, uruchomienie programu wykonywalnego. Niestety, prawie każdy program (nawet najbardziej trywialny) może zawierać błędy, często nazywane „pluskwami”. Niektóre błędy uniemożliwiają kompilację, inne uniemożliwiają łączenie, zaś jeszcze inne objawiają się dopiero podczas działania programu. Bez względu na rodzaj błędu, należy go poprawić – oznacza to edycję kodu źródłowego, ponowną kompilacja i łączenie, oraz ponowne uruchomienie programu. Cały ten cykl został przedstawiony na rysunku 1.1, schematycznie obrazuje on kolejne kroki w cyklu tworzenia programu wykonywalnego.

Rys. 1.1. Kroki wykonywane podczas tworzenia programu w języku C++

10

HELLO.cpp — twój pierwszy program w C++ Tradycyjne książki o programowaniu zaczynają od wypisania na ekranie słów „Witaj Świecie” lub od innej „wariacji na ten temat”. Ta uświecona tradycją formuła zostanie zachowana także i tu.

11

Wpisz swój pierwszy program bezpośrednio do edytora, dokładnie przepisując jego treść. Gdy będziesz pewien, że został wpisany poprawnie, zapisz go do pliku, skompiluj, połącz i uruchom. Program wypisze na ekranie słowa „Witaj Świecie”. Nie martw się na razie tym, jak działa; teraz powinieneś jedynie poznać cykl tworzenia programu. Każdy element programu zostanie omówiony w kilku następnych rozdziałach. OSTRZEŻENIE Na przedstawionym poniżej listingu po lewej stronie umieszczone zostały numery linii. Te numery służą jedynie jako punkty odniesienia dla opisu w tekście. Nie należy ich wpisywać do kodu programu. Na przykład, w linii 1. listingu 1.1 należy wpisać: #include

Listing 1.1. HELLO.cpp, program „Witaj Świecie”. 0: 1: 2: 3: 4: 5: 6:

#include int main() { std::cout