C++ w dwunastu długich krokach

Uniwersytet Wrocławski Wydział Fizyki i Astronomii Zbigniew Koza C++ w dwunastu długich krokach Wrocław 2006

Redakcja techniczna, opracowanie tekstu i skład: Zbigniew Koza Copyright c 2006 by Zbigniew Koza and Uniwersytet Wrocławski Drukarnia Uniwersytetu Wrocławskiego Plac Solny 12, 50-061 Wrocław tel. 713438389, 713752305, fax 713447258

Wszystkim Kózkom dużym i małym

Spis treści 1 Pierwszy program w C++ 13 1.1 Dla kogo jest ta książka?........................ 13 1.2 Rys historyczny............................. 13 1.2.1 Dlaczego C++?......................... 14 1.2.2 C++ a C............................ 16 1.2.3 Aktualny standard języka................... 16 1.3 Zanim napiszemy swój pierwszy program.............. 16 1.3.1 Środowisko programistyczne.................. 16 1.4 Pierwszy program........................... 18 1.4.1 Kompilacja kodu źródłowego................. 18 1.4.2 Błędy kompilacji........................ 19 1.4.3 Uruchamianie programu w środowisku Dev-C++...... 20 1.4.4 Struktura prostego programu w C++............ 20 1.5 Obiekt std::cout i literały...................... 21 1.6 Definiowanie obiektów......................... 22 1.7 Identyfikatory, słowa kluczowe i dyrektywy............. 24 1.8 Zapis programu............................. 24 1.9 Cztery działania matematyczne i typ double............ 25 1.10 Jeszcze więcej matematyki....................... 26 1.11 Upraszczanie zapisu obiektów i funkcji biblioteki standardowej.. 28 1.12 Źródła informacji............................ 28 1.13 Q & A.................................. 29 1.14 Quiz................................... 30 1.15 Problemy................................ 30 2 Wyrażenia i instrukcje 31 2.1 Instrukcje sterujące........................... 31 2.1.1 Instrukcja if... else...................... 31 2.2 Pętle................................... 33 2.2.1 Pętla for............................ 33 2.2.2 Pętle while i do........................ 35 2.2.3 Instrukcje break i continue................. 35 2.3 Typy wbudowane............................ 36 2.3.1 Typy całkowite......................... 36 2.3.2 Typy zmiennopozycyjne.................... 38 2.3.3 Typ logiczny.......................... 40 2.3.4 Zapis literałów całkowitych i zmiennopozycyjnych..... 40 5

6 Spis treści 2.4 Wyrażenia arytmetyczne, promocje i konwersje standardowe.... 41 2.5 Tworzenie obiektów stałych...................... 43 2.5.1 Modyfikator const....................... 43 2.6 Popularne typy standardowe...................... 44 2.6.1 Strumienie........................... 44 2.6.2 Napisy.............................. 46 2.6.3 Wektory............................. 47 2.6.4 Słowniki............................. 49 2.7 Obiekty lokalne i globalne. Zasięg. Przesłanianie.......... 50 2.8 Operatory................................ 51 2.8.1 Priorytet operatorów...................... 53 2.8.2 Łączność operatorów...................... 53 2.8.3 Wartość operatorów...................... 53 2.8.4 Opis wybranych operatorów.................. 53 2.8.5 Operatorowe patologie..................... 56 2.9 Wyrażenia i instrukcje......................... 56 2.10 Q & A.................................. 57 2.11 Quiz................................... 57 2.12 Problemy................................ 58 3 Funkcje 59 3.1 Referencje................................ 59 3.2 Funkcje swobodne........................... 60 3.3 Po co są funkcje?............................ 62 3.4 Funkcje składowe wprowadzenie................... 64 3.5 Argumenty funkcji........................... 64 3.5.1 Przekazywanie argumentów przez wartość.......... 64 3.5.2 Przekazywanie argumentów przez referencję......... 64 3.5.3 Przekazywanie argumentów przez stałą referencję...... 65 3.6 Funkcje zwracające referencję..................... 67 3.7 Operatory jako funkcje swobodne................... 68 3.8 Stos funkcji............................... 71 3.9 Funkcje otwarte (inline)....................... 73 3.10 Funkcje jako argumenty innych funkcji................ 75 3.11 Rekurencja............................... 75 3.12 Argumenty domyślne.......................... 76 3.13 Lokalne obiekty statyczne....................... 77 3.14 Funkcja main.............................. 79 3.14.1 Argumenty funkcji main.................... 79 3.14.2 Wartość funkcji main...................... 79 3.15 Polimorfizm nazw funkcji....................... 80 3.16 Deklaracja a definicja funkcji..................... 80 3.17 Q & A.................................. 81 3.18 Quiz................................... 81 3.19 Problemy................................ 82

Spis treści 7 4 Tablice i wskaźniki 83 4.1 Wskaźniki................................ 83 4.1.1 Definiowanie wskaźników................... 83 4.1.2 Wskaźniki typu void*, czyli wycieczka w stronę C..... 85 4.1.3 Wskaźnik zerowy........................ 85 4.1.4 Czym grozi nieumiejętne użycie wskaźników?........ 85 4.1.5 Wskaźniki stałe i wskaźniki na stałe............. 86 4.1.6 Wskaźniki na wskaźniki.................... 86 4.2 Tablice.................................. 87 4.2.1 Tablice wielowymiarowe.................... 88 4.2.2 Inicjalizacja tablic....................... 88 4.2.3 Zastosowanie operatora sizeof do tablic.......... 90 4.2.4 Tablice a wskaźniki....................... 90 4.2.5 Tablice wskaźników i wskaźniki na tablice.......... 91 4.2.6 Tablice jako argumenty funkcji................ 91 4.2.7 Teksty literalne i tablice znaków............... 92 4.2.8 Porównanie tablic i wektorów................. 93 4.3 Pamięć wolna (sterta)......................... 94 4.4 Q & A.................................. 96 4.5 Quiz................................... 97 4.6 Problemy................................ 97 5 Klasy i obiekty 99 5.1 Struktury................................ 99 5.1.1 Podstawowe zasady definiowania i używania struktur.... 99 5.1.2 Inicjalizacja struktur...................... 101 5.1.3 Dostęp do składowych poprzez wskaźnik........... 101 5.2 Co to są klasy?............................. 101 5.3 Definiowanie klas............................ 102 5.3.1 Klasa jako zmodyfikowana struktura............ 102 5.3.2 Konstruktory.......................... 103 5.3.3 Destruktor........................... 106 5.4 Funkcje składowe (metody)...................... 107 5.4.1 Metody i metody stałe..................... 108 5.4.2 Przeciążanie operatorów w klasie............... 109 5.4.3 Konstruktor kopiujący i operator =.............. 110 5.4.4 Wskaźnik this......................... 112 5.5 Udostępnianie składowych....................... 113 5.5.1 Sekcje public i private.................... 113 5.5.2 Funkcje i klasy zaprzyjaźnione................ 114 5.6 Interfejs i implementacja........................ 115 5.6.1 Podział definicji klasy na interfejs i implementację..... 115 5.7 Kontrakty, niezmienniki i asercje................... 118 5.7.1 Kontrakty............................ 118 5.7.2 Niezmienniki.......................... 119 5.8 Hermetyzacja danych.......................... 120 5.9 Różnice między klasami i strukturami................ 120 5.10 Dygresja: składowe statyczne..................... 121 5.11 Quiz................................... 122

8 Spis treści 5.12 Problemy................................ 123 6 Dynamiczne struktury danych 125 6.1 Stos na bazie tablicy dynamicznej.................. 125 6.1.1 Interfejs stosu.......................... 125 6.1.2 Implementacja stosu...................... 126 6.1.3 Test stosu............................ 131 6.2 Stos na bazie listy pojedynczo wiązanej............... 132 6.2.1 Rekurencyjne struktury danych................ 133 6.2.2 Interfejs klasy.......................... 133 6.2.3 Implementacja......................... 134 6.3 Dygresja: przestrzenie nazw i zagnieżdżanie definicji klas...... 136 6.4 Q & A.................................. 138 6.5 Quiz................................... 138 6.6 Problemy................................ 138 7 Dziedziczenie i polimorfizm 139 7.1 Dziedziczenie.............................. 139 7.1.1 Do czego służy dziedziczenie?................. 139 7.1.2 Definiowanie klasy pochodnej................. 141 7.1.3 Inicjalizacja klasy bazowej................... 142 7.1.4 Relacje X ma Y, X jest Y oraz X zarządza Y.... 144 7.1.5 Kolejność inicjalizacji i destrukcji obiektu.......... 146 7.1.6 Sekcja protected....................... 146 7.1.7 Zastępowanie (overridnig) funkcji składowych........ 147 7.2 Polimorfizm............................... 149 7.2.1 Niedoskonałości zwykłego dziedziczenia.......... 149 7.2.2 Definiowanie metod polimorficznych............. 151 7.2.3 vtable............................. 153 7.2.4 Dygresja: klasy abstrakcyjne................. 155 7.3 Jak to się robi w Qt?.......................... 156 7.4 Q & A.................................. 159 7.5 Quiz................................... 159 7.6 Problemy................................ 160 8 Strumienie 161 8.1 Strumienie buforowane i niebuforowane............... 161 8.2 Klawiatura, konsola, plik, strumień napisowy............ 162 8.3 Stan strumienia............................. 164 8.4 Manipulatory i formatowanie strumienia............... 164 8.4.1 Manipulator std::setw.................... 165 8.4.2 Manipulator std::setprecision............... 166 8.5 Strumienie wyjścia........................... 167 8.6 Strumienie wejścia........................... 167 8.6.1 Funkcje składowe get i getline............... 168 8.6.2 Inne funkcje operujące na strumieniach wejściowych.... 169 8.7 Przykład................................. 169 8.8 Quiz................................... 172 8.9 Problemy................................ 172

Spis treści 9 9 Biblioteki 173 9.1 Podział programu na pliki....................... 173 9.1.1 Zasady kompilacji programów podzielonych na pliki.... 174 9.1.2 Przygotowanie plików źródłowych i nagłówkowych..... 175 9.1.3 Kompilacja przy pomocy wiersza poleceń.......... 176 9.1.4 Kompilacja przy pomocy programu make.......... 178 9.1.5 Kompilacja przy pomocy projektów............. 179 9.1.6 Automatyzacja tworzenia pliku Makefile........... 181 9.2 Używanie gotowych bibliotek..................... 182 9.2.1 Dekorowanie nazw i deklaracja extern "C"......... 182 9.2.2 Przykłady............................ 183 9.3 Kompilacja i instalacja bibliotek z plików źródłowych........ 186 9.3.1 Przykłady............................ 186 9.3.2 Systemy kontroli wersji.................... 187 9.4 Quiz................................... 188 9.5 Problemy................................ 188 10 Preprocesor i szablony 189 10.1 Preprocesor............................... 189 10.1.1 Rola preprocesora w C++................... 189 10.1.2 Dyrektywy preprocesora.................... 190 10.1.3 Przykład............................ 193 10.1.4 Podsumowanie......................... 195 10.2 Szablony................................. 195 10.2.1 Szablony klas.......................... 195 10.2.2 Szablony funkcji składowych................. 198 10.2.3 Szablony funkcji swobodnych................. 199 10.2.4 Specjalizacja szablonu..................... 200 10.2.5 Używanie szablonów funkcji do upraszczania pracy z szablonami klas.......................... 201 10.2.6 Gdzie umieszczać definicje szablonów?............ 202 10.2.7 Szablony a programowanie generyczne............ 202 10.2.8 Dygresja: konstrukcja typedef................ 202 10.3 Quiz................................... 203 10.4 Problemy................................ 204 11 Wprowadzenie do STL 205 11.1 Co to jest STL?............................. 205 11.2 Pojemniki................................ 206 11.3 Iteratory................................. 206 11.3.1 Co to są iteratory?....................... 206 11.3.2 Przykład użycia iteratorów.................. 207 11.3.3 Rodzaje iteratorów....................... 209 11.4 Algorytmy................................ 209 11.4.1 Co to są algorytmy?...................... 209 11.4.2 Funktory............................ 210 11.4.3 Obiekty funkcyjne....................... 212 11.4.4 Wartości pobierane i zwracane przez algorytmy....... 213 11.4.5 Obiekty funkcyjne a efektywność szablonów funkcji..... 214

10 Spis treści 11.5 Wektory (std::vector)........................ 216 11.5.1 Opis szablonu std::vector<t>................ 216 11.5.2 Przykłady............................ 219 11.6 Liczby zespolone............................ 220 11.7 Napisy (std::string)......................... 221 11.8 Q & A.................................. 223 11.9 Quiz................................... 223 11.10Problemy................................ 224 12 Pojemniki i algorytmy 225 12.1 Przegląd pojemników STL....................... 225 12.1.1 Słowniki............................. 226 12.1.2 Zbiory.............................. 230 12.1.3 Wielosłowniki i wielozbiory.................. 231 12.1.4 Słowniki i zbiory mieszające.................. 231 12.1.5 Kolejki o dwóch końcach.................... 233 12.1.6 Listy............................... 234 12.1.7 Stosy, kolejki i kolejki priorytetowe.............. 234 12.1.8 Wektory i zbiory bitów.................... 236 12.1.9 Wektory numeryczne (std::valarray<t>)......... 237 12.2 Przegląd algorytmów swobodnych................... 237 12.2.1 Algorytmy niemodyfikujące.................. 238 12.2.2 Algorytmy modyfikujące.................... 239 12.2.3 Sortowanie........................... 242 12.2.4 Algorytmy numeryczne.................... 244 12.2.5 Inne algorytmy......................... 244 12.3 Kontrola poprawności użycia STL.................. 245 12.4 Składniki dodatkowe.......................... 245 12.5 Q & A.................................. 245 12.6 Problemy................................ 246 13 Co dalej? 247 A Wybrane opcje kompilatora g++ 249 B Dodatkowe elementy języka 251 B.1 Instrukcja goto............................. 251 B.2 Instrukcja switch........................... 251

Wstęp Niniejszy podręcznik stanowi zapis wykładu prowadzonego w 2006 r. w Instytucie Fizyki Uniwersytetu Wrocławskiego w ramach finansowanego ze środków Unii Europejskiej projektu Technologie Informatyczne od Podstaw. Wykład adresowany jest do osób pracujących, które znają już jakiś język programowania (np. Pascal, Basic, PHP) i chciałyby poznać język C++ w celu podniesienia swoich kwalifikacji. Dlaczego C++? Odpowiedź jest prosta w ciągu blisko dwudziestu lat swego istnienia C++ osiągnął status języka programowania najczęściej używanego w zastosowaniach komercyjnych. Co więcej, każdy kto pozna C++, niejako mimochodem nauczy się rozumieć drugi podstawowy język programowania język C i będzie miał znacznie ułatwioną drogę do opanowania wielu innych języków (np. Java, C#, bash). Decydujący wpływ na zakres zawartego tu materiału ma długość kursu 12 dwugodzinnych wykładów i tyleż ćwiczeń w laboratorium komputerowym. Odpowiada to zaledwie 80% typowego jednosemetralnego kursu uniwersyteckiego. Z własnego doświadczenia wykładowcy języka C++ wiem jednak, że w praktyce nawet dwa semestry nie starczają, by w pełni omówić wszystkie ważne aspekty programowania w C++. Dlatego w swoim wykładzie skoncentrowałem się na najważniejszych cechach języka. Mam nadzieję, że to ograniczenie wpłynie pozytywnie na jakość wykładu większość książek dostępnych obecnie w księgarniach jest bowiem bardzo rozwlekła, gdyż ich autorzy usiłują przedstawić kompletny opis języka, włącznie z tymi jego elementami, których sami nigdy w życiu nie używali. Natomiast mój podręcznik z założenia stawia sobie znacznie skromniejszy cel: rzetelne nauczenie Czytelnika podstawowych zasad programowania we współczesnym C++. Po zakończeniu kursu jego uczestnicy powinni móc uczestniczyć w typowym projekcie programistycznym i samodzielnie rozwijać swoje umiejętności w zakresie programowania, np. studiując odpowiednie biblioteki C lub C++ potrzebne do realizacji danego zadania. Język C++ jest trudny zarówno do nauczania, jak i uczenia się. Nie powstał bowiem (jak np. Pascal) w wyniku teoretycznych rozważań nad metodologią programowania; przeciwnie, C++ został zaprojektowany przez praktyków (a konkretnie przez Bjarne a Stroustrupa) jako narzędzie mające pomóc w rozwiązaniu problemów praktycznych. Problemów, dodajmy, które zazwyczaj objawiają się dopiero w dużych projektach i mają związek z wydajnością i kosztami pracy programistów. Tu właśnie tkwi źródło trudności związanych z dydaktyką C++: niemal wszystkie charakterystyczne elementy tego języka, które odróżniają go od takich języków, jak C czy Pascal, znajdują zastosowanie (i uzasadnienie) dopiero 11

12 Wstęp w dużych projektach. Tymczasem kurs poświęcony podstawom języka musi ograniczać się do omawiania krótkich programów; analogicznie ćwiczenia laboratoryjne muszą bazować na niewielkich projektach, które można zrealizować w ciągu kilku godzin. Ale jak osobę, która pisze wyłącznie programy liczące 100-200 wierszy i uparła się, by wszystkie zmienne (włącznie ze zmiennymi sterującymi pętli) umieszczać w przestrzeni globalnej ( bo tak szybciej ) przekonać, że popełnia grzech główny? Jak przekonać ją o użyteczności klas czy wyjątków? Jak wyjaśnić zasady dzielenia programów na osobne pliki bez sprawiania wrażenia, że są to jakieś kosmiczne wymysły mające tylko utrudniać ludziom życie? Mając na względzie powyższe trudności oraz fakt, że moim celem jest nauczenie C++ od podstaw w 12 wykładach, podręcznik podzieliłem na 12 rozdziałów, przy czym stopień zaawansowania kilku początkowych dostosowany jest do potrzeb (i poziomu) osób piszących nie tyle nawet programy, ile krótkie wprawki. Pierwszy rozdział zawiera krótki opis języka, kilka przykładowych programów oraz informacje niezbędne do ich kompilacji. Kolejne 3 rozdziały zawierają zwięzły opis nieobiektowych cech języka, a więc m.in. konstrukcji wyrażeń i instrukcji, definiowania zmiennych i tablic oraz posługiwania się funkcjami swobodnymi. Cztery pierwsze rozdziały wprowadzają więc Czytelnika w świat programowania proceduralnego w C++ lub, innymi słowy, w świat C++ traktowanego jako ulepszona wersja języka C. Kolejne cztery rozdziały poświęcone są programowaniu obiektowemu w C++. Znajdziemy więc tu m.in. objaśnienie tak fundamentalnych pojęć, jak obiekty i klasy (z metodami, konstruktorami i destruktorami), dziedziczenie, hermetyzacja danych i polimorfizm. Rozdział 9 przedstawia sposoby wykorzystywania bibliotek zewnętrznych (napisanych w C lub C++) oraz metody dzielenia własnego projektu na wiele plików źródłowych. Trzy ostatnie rozdziały poświęcone są omówieniu programowania generycznego, co obejmuje wprowadzenie w takie zagadnienia, jak szablony i biblioteka STL. Układ książki może sugerować, iż wykład rozpoczyna się od prezentacji języka C, po czym przechodzi do omawiania C++ jako rozszerzenia języka C. W rzeczywistości jednak nie zamierzam opisywać tu samego języka C, który mimo że de facto jest podzbiorem języka C++ zbytnio ustępuje swemu następcy, by warto było poświęcać mu oddzielnie uwagę. Układ podręcznika odzwierciedla natomiast fakt, że język C++ jest tworem eklektycznym, umożliwiającym programowanie w co najmniej trzech godnych polecenia stylach (proceduralnym, obiektowym, generycznym) lub ich kombinacji. Niniejszy podręcznik powstał w oparciu o moje wieloletnie doświadczenie w nauczaniu C++. Wiele jego rozdziałów zostało zainspirowanych książkami B. Stroustrupa [1], B. Milewskiego [2] i J. Liberty ego [3]. Pierwsza z nich jest lekturą obowiązkową każdego programisty C++. Na tę jedyną książkę nie warto żałować pieniędzy po prostu trzeba ją mieć i sięgać po nią możliwie często. Niestety, nie jest to lektura łatwa, nie jest też pomyślana jako podręcznik dla początkujących. Dwie pozostałe cenię za oryginalne podejście pedagogiczne do tematu. Żadna z nich nie stara się zastąpić książki Stroustrupa; usiłują natomiast z dość dobrym skutkiem przedstawić język C++ od podstaw w sposób zrozumiały dla przeciętnego entuzjasty programowania. Na zakończenie pozwolę sobie jeszcze podziękować Bartoszowi Milewskiemu mojemu pierwszemu nauczycielowi C++.

Rozdział 1 Pierwszy program w C++ Dla kogo jest ta książka? Rys historyczny. Pierwszy program. Środowisko programistyczne. Kompilator i kompilacja. Błędy kompilacji. Typy int i double, obiekty std::cin i std::cout. Instrukcja using namespace std. 1.1 Dla kogo jest ta książka? Podręcznik napisałem z myślą o osobie pragnącej nauczyć się języka C++ od podstaw. Zakładam, że Czytelnik biegle posługuje się komputerem (np. potrafi zainstalować program lub odstrzelić zawieszoną aplikację), ma dostęp do Internetu i zna już jakiś język programowania. Oczywiście niezbędna jest też przyzwoita znajomość języka angielskiego co najmniej w stopniu pozwalającym swobodnie rozumieć komunikaty diagnostyczne kompilatora, a najlepiej na poziomie pozwalającym rozumieć oryginalną dokumentację bibliotek. 1.2 Rys historyczny Dawno, dawno temu, czyli w połowie XX-go wieku komputery były bardzo kosztownymi urządzeniami, które wymagały niezwykle pracochłonnej obsługi. W tych zamierzchłych czasach to ludzie dostosowywali się do możliwości maszyn cyfrowych i obsługiwali je, wpisując programy jako ciągi zer i jedynek poprzez ręczne ustawienie przekaźników; wyniki obliczeń również otrzymywano jako sekwencje zer i jedynek odczytywanych ze stanu lampek. Nieco później pojawiły się asemblery specjalne programy, które pozwalały obsłudze komputerów pisać programy w nieco bardziej dla ludzi zrozumiałych kategoriach rozkazów, liczb, zmiennych; programy te były następnie tłumaczone przez specjalny program na kod maszynowy człowiek mógł wreszcie zapomnieć o zerach i jedynkach. Następnie pojawiły się języki proceduralne, np. FORTRAN; programy w nich napisane przypominały już wzory matematyczne, były więc już całkiem dobrze dostosowane do rozwiązywania wielu zagadnień technicznych. Wciąż jednak koszt komputerów był ogromny, a ich moc szczególnie z dzisiejszej perspektywy była bardzo ograniczona. W tych czasach komputery były obsługiwane wyłącznie przez wysoko wykwalifikowany personel, a główną troską programistów było pisanie programów działających możliwie jak najszybciej i zajmujących jak najmniej 13

14 Rozdział 1. Pierwszy program w C++ zasobów maszyny (głównie pamięci operacyjnej). W tych warunkach nie martwiono się specjalnie kwestią wygody obsługi komputerów łatwiej i taniej było wyszkolić ludzi do obsługi stosunkowo prymitywnych komputerów niż odwrotnie. Dziś komputery są jednocześnie i bardzo szybkie, i tanie, a przez to powszechnie dostępne; co więcej, dysponują zasobami sprzętowymi i mocą obliczeniową tysiące lub nawet miliony razy przewyższającymi te dostępne jeszcze 30 lat temu. Typowymi użytkownikami komputerów nie są już wyłącznie błyskotliwi i wszechstronnie wykształceni fachowcy obecnie komputerami posługują się już nawet przedszkolacy. Ci nowi, nierzadko niepiśmienni użytkownicy wymagają, by komputery wyposażone były w zupełnie inny rodzaj programów niezawodnych i łatwych w obsłudze. Takie programy są jednak z natury bardzo złożone 1. Ich wytworzenie wymaga zaangażowania dziesiątek, setek, a czasami tysięcy ludzi. Masowy rynek oznacza potencjalnie wielkie zyski, ale też i ogromne koszty oraz ryzyko utraty rynku na rzecz konkurencji. Stąd wynika potrzeba ograniczenia kosztów. Te z kolei najefektywniej jest redukować już podczas pisania programów, co oznacza konieczność wyposażenia programistów w możliwe jak najlepsze narzędzia produkcji : edytory (do wprowadzania tekstu), debuggery (do wyszukiwania błędów), systemy kontroli wersji (do zarządzania poprawkami w programach) i przede wszystkim język programowania z możliwie najlepszym kompilatorem, czyli programem tłumaczącym programy napisane przez ludzi na zrozumiały dla komputera kod maszynowy. 1.2.1 Dlaczego C++? W tej sytuacji pod koniec lat osiemdziesiątych na scenę wkracza C++. Język ten, zaprojektowany jako obiektowe rozszerzenie języka C, szybko osiągnął status najpopularniejszego niespecjalistycznego języka programowania. Stało się tak dlatego, że pozwala on na zwiększenie wydajności programistów. Szacuje się, że jeden programista stosujący C++ może sobie poradzić z kilkukrotnie większą (w sensie funkcjonalnym) porcją kodu niż jego kolega posługujący się C. Ponadto kod napisany w C++ jest łatwiejszy w utrzymaniu, rozwoju i ponownym wykorzystaniu w innym projekcie; nie ustępuje przy tym wcale prędkością programom napisanym w C, natomiast w zakresie tym bije na głowę takie popularne języki, jak Java, C# czy Lisp. Jakie są główne zalety C++? C++ umożliwia stosowanie wielu stylów programowania i pracę na wielu poziomach abstrakcji. Można w nim stosować wstawki asemblerowe, a więc programować w języku maszyny; można też programować proceduralnie w stylu takich języków, jak Pascal czy C; można też programować obiektowo, a więc na wysokim poziomie abstrakcji, ułatwiającym programistom myślenie w kategoriach rozwiązywanego przez nich zadania, a nie abstrakcyjnych zer i jedynek, rozkazów maszynowych, adresów czy rejestrów. C++ zawiera mechanizmy ułatwiające wielokrotne wykorzystywanie tego samego kodu. Jest to najważniejsza cecha języka. Programy w C++ (tak jak w C) można dzielić na osobne części ( moduły ); części 1 Na przykład projekt KDE to ponad 4 miliony wierszy kodu nad którym pracuje ponad 800 programistów; tylko w maju 2002 roku dokonano 11 014 zmian w kodzie źródłowym [4].

Rys historyczny 15 te można następnie wykorzystywać w dowolnym innym programie C++, przy czym taki moduł wystarczy raz skompilować, a następnie tylko dołączać do nowych programów (w ten sposób otrzymuje się biblioteki ). Ponadto w C++ takie moduły można w bardziej naturalny sposób niż w C odseparować od siebie (dzięki hermetyzacji danych i interfejsom), tworząc z nich prawdziwe czarne skrzynki. Dzięki tzw. wyjątkom twórcy bibliotek mogą precyzyjnie określić zachowanie się ich kodu w wypadku sytuacji nadzwyczajnych i nawet wymusić określone zachowanie na użytkownikach tych bibliotek. Tak jak w innych językach programowania, w C++ można uniknąć powielania tego samego kodu poprzez zastosowanie funkcji. Ale C++ oferuje dużo więcej szablony, dzięki którym ten sam kod można stosować do obiektów różnych typów, a także przestrzenie nazw, dzięki którym łatwo jest zarządzać nazwami używanymi w różnych bibliotekach. C++ jest rozszerzeniem najpopularniejszego języka lat 80-tych języka C. Dlatego programy napisane w C++ mają pełny dostęp do wszystkich niezliczonych bibliotek kiedykolwiek napisanych w C. Kompilator C++ przejmuje na siebie wiele zadań, za realizację których jeszcze niedawno całkowitą odpowiedzialność ponosił programista. Kompilator sprawdza na przykład, czy użycie zmiennych lub funkcji jest zgodne z ich deklaracją. Możemy też poinstruować go, że pewne zmienne mogą być wykorzystywane tylko w określonych partiach programu albo że ich wartości nie mogą być tam modyfikowane, albo że muszą być zainicjalizowane. W związku z tym, że kompilator C++ z definicji znacznie dokładniej analizuje kod źródłowy, zaleca się nawet, by programy napisane w czystym C kompilować kompilatorem C++. C++ posiada konstrukcje ułatwiające zarządzanie zasobami komputera. Należą do nich m.in. konstruktory, destruktory i wyjątki. Stosując je systematycznie, można zagwarantować np., że z naszego programu nie będzie wyciekać pamięć operacyjna. Programy napisane w C++ są co najmniej równie szybkie, jak te napisane w C. A niekiedy szybsze (np. dzięki szablonom sortowanie jest nieco szybsze w C++ niż w C). Biblioteki standardowe C++ są o wiele bardziej funkcjonalne od ich odpowiedników ze standardowej biblioteki C. Standardowa biblioteka C++ zawiera m.in. wysokopoziomowy typ napisów std::string, który całkowicie zwalnia programistę od troski o to, w jaki sposób napisy są faktycznie interpretowane przez procesor. Podobnie klasa std::vector jest dużo bardziej elastyczna od standardowych tablic języka C, a o czymś takim jak słownik (std::map) możemy w C tylko pomarzyć. Oczywiście C++ ma też wady: C++ jest trudny zarówno do nauczania, jak i uczenia się; C++ stanowi niezwykle trudne wyzwanie dla twórców kompilatorów. O ile mi wiadomo, żaden powszechnie używany kompilator (tj. gcc i MS Visual C++) nie jest jeszcze w 100% zgodny ze standardem ISO z 1998 r. Ze względu na swój olbrzymi potencjał, w rękach niedouczonego programisty C++ jest jak przysłowiowa zapałka w ręku dziecka.

16 Rozdział 1. Pierwszy program w C++ 1.2.2 C++ a C Jak już wspomniałem, C++ jest rozszerzeniem C. Wiele osób wyciąga stąd wniosek, że aby nauczyć się trudnego C++, dobrze jest rozpocząć od łatwego C. Wniosek ten jest jednak równie fałszywy jak teza, że przed nauką jazdy samochodem należy nauczyć się jeździć rowerem (bo także ma kierownicę, hamulce i koła). Język C wymaga stosowania od samego początku dość karkołomnych konstrukcji, których niemal nie używa się w C++ (np. funkcji printf/scanf czy nieustannej żonglerki wskaźnikami). Dlatego programiści obeznani w języku C, aby dobrze opanować C++ muszą oduczyć się wielu nawyków nabytych podczas pracy w C. Jeżeli ostatecznym celem jest C++, nauka C jest marnowaniem czasu! 1.2.3 Aktualny standard języka Na przestrzeni lat język C++ podlegał ciągłej ewolucji. Większość zmian polegała na dodawaniu nowych cech rozszerzających możliwości języka. Kilka istotnych modyfikacji doprowadziło jednak do niezgodności nowszych wersji języka z wersjami starszymi. Dlatego programy napisane 10 lat temu mogą nie spełniać wymagań aktualnego standardu. W niniejszym podręczniku za standard w wymiarze teoretycznym uznaje się standard ISO C++ opisany w piątym wydaniu książki Bjarne a Stroustrupa Język C++. Z kolei w wymiarze praktycznym za standardowe uznaje się tu programy kompilowane szeroko dostępnym kompilatorem GNU g++ w wersji 3.4.2 z opcjami -ansi -pedantic. Oba te warunki powinny zapewnić całkowitą zgodność prezentowanych tu konstrukcji języka z aktualnie obowiązującym standardem ISO C++ z 1998 roku, a więc w efekcie uniezależnić przedstawiane tu informacje od platformy czy konkretnej implementacji kompilatora. 1.3 Zanim napiszemy swój pierwszy program 1.3.1 Środowisko programistyczne Programista, jak każdy zawodowiec, potrzebuje specjalistycznego warsztatu pracy. Nie mam tu oczywiście na myśli samego komputera, lecz specjalnych programów służących do tworzenia nowych lub ulepszania starych programów. Takie zastaw programów nazywa się środowiskiem programistycznym. Istnieją dwa podstawowe rodzaje środowisk. Pierwsze, typowe dla systemu Unix i jego pochodnych, to po prostu kolekcja oddzielnych programów uruchamianych z powłoki systemowej; do tej grupy należy m.in. używany w tym podręczniku kompilator gcc. Drugi rodzaj środowisk to tzw. zintegrowane środowiska programistyczne (IDE, ang. Integrated Development Environments), w których programista do wszystkich potrzebnych narzędzi ma dostęp z jednego programu sterującego zintegrowanego ze specjalistycznym edytorem; do tej kategorii należą m.in. kompilatory firm Microsoft (Visual Studio) i Borland (C++ Builder). Zaletą pierwszego rozwiązania jest to, że daje użytkownikom pełną swobodę w sposobie posługiwania się kompilatorem. W szczególności kompilator gcc można łatwo i ściśle zintegrować z wieloma dostępnymi edytorami tekstu (np. emacs czy vim) lub istniejącymi środowiskami zintegrowanymi (np. C++ Builder), można też na jego podstawie zbudować od podstaw zupełnie nowe środowisko typu

Zanim napiszemy swój pierwszy program 17 Menu Paski narzędzi Okno widoku projektu, klasy lub zmiennych Okienko edycji programu Zakładki okna raportu Pasek stanu Rysunek 1.1: Główne elementy okna programu Dev-C++. IDE (np. KDeveloper i Anjuta w systemie Linux). Podczas zajęć laboratoryjnych towarzyszących bieżącemu kursowi korzystać będziemy z programu Dev-C++, który jest (darmowym) zintegrowanym środowiskiem programistycznym opartym na kompilatorach serii gcc i pracującym w systemie Windows. Program ten można pobrać z Sieci ze strony http://www.bloodshed.net 2. Wybraliśmy go, gdyż (i) jego używanie nie jest obwarowane licencjami komercyjnymi; (ii) oparty jest na bardzo dobrym zestawie kompilatorów gcc/mingw; (iii) zajmuje niewiele miejsca, jest szybki i łatwy w instalacji i obsłudze; (iv) towarzyszy mu ogromna liczba opcjonalnych bibliotek; (v) jest programem dobrze nam znanym, od kilku lat używanym (z wyboru) przez naszych studentów. Typowy wygląd okna programu Dev-C++ przedstawia Rys. 1.1. Głównymi elementami interfejsu użytkownika w tym programie są: Okno edytora tekstu. Jest dostosowane do pisania programów w C lub C++, a wiele jego właściwości może być swobodnie konfigurowanych przez użytkownika. Paski narzędzi. Ułatwiają dostęp do często wykonywanych czynności, np. kompilacji programu, obsługi projektów, wyszukiwania tekstu. Menu. Udostępnia wszystkie funkcje programu. Okno widoku projektu. Ułatwia orientację w dużych programach. Okna raportu. Zawierają dodatkowe informacje, np. pełny komunikat kompilatora o przebiegu kompilacji. Pasek stanu. Podaje podstawowe informacje o edytowanym pliku. 2 Jeśli Czytelnik zdecyduje się zainstalować u siebie środowisko Dev-C++, warto rozszerzyć je o najnowszą wersję środowiska MSYS (http://www.mingw.org), które zwiera programy niezbędne do kompilowania programów i bibliotek dostępnych na licencji GNU. Jeszcze większe możliwości daje instalacja systemu CygWin (http://sources.redhat.com).

18 Rozdział 1. Pierwszy program w C++ 1.4 Pierwszy program Oto nasz pierwszy, najprostszy program w C++. Jego celem jest wyświetlenie na ekranie napisu Pierwszy program w C++. #include <iostream> Wydruk 1.1: Pierwszy program w C++. int main() { std :: cout << Pierwszy program w C++ << \n ; } Tekst programu należy zapisać w pliku o odpowiednim rozszerzeniu. W przypadku kompilatora gcc 3.4.2 za standardowe rozszerzenia nazw plików zawierających programy w C++ uznaje się plik.cc, plik.cp, plik.cxx, plik.cpp, plik.cpp, plik.c++ oraz plik.c. W niniejszym kursie stosować będę bodaj najpopularniejsze rozszerzenie plik.cpp. 1.4.1 Kompilacja kodu źródłowego Programy pisze się w postaci możliwie jak najbardziej zrozumiałej dla ludzi, po czym przy pomocy specjalnych programów tłumaczy się je na ciąg instrukcji przeznaczonych bezpośrednio dla komputera. Obie te wersje zwyczajowo zwie się programem. Aby uniknąć ewentualnych nieporozumień, program w postaci zrozumiałej dla ludzi zwie się kodem źródłowym, a w postaci przeznaczonej dla komputera kodem maszynowym lub wynikowym 3. Program tłumaczący kod źródłowy na maszynowy zwany jest kompilatorem, a sam proces tłumaczenia kompilacją. Słowa kompilator i kompilacja są jednak wieloznaczne. Jeszcze nie tak dawno temu proces tłumaczenia kodu źródłowego na maszynowy składał się z wielu kroków wykonywanych przez osobne programy. W wypadku języka C były to m.in. preprocesor, kompilator, asembler, konsolidator. Najważniejszym instrumentem w tej orkiestrze był (i jest) kompilator od jego jakości w największym stopniu zależy jakość kodu maszynowego. Stąd po pewnym czasie cały proces translacji kodu źródłowego zaczęto nazywać kompilacją; analogicznie cały zestaw programów zaangażowanych w tak rozumianą kompilację zwie się kompilatorem. Z biegiem czasu pojawiła się tendencja, by możliwie jak najbardziej uprościć obsługę procesu tłumaczenia programów. Obecnie w zintegrowanych środowiskach programistycznych translację programu można wykonać po prostu za naciśnięciem myszą odpowiedniego przycisku. Z kolei twórcy kompilatora gcc przyjęli zasadę, że wszystkie etapy translacji można (jawnie lub nie) wykonać przy pomocy polecenia gcc, przy czym szczegółami samego procesu translacji steruje się tu przy pomocy rozlicznych opcji podawanych w wierszu poleceń. Wśród profesjonalistów żelazną regułą jest, by duże programy dzielić na stosunkowo małe fragmenty umieszczane w osobnych plikach źródłowych. W tym 3 Słowo program ma jeszcze trzecie znaczenie informatyczne kod znajdujący się w fazie realizacji przez maszynę ; aby uniknąć dwuznaczności, zwie się go procesem.

Pierwszy program 19 wypadku translację kodu źródłowego dzieli się na kompilację poszczególnych plików, w wyniku czego otrzymuje się tzw. pliki obiektowe, i łączenie (zwane też konsolidacją lub linkowaniem) plików obiektowych z plikami bibliotecznymi w jeden plik wykonywalny. W środowisku kompilatora gcc proces ten zazwyczaj sterowany jest specjalnym programem make, natomiast w zintegrowanych środowiskach programistycznych efektywna praca z programem podzielonym na wiele plików wymaga utworzenia tzw. projektu. Z początku będziemy pisać wyłącznie małe programy mieszczące się w jednym pliku i ani szczegółami obsługi programu make, ani sposobami tworzenie projektów nie musimy się jeszcze zajmować; ważne jest jednak, by zdawać sobie sprawę z pewnego zamieszania pojęciowego panującego w zintegrowanych środowiskach programistycznych. Wiele z nich, np. Visual C++ czy Anjuta, pod nazwą compile rozumie wyłącznie pierwszą fazę translacji, czyli tłumaczenie bieżącego pliku źródłowego na kod obiektowy. Z kolei Dev-C++ pod nazwą compile (lub kompiluj ) rozumie cały proces translacji aż do utworzenia pliku wykonywalnego 4. Pora na małe podsumowanie tego przydługiego wywodu. Aby przetłumaczyć plik źródłowy plik.cpp na plik wykonywalny plik.exe należy Kompilator gcc: Wydać polecenie g++ plik.cpp -o plik.exe Środowisko Dev-C++: Przycisnąć kombinację Ctrl+F9. Zwróćmy uwagę na to, że polecenie wywołujące kompilator C++ nazywa się g++ a nie gcc. W gruncie rzeczy g++ i gcc to ten sam kompilator; wywołanie go jako g++ (lub c++) powoduje jedynie automatyczne połączenie kompilowangeo programu ze standardowymi bibliotekami C++ (zamiast C). Kompilator gcc posiada mnóstwo opcji. Opis najważniejszych z nich znajduje się w dodatku A. 1.4.2 Błędy kompilacji Dość rzadko zdarza się, by już pierwsza wersja programu była całkowicie poprawna. Zazwyczaj kody źródłowe zawierają różnego rodzaju naruszenia składni języka. Typowy błąd to literówka, pominięcie nawiasu lub definicji zmiennej. Dobry kompilator powinien nie tylko wskazać miejsce wystąpienia błędu, ale także zasugerować sposób usunięcia go. W praktyce bywa z tym różnie, a do prawidłowego rozszyfrowania komunikatów kompilatora potrzebna jest wieloletnia wprawa. Rozpatrzmy prosty przykład. Załóżmy, że w programie 1.1 ze str. 18 zapomniano zakończyć średnikiem instrukcję cout <<.... Po skompilowaniu takiego błędnego programu w środowisku Dev-C++ uzyskamy efekt jak na Rys. 1.2. Brązowy pasek i krzyżyk na lewym marginesie wskazują wiersz, w którym kompilator wykrył błąd. Komunikat o błędzie wyświetlany jest na dole w okienku komunikatów. Zawiera on numer wiersza (tu: 6), nazwę pliku (tu: 1.cpp) oraz komunikat diagnostyczny (expected ; before \} token). Gdyby błędów było więcej, moglibyśmy łatwo dotrzeć do miejsca detekcji każdego z nich w tym celu wystarczyłoby kliknąć odpowiedni wiersz w okienku komunikatów. Miejsce detekcji błędu często różni się od jego rzeczywistej lokalizacji. W naszym przypadku różnica jest niewielka tylko jeden wiersz ale czasami może nawet dojść do sytuacji, gdy kompilator odkryje błąd w innym pliku niż ten, 4 Ta sama czynność w języku Visual C++ zwie się budowaniem (ang. build ).

20 Rozdział 1. Pierwszy program w C++ Tu brakuje średnika Tu wykryto błąd Lista komunikatów kompilatora Rysunek 1.2: Wygląd okna programu Dev-C++ w przypadku wykrycia przez kompilator błędu w kodzie źródłowym. w którym błąd faktycznie popełniono. Sam komunikat również nie jest klarowny nawet dla osób biegle władających językiem angielskim. Nie narzekajmy jednak zbytnio: gdyby kompilator mógł sam poprawiać nasze błędy, mógłby też sam pisać programy, a więc my nie bylibyśmy już do niczego potrzebni. 1.4.3 Uruchamianie programu w środowisku Dev-C++ Aby uruchomić w środowisku Dev-C++ skompilowany program, wystarczy wybrać z menu pozycję Uruchom/Uruchom lub wcisnąć kombinację Ctrl+F10. Jeśli jednak w ten sposób uruchomimy program 1.1, spotka nas przykra niespodzianka: Dev-C++ otworzy okienko konsoli, uruchomi w niej nasz program, po czym natychmiast zamknie okno wraz z konsolą! Całość ledwie mignie nam przed oczami. Aby uchronić okno programu przed natychmiastowym zamknięciem, zazwyczaj na samym końcu funkcji main umieszcza się instrukcję system( pause ); 1.4.4 Struktura prostego programu w C++ Króciutkie (a więc też, niestety, raczej trywialne) programy w C++ mają następującą strukturę: Wydruk 1.2: Ogólna struktura prostych programów w C++. #include <iostream> int main() {... } przy czym wielokropek należy zastąpić tu instrukcjami programu. Na razie to nie do końca prawdziwe stwierdzenie proszę przyjąć jak dogmat. Wyjaśnienie roli i znaczenia poszczególnych konstrukcji użytych w powyższym schemacie zostanie przedstawione w kolejnych rozdziałach.

1.5 Obiekt std::cout i literały Obiekt std::cout i literały 21 Nasz pierwszy program (wydruk 1.1 na str. 18) zawiera tylko jedną instrukcję: std :: cout << Pierwszy program w C++ << \n ; Jej znaczenie jest następujące. std::cout oznacza strumień danych związany z bieżącym okienkiem. Do strumienia tego przesyłane są dane przy pomocy operatora <<. Najpierw przesyłany jest napis Pierwszy program w C++. Następnie do obiektu std::cout trafia kolejny, dość tajemniczy napis \n jednak tak naprawdę nie jest to zwyczajny napis, lecz specjalny znak sterujący, którego przesłanie na konsolę powoduje przemieszczenie kursora na początek kolejnego wiersza. Spójrzmy teraz na tę samą instrukcję z bardziej ogólnego punktu widzenia: std:: w nazwie obiektu std::cout oznacza, że mamy do czynienia z obiektem z biblioteki standardowej; std jest tu nazwą przestrzeni nazw, a :: tzw. operatorem zasięgu. Zapis std::cout oznacza, że używamy obiektu cout z przestrzeni nazw std. Nazwa obiektu cout to skrót od angielskiego console output (wyjście na konsolę). Przed pierwszym użyciem strumienia std::cout należy zastosować makrodefinicję #include <iostream> Zwyczajne napisy w C++ umieszcza się między znakami cudzysłowu. Dalej takie napisy będę nazywał tekstami. Znaki sterujące (zwane też znakami specjalnymi) zapisuje się jako ciąg dwóch liter, z których pierwsza jest ukośnikiem (\). Zapis << oznacza specjalny operator. Służy on m.in. do przesyłania danych na konsolę. Wywołania operatora << można łączyć ze sobą w ciąg; odpowiada to kierowaniu na konsolę kolejnych tekstów lub obiektów. Dwa kolejne teksty (ujęte w cudzysłów) można ze sobą łączyć w jeden. Dlatego zamiast std::cout << "Pierwszy program w C++"<< "\n" można napisać std :: cout << Pierwszy program w C++\n ; Każda instrukcja (prosta) musi kończyć się średnikiem. Liczby wyświetla się na konsoli równie łatwo, jak napisy. Jedyna komplikacja polega na tym, że komputery rozróżniają wiele rodzajów liczb. W szczególności starannie rozróżniają liczby całkowite od rzeczywistych. Spójrzmy na wydruk 1.3: #include <iostream> Wydruk 1.3: Program wyświetlający liczby i napisy. int main() { std :: cout << Mam << 40 << lat\nliczba pi = << 3.14 <<...\n ; }

22 Rozdział 1. Pierwszy program w C++ Program ten wyświetla dwie linijki tekstu: Mam 40 lat Liczba pi = 3.14... Jak widać, obiekt std::cout w taki sam sposób operatorem << wyświetla teksty, liczby całkowite i liczby rzeczywiste (oczywiście te ostatnie zapisujemy z kropką, a nie przecinkiem dziesiętnym!). Warto też zwrócić uwagę na stosowanie odstępów w napisach występujących przed lub po liczbach. Liczby wyświetlane są bowiem bez żadnych odstępów. 1.6 Definiowanie obiektów Nasze dotychczasowe programy mają pewną ułomność: ograniczają się do wyświetlania liczb lub tekstów umieszczonych dosłownie ( literalnie ) w tekście programu. W fachowym żargonie mówi się, że te programy wyświetlają wartości literałów. Wartość literału jest znana już podczas kompilacji i nie może ulec zmianie podczas wykonywania programu. Naturalne pytanie brzmi: w jaki sposób zdefiniować obiekty, których wartość mogłaby ulegać zmianie podczas pracy programu? Odpowiedź przynosi program 1.4: 1 #include <iostream> #include <string> Wydruk 1.4: Program modyfikujący wartości zmiennych. int main() 5 { std :: cout << Jak masz na imie? ; std :: string imie; std :: cin >> imie; 10 std :: cout << ile masz lat? ; int wiek; std :: cin >> wiek; std :: cout << Witaj, << imie 15 <<! Nie wiedzialem, ze masz << wiek << lat!\n ; } Definicja funkcji main składa się z siedmiu instrukcji 5 ułożonych w trzech grupach. W wierszach 6-8 program wczytuje imię użytkownika, w wierszach 10-12 prosi go o podanie wieku, po czym w długiej instrukcji zajmującej wiersze 14 i 15 wyświetla komunikat zawierający zarówno imię jak i wiek użytkownika. Przyjrzyjmy się teraz szczegółowo sposobowi realizacji tych zadań. Znaczenie wierszy 6, 10 i 14-15 powinno już być jasne: program wyświetla w nich komunikaty dla użytkownika. Natomiast w wierszach 7 i 11 mamy przykłady zastosowania nowej konstrukcji języka definicji obiektu. Obiekt definiuje się w bardzo prosty sposób: najpierw podajemy nazwę klasy obiektu, a po niej 5 Liczba instrukcji równa jest liczbie średników.

Definiowanie obiektów 23 nazwę definiowanego obiektu 6. Definicja obiektu jest traktowana jak instrukcja, dlatego należy zakończyć ją średnikiem. Co więcej, w C++ obowiązuje Reguła 1.1 Definicje mogą przeplatać się ze zwykłymi instrukcjami Dlatego obiekty można (i należy!) definiować dopiero tam, gdzie są naprawdę potrzebne. W naszym przykładzie zdefiniowano dwa obiekty: imie, (klasy std::string) oraz wiek (klasy int). Klasa std::string służy do obsługi wszelkiego rodzaju tekstów, natomiast int to klasa liczb całkowitych (int to skrót od angielskiego słowa integer oznaczającego właśnie liczbę całkowitą). Po zdefiniowaniu obiekty są gotowe do użycia. W wierszach 8 i 12 zmienia się ich wartości na te, które zostaną wprowadzone przez użytkownika przy pomocy klawiatury. Służy do tego obiekt std::cin (jego nazwa pochodzi od angielskiego zwrotu console input, czyli wejście z konsoli ) oraz operator >>. W przeciwieństwie do wielu innych języków programowania, w C++ nie czyni się żadnych niejawnych założeń co do klasy niezadeklarownych obiektów. Proszę zapamiętać następującą zasadę: Reguła 1.2 Każdy obiekt musi mieć jawnie zadeklarowaną klasę (tj. typ) Po przeczytaniu powyższej reguły uważnemu Czytelnikowi mogą przyjść do głowy dwa pytania. Po pierwsze, gdzie w programie 1.4 znajdują się wymagane przez nią definicje obiektów std::cout i std::cin? Odpowiedź brzmi: za deklarację tych obiektów odpowiedzialna jest dyrektywa #include <iostream>. Jej działanie polega na dołączeniu do kodu programu wszystkich deklaracji związanych z działaniem standardowych strumieni wejścia i wyjścia. Bez tej dyrektywy kompilator nie wiedziałby, jaka jest klasa tych obiektów, a w związku z tym uznałby program za błędny. Drugie pytanie brzmi: skoro tak stanowczo wymaga się, by przed użyciem jakiegokolwiek obiektu zdefiniować jego klasę, jak rozwiązano w C++ zagadnienie definiowania samych klas? W szczególności skąd kompilator wie, jakie jest znaczenie słówek int oraz std::string użytych w programie na oznaczenie klas obiektów? Otóż kilka klas podstawowych, m.in. int, jest zdefiniowanych w samym języku C++; wszystkie inne muszą być jawnie zdefiniowane przed pierwszym użyciem. W szczególności definicja klasy std::string włączana jest do programu dyrektywą #include <string>. Odpowiedź na powyższe pytania zawiera jednocześnie wyjaśnienie znaczenia dwóch pierwszych wierszy programu 1.4. Znajdujące się w nich dyrektywy 7 #include służą do dosłownego wstawienia w miejscu ich wystąpienia treści plików o nazwach podanych w nawiasach ostrokątnych. Takie pliki zwie się plikami nagłówkowymi. Użyte w programie pliki iostream i string wchodzą w skład każdej instalacji kompilatora C++, gdyż stanowią część biblioteki standardowej tego języka. Dodatkowo każda niestandardowa biblioteka instaluje w kompilatorze dodatkowe pliki nagłówkowe (w moim kompilatorze jest ich bagatela około 1270). Zasadniczo pliki nagłówkowe służą do informowania kompilatora o możliwościach danej biblioteki (tj. stanowią jej interfejs). 6 Wiele podręczników C++ w użytym tu kontekście zastosowałoby terminy zmienna (zamiast obiekt ) i typ (zamiast klasa ). Ja uważam takie rozróżnianie za zbędne i niepedagogiczne; prowadzi ono bowiem do sytuacji, gdy słowa obiekt i klasa pojawiają się w połowie kursu, co sugeruje, że obiekty i klasy to coś niesamowicie skomplikowanego. 7 Dyrektywy zostaną szczegółowo omówione w Rozdziale 10.

24 Rozdział 1. Pierwszy program w C++ Plik nagłówkowe bardzo często same także zawierają dyrektywy #include włączające kolejne pliki nagłówkowe. Wiąże się z tym następująca ciekawostka: dwie niewinnie wyglądające w programie 1.4 dyrektywy #include w rzeczywistości włączają do jego tekstu zawartość nie dwóch, lecz 98 plików nagłówkowych, a po ich włączeniu całkowita liczba wierszy programu wynosi nie 17, lecz... 23 726 (dane dla kompilatora gcc 3.4.4 cygming special). 1.7 Identyfikatory, słowa kluczowe i dyrektywy Definiując obiekty, musimy nadać im nazwy. Jak się wkrótce przekonamy, w C++ można (i zazwyczaj trzeba) definiować też inne byty : funkcje, klasy, wyliczenia itp. Wszystkie one muszą mieć nazwy. W żargonie C/C++ nie używa się jednak w tym kontekście słowa nazwa, lecz identyfikator. Identyfikatory mogą składać się wyłącznie liter, cyfr i znaku podkreślenia (_), przy czym pierwszym znakiem nie może być cyfra (gdyż cyframi rozpoczynać się mogą wyłącznie liczby). Ilość znaków w identyfikatorze (we współczesnych kompilatorach) jest praktycznie nieograniczona. We wszystkich identyfikatorach litery małe uważa się za różne od wielkich. Poprawnymi (i wzajemnie różnymi) identyfikatorami są więc np. rozmiar, Rozmiar, rozmiar_tablic, s00, M_PI. W punkcie 1.6 wspomniałem już, że pewne identyfikatory, np. int, zdefiniowane są w samym języku. Są to tak zwane słowa kluczowe. Słowa kluczowe mają ściśle określone, niezmienne znaczenie. Nie można więc używać ich jak zwykłych identyfikatorów (np. jako nazw zmiennych lub typów). W C++ istnieją aż 73 słowa kluczowe (w praktyce używa się ok. 50). W niniejszym podręczniku słowa kluczowe wyróżniono pogrubieniem. Oprócz słów kluczowych specjalną rolę w programie odgrywają tzw. dyrektywy preprocesora. Są to specjalne identyfikatory poprzedzone znakiem #. Jest ich w sumie kilkanaście, z czego w praktyce używa się ok. 6. W podręczniku dyrektywy preprocesora również wyróżniam pogrubieniem (tak jak słowa kluczowe). Regułę 1.2 można teraz rozszerzyć następująco: Reguła 1.3 Każdy identyfikator, który nie jest słowem kluczowym lub dyrektywą preprocesora, najpierw musi być zadeklarowany, a dopiero potem może zostać użyty. Jak już wiemy, do deklarowania identyfikatorów bibliotecznych służy dyrektywa #include<...>; z kolei najczęściej spotykaną metodą deklaracji własnych identyfikatorów jest podanie ich definicji (tj., definicji obiektu, funkcji, etc.). 1.8 Zapis programu Wróćmy jeszcze raz do programu 1.4 (str. 22) i przyjrzyjmy się jego zapisowi. Mam nadzieję, że Czytelnik zwrócił uwagę na jego czytelność. Aby ją osiągnąć, zastosowałem następujące zasady: Dyrektywy #include rozpoczynają się od pierwszej kolumny i poprzedzają wszelkie inne fragmenty programu. Definicja funkcji rozpoczyna się od pierwszej kolumny, natomiast jej treść jest (równomiernie) wcięta.