C++. Potęga języka. Od przykładu do przykładu

1. IDZ DO PRZYK£ADOWY ROZDZIA£ SPIS TRE CI C++. Potêga jêzyka. Od przyk³adu do przyk³adu KATALOG KSI¥¯EK Autorzy: Andrew Koenig, Barbara E. Moo T³umaczenie: Przemys³aw Szeremiota KATALOG ONLINE ISBN: 83-7361-374-9 Tytu³ orygina³u: Accelerated C++. ZAMÓW DRUKOWANY KATALOG Practical Programming by Example Format: B5, stron: 422 Przyk³ady na ftp: 122 kB TWÓJ KOSZYK Ksi¹¿ka ta ma pomóc Czytelnikowi w szybkim nauczeniu siê jêzyka C++ poprzez DODAJ DO KOSZYKA pisanie w nim przydatnych programów. Ta strategia wydaje siê oczywista, jednak jest odmienna od powszechnie przyjêtej metodologii nauczania. Autorzy nie bêd¹ uczyæ Ciê CENNIK I INFORMACJE jêzyka C, choæ wielu uwa¿a, ¿e jest to niezbêdne. W prezentowanych przyk³adach od razu wykorzystane zostan¹ wysokopoziomowe struktury, a prezentacja sposobu ich zastosowania bêdzie czêsto wyprzedzaæ omówienie ich fundamentów. Dziêki takiemu ZAMÓW INFORMACJE podej ciu zaczniesz szybko pisaæ programy wykorzystuj¹ce idiomy C++. O NOWO CIACH Zastosowany w ksi¹¿ce schemat autorzy wypróbowali podczas kursów prowadzonych ZAMÓW CENNIK na Uniwersytecie Stanforda, na których studenci ucz¹ siê pisaæ programy ju¿ na pierwszych zajêciach. Poznaj: CZYTELNIA • Podstawowe cechy C++ • Operacje na ci¹gach FRAGMENTY KSI¥¯EK ONLINE • Pêtle i liczniki • Przetwarzanie danych „porcja po porcji” • Organizacjê programów i danych • Kontenery sekwencyjne i analiza ci¹gów tekstowych • Algorytmy biblioteki standardowej • Kontenery asocjacyjne • Funkcje uogólnione i definiowanie w³asnych typów • Zarz¹dzanie pamiêci¹ i niskopoziomowymi strukturami danych • Pó³automatyczne zarz¹dzanie pamiêci¹ • Programowanie zorientowane obiektowo Andrew Koenig jest cz³onkiem dzia³u badaj¹cego systemy oprogramowania w Shannon Wydawnictwo Helion Laboratory firmy AT&T oraz redaktorem projektu komitetów standaryzacyjnych jêzyka ul. Chopina 6 C++. Jako programista z trzydziestoletnim sta¿em (piêtna cie lat po wiêconych C++) 44-100 Gliwice opublikowa³ ponad 150 artyku³ów i wyg³osi³ mnóstwo odczytów o tym jêzyku. tel. (32)230-98-63 Barbara E. Moo jest konsultantk¹ z dwudziestoletnim do wiadczeniem e-mail: helion@helion.pl programistycznym. Pracuj¹c przez 15 lat dla AT&T wspó³tworzy³a jeden z pierwszych komercyjnych produktów tworzonych w jêzyku C++, zarz¹dza³a projektem pierwszego kompilatora C++ firmy AT&T i kierowa³a rozwojem uznanego systemu AT&T WorldNet Internet Service. Jest wspó³autork¹ ksi¹¿ki „Ruminations on C++”. Wyk³ada na ca³ym wiecie.

2. Spis treści Przedmowa........................................................................................ 9 Wstęp ............................................................................................. 15 Zaczynamy ........................................................................................................................15 W.1. Komentarze...............................................................................................................16 W.2. Dyrektywa #include..................................................................................................16 W.3. Funkcja main ............................................................................................................16 W.4. Nawiasy klamrowe ...................................................................................................17 W.5. Wykorzystanie biblioteki standardowej do realizacji operacji wyjścia ...................17 W.6. Instrukcja return........................................................................................................18 W.7. Nieco głębsza analiza ...............................................................................................19 W.8. Podsumowanie..........................................................................................................21 Rozdział 1. Operacje na ciągach ........................................................................ 25 1.1. Wejście programu ......................................................................................................25 1.2. Ozdabianie powitania.................................................................................................28 1.3. Podsumowanie ...........................................................................................................32 Rozdział 2. Pętle i liczniki.................................................................................. 37 2.1. Zadanie .......................................................................................................................37 2.2. Ogólna struktura programu ........................................................................................38 2.3. Wypisywanie nieznanej z góry liczby wierszy ..........................................................38 2.4. Wypisywanie wierszy ................................................................................................43 2.5. Połączenie fragmentów programu..............................................................................48 2.6. Zliczanie .....................................................................................................................52 2.7. Podsumowanie ...........................................................................................................54 Rozdział 3. Przetwarzanie porcji danych .............................................................. 61 3.1. Obliczanie średniej ocen z egzaminów ......................................................................61 3.2. Mediana zamiast średniej ...........................................................................................68 3.3. Podsumowanie ...........................................................................................................77 Rozdział 4. Organizacja programów i danych ...................................................... 81 4.1. Organizacja przetwarzania .........................................................................................82 4.2. Organizacja danych ....................................................................................................93 4.3. Połączenie fragmentów programu..............................................................................98 4.4. Podział programu wyznaczającego oceny semestralne............................................101 4.5. Ostateczna wersja programu ....................................................................................103 4.6. Podsumowanie .........................................................................................................105

3. 6 C++. Potęga języka. Od przykładu do przykładu Rozdział 5. Kontenery sekwencyjne i analiza ciągów tekstowych....................... 109 5.1. Dzielenie studentów na grupy ..................................................................................109 5.2. Iteratory ....................................................................................................................114 5.3. Wykorzystanie iteratorów w miejsce indeksów.......................................................118 5.4. Ulepszanie struktury danych pod kątem większej wydajności ................................120 5.5. Kontener typu list .....................................................................................................121 5.6. Wracamy do ciągów typu string...............................................................................124 5.7. Testowanie funkcji split ...........................................................................................127 5.8. Kolekcjonowanie zawartości ciągu typu string........................................................129 5.9. Podsumowanie .........................................................................................................134 Rozdział 6. Korzystanie z algorytmów biblioteki standardowej........................... 141 6.1. Analiza ciągów znakowych......................................................................................142 6.2. Porównanie metod wyznaczania ocen......................................................................151 6.3. Klasyfikacja studentów — podejście drugie............................................................159 6.4. Algorytmy, kontenery, iteratory...............................................................................163 6.5. Podsumowanie .........................................................................................................164 Rozdział 7. Stosowanie kontenerów asocjacyjnych ........................................... 169 7.1. Kontenery obsługujące szybkie wyszukiwanie........................................................169 7.2. Zliczanie wyrazów ...................................................................................................171 7.3. Generowanie tabeli odsyłaczy..................................................................................173 7.4. Generowanie prostych zdań .....................................................................................176 7.5. Słowo o wydajności .................................................................................................184 7.6. Podsumowanie .........................................................................................................185 Rozdział 8. Pisanie funkcji uogólnionych.............................................................. 189 8.1. Czym jest funkcja uogólniona? ................................................................................189 8.2. Niezale ność od struktur danych..............................................................................194 8.3. Iteratory wejściowe i wyjściowe ..............................................................................202 8.4. Wykorzystanie iteratorów dozwiększeniaelastycznościprogramów................................204 8.5. Podsumowanie .........................................................................................................205 Rozdział 9. Definiowanie własnych typów ......................................................... 209 9.1. Rewizja typu Student_info .......................................................................................209 9.2. Typy definiowane przez u ytkownika .....................................................................210 9.3. Ochrona składowych ................................................................................................214 9.4. Klasa Student_info ...................................................................................................219 9.5. Konstruktory.............................................................................................................219 9.6. Stosowanie klasy Student_info ................................................................................222 9.7. Podsumowanie .........................................................................................................223 Rozdział 10. Zarządzanie pamięcią i niskopoziomowymi strukturami danych........ 227 10.1. Wskaźniki i tablice .................................................................................................228 10.2. Literały łańcuchowe — powtórka ..........................................................................235 10.4. Argumenty funkcji main ........................................................................................238 10.5. Odczyt i zapis plików.............................................................................................239 10.6. Trzy tryby zarządzania pamięcią............................................................................242 10.7. Podsumowanie .......................................................................................................245 Rozdział 11. Definiowanie abstrakcyjnych typów danych ........................................ 249 11.1. Klasa Vec ...............................................................................................................249 11.2. Implementacja klasy Vec .......................................................................................250 11.3. Kontrola operacji kopiowania ................................................................................258 11.4. Pamięć dynamiczna w klasie Vec ..........................................................................267 11.5. Elastyczne zarządzanie pamięcią ...........................................................................269 11.6. Podsumowanie .......................................................................................................275

4. Spis treści 7 Rozdział 12. Obiekty typów definiowanych przez użytkownika jako wartości........ 279 12.1. Prosta klasa ciągów ................................................................................................280 12.2. Konwersje automatyczne .......................................................................................281 12.3. Operacje wykonywane na klasie Str ......................................................................283 12.4. Ryzykowne konwersje ...........................................................................................290 12.5. Operatory konwersji...............................................................................................292 12.6. Konwersje a zarządzanie pamięcią............................................................................293 12.7. Podsumowanie .......................................................................................................295 Rozdział 13. Dziedziczenie i wiązanie dynamiczne............................................... 299 13.1. Dziedziczenie .........................................................................................................299 13.2. Polimorfizm i funkcje wirtualne ............................................................................305 13.3. Rozwiązanie zadania z u yciem dziedziczenia......................................................310 13.4. Prosta klasa manipulatora.......................................................................................316 13.5. Stosowanie klasy manipulatora..............................................................................321 13.6. Niuanse...................................................................................................................323 13.7. Podsumowanie .......................................................................................................324 Rozdział 14. Automatyczne (prawie) zarządzanie pamięcią.................................. 329 14.1. Manipulatory kopiujące obiekty docelowe ............................................................330 14.2. Manipulatory zliczające odwołania.............................................................................337 14.3. Manipulatory z opcją współu ytkowania danych ..................................................340 14.4. Ulepszanie manipulatorów.....................................................................................342 14.5. Podsumowanie .......................................................................................................346 Rozdział 15. Obrazki znakowe — podejście drugie.............................................. 347 15.1. Projekt ....................................................................................................................348 15.2. Implementacja ........................................................................................................357 15.3. Podsumowanie .......................................................................................................368 Rozdział 16. Co dalej?....................................................................................... 371 16.1. Korzystaj z posiadanych narzędzi ..........................................................................371 16.2. Pogłębiaj wiedzę ....................................................................................................373 Dodatek A Tajniki języka................................................................................. 375 A.1. Deklaracje................................................................................................................375 A.2. Typy.........................................................................................................................380 A.3. Wyra enia................................................................................................................388 A.4. Instrukcje .................................................................................................................391 Dodatek B Opis biblioteki ............................................................................... 395 B.1. Wejście i wyjście .....................................................................................................396 B.2. Kontenery i iteratory................................................................................................399 B.3. Algorytmy................................................................................................................411 Skorowidz......................................................................................417

5. Rozdział 6. Korzystanie z algorytmów biblioteki standardowej W rozdziale 5. widzieliśmy, e wiele operacji wykonywanych na kontenerach da się zastosować do więcej ni jednego typu kontenera. Przykładowo, typy XGEVQT, UVTKPI i NKUV pozwalają na realizację operacji wstawiania elementów za pośrednictwem metody KPUGTV i usuwania elementów metodą GTCUG. Operacje te realizowane są za po- średnictwem identycznego we wszystkich trzech przypadkach interfejsu. Dzięki temu wiele z operacji charakterystycznych dla kontenerów da się wykonać równie wobec obiektów typu UVTKPI. Ka dy kontener — równie klasa UVTKPI — udostępnia skojarzone z danym typem kontenera klasy iteratorów, za pośrednictwem których mo na wybierać elementy z kontenera. Tu znów biblioteka standardowa troszczy się o to, aby ka dy z udostępnianych iteratorów pozwalała na realizację pewnych operacji za pośrednictwem wspólnego dla wszystkich iteratorów interfejsu. Dla przykładu, operator daje się zastosować wobec iteratora dowolnego typu i zawsze oznacza przesunięcie iteratora do następnego elementu kontenera; operator

6. słu y z kolei do odwoływania się do elementu skojarzonego z iteratorem, niezale nie od typu tego ostatniego. W bie ącym rozdziale zobaczymy, w jaki sposób biblioteka standardowa wykorzystuje koncepcję wspólnego interfejsu w udostępnianiu zbioru tak zwanych standardowych algorytmów. Korzystając z tych algorytmów, unikamy pisania i przepisywania wcią tego samego kodu dla ró nych struktur danych. Co wa niejsze, mo emy dzięki nim pisać programy prostsze i mniejsze ni gdybyśmy wszystkie algorytmy implementowali sami — niekiedy ró nica rozmiarów i prostoty oprogramowania w wyniku zastosowania algorytmów standardowych mo e być ogromna. Algorytmy, podobnie jak iteratory i kontenery, równie wykorzystują konwencję spój- nego interfejsu. Spójność ta pozwala nam ograniczyć naukę do kilku algorytmów i na zastosowanie zdobytych doświadczeń w pracy z pozostałymi algorytmami. W tym rozdziale do rozwiązywania problemów związanych z przetwarzaniem ciągów typu UVTKPI i ocen studentów wykorzystamy kilka standardowych algorytmów. Przy okazji nauczy- my się korzystać z większości kluczowych koncepcji algorytmów biblioteki standardowej.

7. 26 Accelerated C++. Practical Programming by Example O ile w tekście nie będzie zaznaczone inaczej, wszystkie prezentowane w tym rozdziale algorytmy definiowane będą w nagłówku CNIQTKVJO . 6.1. Analiza ciągów znakowych W §5.8.2/132 wykorzystywaliśmy do konkatenacji dwóch obrazków znakowych nastę- pującą pętlę: HQT XGEVQTUVTKPI EQPUVKVGTCVQT KV DQVVQODGIKP KV DQVVQOGPF KV TGVRWUJADCEM

8. KV Stwierdziliśmy, e pętla ta odpowiada czynności wstawienia kopii elementów kontenera DQVVQO na koniec kontenera TGV, która to czynność w przypadku kontenerów typu XGEVQT mo e zostać zrealizowana bezpośrednio: TGVKPUGTV TGVGPF DQVVQODGIKP DQVVQOGPF Niniejsze zadanie da się jednak rozwiązać jeszcze bardziej ogólnie — mo na bowiem oddzielić kopiowanie elementów od ich wstawiania na koniec kontenera, jak poni ej: EQR[ DQVVQODGIKP DQVVQOGPF DCEMAKPUGTVGT TGV W tym przykładzie EQR[ jest algorytmem uogólnionym, a DCEMAKPUGTVGT jest przykła- dem adaptora. Algorytm uogólniony to algorytm, który nie jest częścią definicji jakiegokolwiek kon- kretnego kontenera, a o sposobie dostępu do przetwarzanych danych decyduje na podstawie typów argumentów. Algorytmy uogólnione biblioteki standardowej przyjmują zwykle w liście argumentów wywołania iteratory, za pośrednictwem których odwołują się do manipulowanych elementów w kontenerach źródłowych. Dla przykładu, algorytm EQR[ przyjmuje trzy iteratory, którym przypiszemy nazwy DGIKP, GPF i QWV i kopiuje elementy w zakresie =DGIKP GPF do miejsca wskazywanego przez QWV, w miarę potrzeby rozszerzając kontener docelowy. Innymi słowy, konstrukcja: EQR[ DGIKP GPF QWV jest co do efektu równowa na konstrukcji: YJKNG DGIKP GPF

9. QWV

10. DGIKP z tym, e powy sza instrukcja YJKNG zmienia wartości iteratorów, a algorytm EQR[ tego nie robi. Zanim przejdziemy do omawiania adaptorów iteratorów, powinniśmy zwrócić uwagę na wykorzystanie w powy szej pętli operatora inkrementacji w postaci przyrostkowej. Operatory przyrostkowe ró nią się od przedrostkowych tym, e wyra enie DGIKP zwraca kopię oryginalnej wartości DGIKP, a zwiększenie wartości DGIKP stanowi efekt uboczny operacji. Innymi słowy, kod: KV DGIKP

11. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 27 jest równowa ny kodowi: KV DGIKP DGIKP Operator inkrementacji ma priorytet identyczny z priorytetem operatora

12. ; oba te operatory są te operatorami łącznymi prawostronnie, co oznacza, e

13. QWV powinno być interpretowane jako

14. QWV . Stąd zapis:

15. QWV

16. DGIKP odpowiada zapisowi: ]

17. QWV

18. DGIKP QWV DGIKP _ Wróćmy teraz do adaptorów iteratorów, które są, zasadniczo rzecz biorąc, funkcjami zwracającymi iteratory, których właściwości są związane z argumentami wywołania. Adaptory iteratorów są definiowane w nagłówku KVGTCVQT . Najpowszechniej wykorzystywanym adaptorem jest DCEMAKPUGTVGT, który przyjmuje jako argument wywoła- nia kontener i zwraca iterator, który zastosowany w operacji wstawiania wskazuje na miejsce kolejnego elementu. Przykładowo więc DCEMAKPUGTVGT TGV jest iteratorem, któ- ry wykorzystany jako iterator elementu docelowego operacji wstawiania spowoduje wstawienie elementu na koniec kontenera. Stąd: EQR[ DQVVQODGIKP DQVVQOGPF DCEMAKPUGTVGT TGV kopiuje wszystkie elementy kontenera DQVVQO, dołączając ich kopie na koniec kontenera TGV. Po zakończeniu działania funkcji rozmiar kontenera TGV zostanie zatem zwiększony o wielkość DQVVQOUKG . Zauwa my, e nie mo na wykonać wywołania: błąd — TGV nie jest iteratorem EQR[ DQVVQODGIKP DQVVQOGPF TGV a to dlatego, e trzecim parametrem funkcji EQR[ musi być iterator, a w wywołaniu w miejsce odpowiedniego argumentu przekazano kontener. Podobnie niemo liwe jest wykonanie kodu: błąd — brak elementu pod wskazaniem GPFTGV EQR[ DQVVQODGIKP DQVVQOGPF TGVGPF Tutaj błąd jest mniej oczywisty, poniewa dzięki zgodności typów argumentów wywo- łanie takie zostanie przyjęte przez kompilator. Błąd ujawni się dopiero przy wykonywaniu powy szego kodu — na początek funkcja EQR[ spróbuje przypisać skopiowaną wartość do elementu wskazywanego iteratorem TGVGPF , podczas gdy wiemy, e TGVGPF to odniesienie do nieistniejącego elementu za ostatnim elementem kontenera. Sposób działania programu w takiej sytuacji jest całkowicie niezdefiniowany. Skąd taka definicja funkcji EQR[? Otó oddzielenie koncepcji kopiowania od zwiększania rozmiaru kontenera pozwala programistom na dokonywanie wyboru operacij w zale ności od potrzeb. Przydaje się to, na przykład, w sytuacji, kiedy zachodzi potrzeba skopiowania elementów do kontenera bez zmieniania jego rozmiaru (a więc z nadpisaniem bie ącej zawartości kontenera). W innym przykładzie, prezentowanym zresztą w §6.2.2/154, dzięki adaptorowi DCEMAKPUGTVGT mo na dołączać do kontenera elementy, które nie są prostymi kopiami elementów innego kontenera.

19. 28 Accelerated C++. Practical Programming by Example 6.1.1. Inna implementacja funkcji split Inną funkcją, którą moglibyśmy zmodyfikować pod kątem wykorzystania algorytmów standardowych, jest funkcja URNKV, prezentowana w §5.6/125. Najtrudniejsze w pierwot- nej wersji funkcji było kontrolowanie indeksów ograniczających kolejne wyrazy ciągu wejściowego. Indeksy te mo emy zastąpić iteratorami i zaprząc do pracy algorytmy biblioteki standardowej: zwraca VTWG, je eli argument jest znakiem odstępu; w przeciwnym przypadku zwraca HCNUG DQQN URCEG EJCT E ] TGVWTP KUURCEG E _ zwraca HCNUG, je eli argument jest znakiem odstępu; w przeciwnym przypadku zwraca VTWG DQQN PQVAURCEG EJCT E ] TGVWTP KUURCEG E _ XGEVQTUVTKPI URNKV EQPUV UVTKPI UVT ] V[RGFGH UVTKPIEQPUVAKVGTCVQT KVGT XGEVQTUVTKPI TGV KVGT K UVTDGIKP YJKNG K UVTGPF ] pomiń wprowadzające znaki odstępu K HKPFAKH K UVTGPF PQVAURCEG znajdź koniec bie ącego wyrazu KVGT L HKPFAKH K UVTGPF URCEG kopiuj znaki z zakresu =K L KH K UVTGPF TGVRWUJADCEM UVTKPI K L K L _ TGVWTP TGV _ W kodzie nowej wersji funkcji widać sporo nowości wymagających objaśnienia. W grun- cie rzeczy jednak powy sza implementacja stanowi nieco inne wcielenie dotychcza- sowego algorytmu, wykorzystującego K i L do wyznaczania granic odszukanego wyrazu ciągu UVT, zgodnie z wytycznymi z §5.6/125. Po znalezieniu słowa, jego kopia jest do- łączana do kontenera TGV. Tym razem jednak K oraz L są iteratorami, a nie indeksami. Do wygodnego posługiwa- nia się typem iteraotra wykorzystaliśmy definicję V[RGFGH, dzięki czemu później mo - na było korzystać z nazwy typu KVGT w miejsce nazwy UVTKPIEQPUVAKVGTCVQT. I choć typ UVTKPI nie obsługuje wszystkich operacji charakterystycznych dla kontenerów, ob- sługuje iteratory, dzięki czemu mo emy w stosunku do znaków umieszczonych w ciągu UVTKPI wykorzystywać algorytmy biblioteki standardowej, podobnie, jak czyniliśmy to w odniesieniu do elementów kontenera typu XGEVQT.

20. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 29 Wykorzystywanym w tym wcieleniu funkcji algorytmem jest HKPFAKH. Pierwszymi dwoma argumentami wywołania tego algorytmu są iteratory ograniczające analizowany ciąg. Trzeci argument jest predykatem sprawdzającym przekazany argument i zwraca- jącym wartość VTWG bądź HCNUG. Funkcja HKPFAKH wywołuje predykat dla ka dego elementu we wskazanym zbiorze, przerywając działanie w momencie napotkania pierwszego elementu spełniającego predykat. Biblioteka standardowa udostępnia funkcję KUURCEG, która sprawdza, czy przekazany argumentem znak nale y do grupy znaków odstępu. Funkcja ta jest jednak przecią ona pod kątem obsługi języków takich jak, na przykład, japoński, korzystających z rozsze- rzonego typu znaku YEJCTAV (patrz §1.3/32). Nie jest łatwo przekazać funkcję przecią- oną jako bezpośredni argument szablonu funkcji. Kłopot z takim przekazaniem polega na tym, e kompilator nie „wie”, której wersji funkcji przecią onej u yć w wywołaniu szablonu funkcji; nie mo e tego rozstrzygnąć na podstawie argumentów wywołania funkcji przecią onej, poniewa w wywołaniu argumentów tych nie ma. Z tego wzglę- du udostępniliśmy własny predykat dla algorytmu HKPFAKH, a konkretnie dwa takie pre- dykaty: URCEG i PQVAURCEG; dzięki nim staje się jasne, której wersji funkcji KUURCEG ma u yć kompilator. Pierwsze wywołanie funkcji HKPFAKH wyszukuje znak niebędący znakiem odstępu roz- poczynający kolejny wyraz. Pamiętajmy, e znaki odstępów mogą znajdować się rów- nie przed pierwszym z wyrazów. Tych znaków nie chcemy wyprowadzać na wyjście. Po zakończeniu pierwszego wywołania funkcji HKPFAKH K wskazuje pierwszy niebędący odstępem znak ciągu UVT. Wskazanie to wykorzystywane jest w drugim wywołaniu funkcji HKPFAKH, która z kolej wyszukuje pierwszy znak odstępu za pozycją K i przed koń- cem ciągu. Je eli funkcji nie uda się znaleźć znaku spełniającego predykat, zwraca drugi argument, który w naszym przypadku będzie miał wartość UVTGPF . Tak więc L zostanie zainicjalizowane wartością iteratora odnoszącego się do pierwszego znaku za znakiem K będącym znakiem spacji, ewentualnie wartością UVTGPF , je eli takiego znaku w ciągu nie było. W tej fazie wykonania K i L ograniczają kolejny znaleziony wyraz ciągu UVT. Zostało ju tylko skorzystanie z wartości iteratorów do skopiowania podciągu z ciągu UVT do kontenera TGV. W poprzedniej wersji funkcji URNKV do tego zadania wytypowana została funkcja UVTKPIUWDUVT. Poniewa jednak w nowej wersji funkcji URNKV nie mamy ju indeksów, a jedynie iteratory, a funkcja UWDUVT nie jest przecią ona dla argumentów tego typu, musimy skonstruować podciąg typu UVTKPI jako kopię ograniczonego iteratorami ciągu UVT. Realizujemy to w wyra eniu UVTKPI K L, które wygląda podobnie do definicji zmiennej URCEGU pokazanej w §1.2/30. W tym przykładzie obiekt typu UVTKPI inicjalizowany jest kopią znaków w zakresie =K L. Obiekt ten jest następnie za po- średnictwem metody RWUJADCEM kierowany do kontenera TGV. Warto wskazać, e nowa wersja programu pomija testowanie indeksu K pod kątem zrów- nania się z UVTUKG . Nie ma te odpowiedników tych testów porównujących iteratory z UVTGPF . Przyczyną tego stanu rzeczy jest fakt, e algorytmy biblioteki standardowej są zaprojektowane i zaimplementowane z uwzględnieniem obsługi wywołań z przekazaniem zakresu pustego. Je eli, na przykład, w którymś momencie pierwsze z wywołań HKPFAKH ustawi wartość iteratora K na UVTGPF , wtedy nie ma konieczności

21. 30 Accelerated C++. Practical Programming by Example wykrywania tego faktu przed kolejnym wywołaniem funkcji HKPFAKH z tym iteratorem — HKPFAKH wykryje fakt przekazania ciągu pustego =K UVTGPF i zwróci w takim przypadku UVTGPF , sygnalizując jednocześnie brak spełnienia predykatu. 6.1.2. Palindromy Kolejnym zadaniem związanym z manipulowaniem ciągami, do którego realizacji mo- emy wykorzystać algorytmy biblioteki standardowej, jest sprawdzanie, czy zadany wyraz jest palindromem. Palindromy to wyrazy, czytane tak samo w przód i wspak. Przy- kłady palindromów to: „kajak”, „oko”, „Anna”, „potop” czy „radar”. Oto rozwiązanie postawionego zadania: DQQN KUARCNKPFTQOG EQPUV UVTKPI ] TGVWTP GSWCN UDGIKP UGPF UTDGIKP _ Wyra enie wartości zwracanej w powy szej funkcji korzysta z wywołania GSWCN i metody TDGIKP; obu tych funkcji nigdy dotąd nie wykorzystywaliśmy. Podobnie jak metoda DGIKP, TDGIKP zwraca iterator, tyle e iterator ten rozpoczyna wskazanie od ostatniego elementu kontenera, a jego zwiększanie powoduje cofanie wskazania do poprzednich elementów kontenera. Funkcja GSWCN porównuje dwie sekwencje znaków i określa, czy sekwencje te zawierają identyczne znaki. Pierwsze dwa argumenty wywołania to iteratory ograniczające pierw- szą z sekwencji. Trzeci argument to iterator odnoszący się do początku sekwencji drugiej. Funkcja GSWCN zakłada, e sekwencja numer dwa ma rozmiar identyczny z roz- miarem sekwencji pierwszej, stąd brak konieczności określania iteratora kończącego drugą sekwencję. Jako e trzecim argumentem wywołania, a więc początkiem drugiej sekwencji porównania, jest UTDGIKP , efektem wywołania jest porównanie znaków z początku kontenera (ciągu) ze znakami końca kontenera. Funkcja GSWCN porównuje kolejno pierwszy znak ciągu U z ostatnim znakiem, następnie drugi znak ciągu ze znakiem przedostatnim i tak dalej. Działanie takie idealnie spełnia warunki rozwiązania postawionego zadania. 6.1.3. Wyszukiwanie w tekście adresów URL W ramach ostatniego przykładu przetwarzania ciągów znakowych napiszemy funkcję, która w przekazanym ciągu typu UVTKPI wyszuka adresy zasobów sieci WWW, zwane te identyfikatorami URL. Funkcję taką mo na wykorzystać do przeglądania dokumentu (po ich uprzednim skopiowaniu do zmiennej typu UVTKPI) w poszukiwaniu zawartych w tym dokumencie identyfikatorów URL. Funkcja powinna odnaleźć wszystkie identyfikatory URL występujące w tekście dokumentu. Identyfikator URL jest ciągiem znaków postaci: nazwa-protokołunazwa-zasobu

22. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 31 gdzie nazwa-protokołu mo e zawierać wyłącznie litery, gdy nazwa-zasobu mo e skła- dać się z liter, cyfr oraz rozmaitych znaków przestankowych i specjalnych. Nasza funkcja powinna przyjmować ciąg typu UVTKPI i wyszukiwać w nim wystąpienia sekwencji znaków . W przypadku odnalezienia takiego zestawu znaków funkcja powinna od- szukać poprzedzającą go nazwę protokołu i następującą po nim nazwę zasobu. Jako e projektowana funkcja powinna odnaleźć wszystkie identyfikatory URL wy- stępujące w tekście, wartością zwracaną powinien być kontener typu XGEVQTUVTKPI , w którym ka dy z elementów reprezentowałby pojedynczy identyfikator URL. Dzia- łanie funkcji opiera się na przesuwaniu iteratora wzdłu przekazanego ciągu i wyszukiwanie w tym ciągu znaków . W momencie odnalezienia ciągu funkcja wyszukuje wstecz wyraz będący nazwą protokołu i w przód ciąg będący nazwą zasobu URL: XGEVQTUVTKPI HKPFAWTNU EQPUV UVTKPI U ] XGEVQTUVTKPI TGV V[RGFGH UVTKPIEQPUVAKVGTCVQT KVGT KVGT D UDGIKP G UGPF przejrzyj cały ciąg wejściowy YJKNG D G ] poszukaj jednego lub kilku znaków, po których znajduje się podciąg D WTNADGI D G jeśli udało się znaleźć podciąg KH D G ] pobierz resztę URL-a KVGT CHVGT WTNAGPF D G zapamiętaj znaleziony URL TGVRWUJADCEM UVTKPI D G zwiększ D i szukaj następnych identyfikatorów D CHVGT _ _ TGVWTP TGV _ Funkcja zaczyna się od zadeklarowania TGV jako kontenera typu XGEVQT, przechowu- jącego docelowo znalezione identyfikatory URL, oraz od zdefiniowania iteratorów ogra- niczających wejściowy ciąg typu UVTKPI. Musimy jeszcze napisać funkcje WTNADGI i WTNAGPF. Pierwsza z nich będzie wyszukiwać początek ka dego z identyfikatorów URL przekazanego ciągu i ewentualnie zwracać iterator ustawiony na początek podciągu nazwa-protokołu; je eli w ciągu wejściowym nie uda się znaleźć URL-a, funkcja WTNA DGI powinna zwrócić drugi argument wywołania (tutaj G), sygnalizując w ten sposób niepowodzenie. Gdy WTNADGI wyszuka początek identyfikatora URL, resztą zajmuje się WTNAGPF. Funkcja ta przeszukuje ciąg od wskazanej pozycji początkowej a do osiągnięcia końca ciągu wejściowego albo znalezienia znaku, który nie mo e być częścią identyfikatora URL. Funkcja zwraca iterator ustawiony na pozycję następną za pozycją ostatniego znaku identyfikatora.

23. 32 Accelerated C++. Practical Programming by Example Po wywołaniu funkcji WTNADGI i WTNAGPF iterator D powinien odnosić się do początku znalezionego identyfikatora URL, a iterator CHVGT powinien wskazywać pozycję na- stępną za pozycją ostatniego znaku identyfikatora, jak na rysunku 6.1. Rysunek 6.1. Podział obowiązków w zadaniu wyszukiwania identyfikatora URL Ze znaków znajdujących się we wskazanym iteratorami zakresie konstruowany jest nowy ciąg typu UVTKPI umieszczany w kontenerze TGV. W tym momencie mo na ju tylko zwiększyć wartość iteratora D i przejść do wyszukiwania następnego identyfikatora. Poniewa identyfikatory nie mogą na siebie nachodzić, D mo na ustawić na znak następny za ostatnim znakiem właśnie znalezionego identyfikatora URL; pętlę YJKNG nale y kontynuować a do przetworzenia wszystkich znaków ciągu wejściowego. Po wyjściu z tej pętli zwracany przez funkcję kontener TGV zawierać będzie wszystkie URL-e występujące w ciągu wejściowym. Pora na zastanowienie się nad implementacją funkcji WTNADGI i WTNAGPF. Na pierwszy ogień pójdzie funkcja prostsza, a więc WTNAGPF: UVTKPIEQPUVAKVGTCVQT WTNAGPF UVTKPIEQPUVAKVGTCVQT D UVTKPIEQPUVAKVGTCVQT G ] TGVWTP HKPFAKH D G PQVAWTNAEJCT _ Funkcja przegląda kolejne znaki wskazanego zakresu, poddając je analizie za pośred- nictwem funkcji HKPFAKH, którą poznaliśmy w §6.1.1/144. Predykat przekazany w wy- wołaniu funkcji HKPFAKH, PQVAWTNAEJCT, musimy napisać własnoręcznie. Powinien on zwracać wartość VTWG dla znaku, który nie mo e znaleźć się w identyfikatorze URL: DQQN PQVAWTNAEJCT EJCT E ] znaki (poza znakami alfanumerycznymi) dozwolone w identyfikatorach URL UVCVKE EQPUV UVTKPI WTNAEJ `! A sprawdź, czy E jest dozwolonym znakiem URL TGVWTP KUCNPWO E ^^ HKPF WTNAEJDGIKP WTNAEJGPF E WTNAEJGPF _ Powy sza funkcja, choć niepozorna, wykorzystuje kilka nowych elementów. Po pierwsze, w definicji ciągu znaków dozwolonych w identyfikatorze URL pojawiło się słowo UVCVKE. Zmienne lokalne deklarowane jako statyczne (właśnie ze słowem UVCVKE) są zachowywane pomiędzy wywołaniami funkcji. Zmienna typu UVTKPI o nazwie WTNAEJ będzie więc konstruowana i inicjalizowana jedynie podczas realizacji pierwszego wy- wołania funkcji PQVAWTNAEJCT. Kolejne wywołania zastaną gotową wartość typu UVTKPI. Dodatkowo słowo EQPUV zapewnia niezmienność wartości zmiennej WTNAEJ po jej ini- cjalizacji.

24. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 33 Funkcja PQVAWTNAEJCT wykorzystuje wywołanie funkcji KUCNPWO zdefiniowanej w nagłów- ku EEV[RG . Funkcja ta sprawdza, czy przekazany znak jest znakiem alfanumerycznym (czyli czy jest literą lub cyfrą). Wykorzystane w tej funkcji wywołanie HKPF jest kolejnym algorytmem biblioteki standardowej. Jego działanie jest podobne do HKPFAKH z tym, e zamiast wywoływać predykat, funkcja HKPF samodzielnie porównuje kolejne znaki z trzecim argumentem wywo- łania. Je eli w sekwencji określonej dwoma pierwszymi argumentami znajduje się wartość określona argumentem trzecim, funkcja zwraca iterator ustawiony na miejsce pierwszego wystąpienia zadanej wartości w sekwencji. W przypadku nieodnalezienia zadanej wartości funkcja HKPF zwraca drugi argument. Teraz widać, jak dokładnie działa funkcja PQVAWTNAEJCT. Poniewa wartość zwracana stanowi negację całego wyra enia, PQVAWTNAEJCT zwraca wartość HCNUG, je eli zadany znak oka e się literą, cyfrą bądź znakiem dozwolonym w identyfikatorze URL, a okre- ślonym w ciągu WTNAEJ. Dla ka dej innej wartości argumentu E funkcja zwraca war- tość VTWG. Pora na najtrudniejsze — implementację funkcji WTNADGI. Funkcja ta jest nieco zagma- twana, poniewa musi obsługiwać potencjalną sytuację zawierania się w ciągu wejścio- wym sekwencji w kontekście, który wyklucza istnienie wokół tej sekwencji identyfikatora URL. W praktyce implementacja takiej funkcji wykorzystywałaby zapewne zdefiniowaną uprzednio listę dozwolonych nazw protokołów. My, dla uproszczenia, ograniczymy się do zagwarantowania, e sekwencję poprzedza podciąg jednego lub więcej znaków i przynajmniej jeden znak znajduje się za tą sekwencją. UVTKPIEQPUVAKVGTCVQT WTNADGI UVTKPIEQPUVAKVGTCVQT D UVTKPIEQPUVAKVGTCVQT G ] UVCVKE EQPUV UVTKPI UGR V[RGFGH UVTKPIEQPUVAKVGTCVQT KVGT K sygnalizuje odnalezienie separatora KVGT K D YJKNG K UGCTEJ K G UGRDGIKP UGRGPF G ] upewnij się, e separator nie rozpoczyna się od początku ciągu KH K D K UGRUKG G ] DGI zaznacza początek nazwy-protokołu KVGT DGI K YJKNG DGI D KUCNRJC DGI=? DGI czy za i przed separatorem znajduje się przynajmniej po jednym znaku? KH DGI K PQVAWTNAEJCT K=UGRUKG ? TGVWTP DGI _

25. 34 Accelerated C++. Practical Programming by Example odnaleziony separator nie jest częścią URL-a; zwiększ i poza pozycję ostatniego znaku sepraratora K UGRUKG _ TGVWTP G _ Najprostszą częścią tej funkcji jest jej nagłówek. Wiadomo, e w wywołaniu przeka- zane zostaną dwa iteratory określające zakres przetwarzanego ciągu i e funkcja ma zwrócić iterator ustawiony na początek pierwszego z odnalezionych identyfikatorów URL. Oczywista jest te deklaracja lokalnej zmiennej typu UVTKPI, w której przecho- wywane są znaki składające się na wyró niający identyfikator URL separator nazwy protokołu i nazwy zasobu. Podobnie, jak w funkcji PQVAWTNAEJCT (§7.1.1/148), zmienna ta jest zmienną statyczną i stałą. Nie będzie więc mo na zmieniać w funkcji wartości zmiennej — zostanie ona ustalona przy pierwszym wykonaniu funkcji WTNADGI. Działanie funkcji opiera się na ustaleniu wartości dwóch iteratorów w zakresie wy- znaczanym iteratorami D i G. Iterator K ma wskazywać początek separatora URL, a iterator DGI początek znajdującego się przed separatorem podciągu zawierającego nazwę protokołu (rysunek 6.2). Rysunek 6.2. Pozycjonowanie iteratorów w funkcji url_beg Na początek funkcja odnajduje pierwsze wystąpienie separatora, wykorzystując wywo- łanie UGCTEJ (funkcję biblioteki standardowej), którego wcześniej nie stosowaliśmy. Funkcja UGCTEJ przyjmuje dwie pary iteratorów: pierwsza para odnosi się do sekwencji, w której następuje wyszukiwanie, druga określa sekwencję wyszukiwaną. Podobnie jak ma to miejsce w przypadku pozostałych funkcji biblioteki standardowej, je eli funkcji UGCTEJ nie uda się odnaleźć zadanego ciągu, zwraca iterator wskazujący na koniec przeszukiwanego ciągu. Po zakończeniu realizacji funkcji UGCTEJ iterator K mo e przyjąć dwie wartości — albo będzie wskazywał element następny za ostatnim ciągu wejścio- wego, albo zawierać będzie pozycję dwukropka rozpoczynającego separator . Po odnalezieniu separatora nale y odszukać litery składające się na nazwę protokołu. Najpierw nale y jednak sprawdzić, czy separator nie znajduje się na samym początku albo na samym końcu przeszukiwanego ciągu; w obu tych przypadkach mamy do czynienia z niepełnym identyfikatorem URL, poniewa identyfikator taki powinien zawierać przynajmniej po jednym znaku z obu stron separatora. Je eli separator rokuje mo liwo- ści dopasowania identyfikatora URL, nale y spróbować ustawić iterator DGI. W we- wnętrznej pętli YJKNG iterator DGI jest przesuwany w tył, a do momentu, gdy dotrze do początku ciągu albo do pierwszego znaku niebędącego znakiem alfanumerycznym. Wi- dać tutaj zastosowanie dwóch nowych elementów kodu: pierwszym jest wykorzystanie faktu, e je eli kontener obsługuje indeksowanie, to podobną obsługę definiują iteratory tego kontenera. Innymi słowy, DGI=? jest znakiem bezpośrednio poprzedzającym znak wskazywany przez DGI. Zapis DGI=? nale y tu traktować jako skróconą wersję zapisu

26. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 35

27. DGI . O tego typu iteratorach powiemy więcej w §8.2.6/200. Drugi nowy element to wykorzystanie funkcji KUCNRJC zdefiniowanej w nagłówku EEV[RG biblioteki standardowej; funkcja ta sprawdza, czy przekazany argument (znak) zawiera literę. Je eli uda się cofnąć iterator choćby o jeden znak, mo na zało yć, e znak ten tworzy nazwę protokołu. Przed zwróceniem wartości DGI nale y jednak jeszcze sprawdzić, czy przynajmniej jeden dopuszczalny znak znajduje się równie po prawej stronie separatora . Ten test jest nieco bardziej skomplikowany. Wiadomo, e w ciągu wej- ściowym znajduje się przynajmniej jeden znak za separatorem; wiadomo to stąd, e pozytywnie wypadł test ró ności K UGRUKG z wartością G wskazującą koniec ciągu. Do znaku tego mo emy się odwołać za pośrednictwem K=UGRUKG ?, co odpowiada zapisowi

28. K UGRUKG . Nale y jeszcze sprawdzić, czy znak ten nale y do znaków dozwolonych w identyfikatorze URL, przekazując ów znak do wywołania PQVAWTNAEJCT. Funkcja ta zwraca wartość VTWG dla znaków niedozwolonych; po zane- gowaniu wartości zwracanej dowiemy się, czy przekazany znak jest dozwolony w identyfikatorze URL. Je eli separator nie jest częścią poprawnego identyfikatora URL, funkcja zwiększa war- tość iteratora K i kontynuuje wyszukiwanie. W prezentowanym kodzie po raz pierwszy znalazł zastosowanie operator dekrementacji (zmniejszenia o jeden) wymieniony w tabeli operatorów §2.7/54. Operator ten działa podobnie jak operator inkrementacji, tyle e zamiast zwiększać, zmniejsza wartość operandu. Równie ten operator mo na stosować jako operator przedrostkowy bądź przyrost- kowy. Zastosowana tu wersja przedrostkowa zmniejsza wartość operandu i zwraca jego nową wartość. 6.2. Porównanie metod wyznaczania ocen W §4.2/93 zaprezentowaliśmy metodę oceniania studentów w oparciu o ocenę pośred- nią, ocenę z egzaminu końcowego i medianę ocen zadań domowych. Metoda ta mo e zostać nadu yta przez sprytnych studentów, którzy rozmyślnie mogą nie wykonywać niektórych prac domowych. W końcu połowa gorszych ocen nie wpływa na ostateczny wynik. Wystarczy bowiem odrobić dobrze połowę zadań domowych, aby uzyskać wynik identyczny jak osoba, która tak samo dobrze wykonała wszystkie prace domowe. Z naszego doświadczenia wynika, e większość studentów nie będzie próbować wy- korzystywać tej luki w metodzie oceniania. Mieliśmy jednak okazję prowadzić zajęcia w grupie, której studenci czynili to otwarcie. Zastanawialiśmy się wtedy, czy średnia ocen studentów którzy omijali prace domowe, mo e być zbli ona do średniej studentów, któ- rzy sumiennie pracowali w czasie wolnym. Zastanawiając się nad odpowiedzią na to pytanie, uznaliśmy, e warto być mo e sprawdzić odpowiedź na to pytanie w kontek- ście dwóch ró nych metod oceniania:

29. 36 Accelerated C++. Practical Programming by Example Przy u yciu średniej w miejsce mediany (zadania nieodrobione oceniane są na 0 punktów). Przy u yciu mediany tylko tych zadań, które student odrobił. Dla ka dego z tych schematów oceny nale ało porównać medianę ocen studentów, którzy oddawali wszystkie prace domowe z medianą ocen studentów, którzy pominęli jedno lub więcej zadań samodzielnych. Mający pomóc w udzieleniu odpowiedzi program powinien realizować dwa zadania: 1. Wczytywać wpisy wszystkich studentów i wyodrębniać wpisy tych studentów, którzy oddali wszystkie prace domowe. 2. Zastosować obie metody oceniania do obu grup; wypisać na urządzeniu wyjściowym medianę ocen ka dej z grup. 6.2.1. Przetwarzanie wpisów studentów Pierwszym postawionym zadaniem jest wczytanie i klasyfikacja wpisów studentów. Na szczęście dysponujemy ju pewnym kodem, który rozwiązywał podobny problem postawiony w jednym z wcześniejszych rozdziałów. Do wczytania wpisów studentów mo emy bowiem wykorzystać typ 5VWFGPVAKPHQ z §4.2.1/94 i związaną z obsługą tego typu funkcję TGCF (§4.2.2/94). Nie mamy natomiast funkcji, która sprawdzałaby liczbę oddanych prac domowych. Jej napisanie nie stanowi jednak problemu: DQQN FKFACNNAJY EQPUV 5VWFGPVAKPHQ U ] TGVWTP HKPF UJQOGYQTMDGIKP UJQOGYQTMGPF UJQOGYQTMGPF _ Funkcja ta sprawdza, czy kontener JQOGYQTM wpisu studenta U zawiera jakiekolwiek wartości zerowe. Przyjęliśmy tu, e sam fakt oddania pracy domowej jest punktowany, więc wartości zerowe odpowiadają pracom niezrealizowanym w ogóle. Wartość zwracana przez funkcję HKPF porównywana jest z wartością JQOGYQTMGPF , jak bowiem pamiętamy, funkcja HKPF zwraca w przypadku nieodnalezienia zadanej wartości drugi argument wywołania. Dzięki dwóm wspomnianym funkcjom implementacja kodu wczytującego i klasyfiku- jącego wpisy studentów jest znacznie uproszczona. Wystarczy bowiem wczytywać kolejne wpisy, sprawdzać, czy student oddał wszystkie zadania domowe, i w zale ności od wyniku testu dołączyć wpis do jednego z dwóch kontenerów typu XGEVQT, o nazwach FKF (dla studentów sumiennych) i FKFPV (dla leniwych). Potem nale y sprawdzić, czy któryś z kontenerów nie jest przypadkiem pusty, co uniemo liwiłoby dalszą analizę: XGEVQT5VWFGPVAKPHQ FKF FKFPV 5VWFGPVAKPHQ UVWFGPV wczytaj wszystkie wpisy, pogrupuj je według kryterium odrobienia prac domowych YJKNG TGCF EKP UVWFGPV ] KH FKFACNNAJY UVWFGPV FKFRWUJADCEM UVWFGPV

30. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 37 GNUG FKFPVRWUJADCEM UVWFGPV _ sprawdź, czy oba kontenery zawierają jakieś wpisy KH FKFGORV[ ] EQWV CFGP G UVWFGPVÎY PKG QFTQDK YU[UVMKEJ RTCE FQOQY[EJ TGVWTP _ KH FKFPVGORV[ ] EQWV 9U[UE[ UVWFGPEK QFTQDKNK YU[UVMKG RTCEG FQOQYG TGVWTP _ Jedyną nowinką w powy szym kodzie jest wywoływanie metody GORV[, zwracającej wartość VTWG dla kontenera pustego i HCNUG dla kontenera zawierającego jakieś elementy. Ten sposób sprawdzania zawartości kontenera jest lepszy ni porównywanie rozmiaru zwracanego przez UKG z zerem, poniewa w przypadku niektórych rodzajów kontenerów sprawdzenie, czy w kontenerze w ogóle coś się znajduje mo e być realizowane du o szybciej ni policzenie liczby znajdujących się w nim elementów. 6.2.2. Analiza ocen Umiemy ju wczytać wpisy studentów i sklasyfikować je jako przynale ące do kontenera FKF bądź do kontenera FKFPV. Następne zadanie to analiza wpisów; przed przystą- pieniem do takiej analizy wypadałoby zastanowić się nad jej zało eniami. Wiemy, e trzeba będzie wykonać trzy analizy, a ka da z nich ma się składać z dwóch części, osobno dla studentów, którzy odrobili wszystkie zadania domowe i dla tych, któ- rzy to zaniedbali. Poniewa analizy obejmować będą dwa zbiory danych, najlepiej by- łoby zaimplementować je w postaci osobnych funkcji. Jednak e niektóre operacje, takie jak wydruk zestawienia w ustalonym formacie, realizowane będą wobec par wyników analiz. Nale y więc zaimplementować w postaci funkcji wydruk zestawienia analizy par zbiorów wartości. Najgorsze, e docelowo program powinien wywoływać funkcję, która trzykrotnie (raz dla ka dego rodzaju analizy) wypisywałaby na urządzeniu wyjściowym wyniki analizy. Ka da z funkcji analitycznych powinna być wywołana dwukrotnie, raz dla kontenera FKF, raz dla kontenera FKFPV. Tyle e funkcja generująca zestawienie powinna za ka dym razem wywoływać inną funkcję analityczną! Jak to zrobić? Rozwiązaniem najprostszym jest zdefiniowanie trzech funkcji analitycznych i przeka- zywanie ich kolejno do funkcji generującej wydruk wyników. Argumentów typu funk- cyjnego ju u ywaliśmy, między innymi przy przekazywaniu funkcji EQORCTG do funkcji bibliotecznej UQTV (§4.2.2/96). W takim przypadku funkcja generująca zestawienia powinna przyjmować pięć argumentów: Strumień wyjściowy, do którego zapisywane byłyby ciągi wydruku. Ciąg UVTKPI reprezentujący nazwę analizy.

31. 38 Accelerated C++. Practical Programming by Example Funkcję analityczną. Dwa argumenty będące kontenerami typu XGEVQT zawierającymi dane wejściowe analizy. Załó my, dla przykładu, e pierwsza analiza, wyznaczająca mediany ocen prac domowych, realizowana jest przez funkcję o nazwie OGFKCPACPCN[UKU. Wyprowadzenie wy- ników tej analizy w stosunku do obu grup studentów oznaczałoby realizację następu- jącego wywołania: YTKVGACPCN[UKU EQWV OGFKCP OGFKCPACPCN[UKU FKF FKFPV Zanim zdefiniujemy funkcję YTKVGACPN[UKU powinniśmy zaimplementować funkcję OGFKCPACPCN[UKU. Funkcja ta powinna przyjmować kontener (typu XGEVQT) wpisów stu- dentów; na podstawie tych wpisów funkcja powinna obliczać oceny końcowe studen- tów zgodnie z przyjętą metodą oceniania studentów i zwrócić medianę obliczonych ocen. Funkcja taka mogłaby mieć postać: ta funkcja nie całkiem działa FQWDNG OGFKCPACPCN[UKU EQPUV XGEVQT5VWFGPVAKPHQ UVWFGPVU ] XGEVQTFQWDNG ITCFGU VTCPUHQTO UVWFGPVUDGIKP UVWFGPVUGPF DCEMAKPUGTVGT ITCFGU ITCFG TGVWTP OGFKCP ITCFGU _ Choć na pierwszy rzut oka funkcja mo e wydawać się skomplikowana, wprowadza tylko jedną nową funkcję — funkcję VTCPUHQTO. Przyjmuje ona trzy iteratory i jedną funkcję. Pierwsze dwa iteratory definiują zakres elementów do przetworzenia; trzeci iterator to iterator kontenera docelowego wyników przetwarzania — w kontenerze tym zapisywane będą wyniki funkcji przetwarzającej, przekazywanej czwartym argumentem. Wywołując funkcję VTCPUHQTO, musimy zadbać o to, aby w kontenerze docelowym było dość miejsca na zachowanie wyników przetwarzania wejściowej sekwencji elementów. W tym przypadków nie jest to problemem, poniewa kontener docelowy wskazujemy iteratorem DCEMAKPUGTVGT (patrz §6.1/142), powodującym automatyczne dołączanie wy- ników działania funkcji VTCPUHQTO do kontenera ITCFGU; kontener ten będzie dzięki zastosowaniu tego iteratora rozszerzany w miarę dodawania kolejnych elementów potrzeby. Czwartym argumentem wywołania funkcji VTCPUHQTO jest funkcja przekształcająca (przetwarzająca) elementy wskazane zakresem wejściowym; jest ona wywoływana dla ka dego elementu z tego zakresu, a wartości zwracane przez funkcję umieszczane są w kontenerze docelowym. W powy szym przykładzie wywołanie funkcji VTCPUHQTO oznacza zastosowanie do elementów kontenera UVWFGPVU funkcji ITCFG; wyniki zwracane przez funkcję ITCFG umieszczane są w kontenerze ITCFGU. Po skompletowaniu w kontenerze ITCFGU ocen końcowych studentów, wywołujemy funkcję OGFKCP z §4.1.1/83, obliczającą medianę wartości przechowywanych w kontenerze ITCFGU. Jest tylko jeden problem. Zgodnie z uwagą poprzedzającą kod, funkcja w tym kształ- cie niezupełnie działa.

32. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 39 Przyczyną takiego stanu rzeczy jest to, e mamy kilka przecią onych wersji funkcji ITCFG. Kompilator nie jest w stanie określić w wywołaniu VTCPUHQTO, o jaką wersję funkcji ITCFG mo e chodzić, poniewa w wywołaniu tym nie ma adnych argumentów funkcji ITCFG. My wiemy, e chodzi o wersję zdefiniowaną w §4.2.2/95. Trzeba jeszcze znaleźć sposób na przekazanie tej informacji kompilatorowi. Drugą niedoskonałością powy szego kodu jest to, e funkcja ITCFG zgłasza wyjątek w przypadku, kiedy student nie ma adnych ocen zadań domowych, tymczasem funkcja VTCPUHQTO tych wyjątków w aden sposób nie obsługuje. Je eli więc zdarzy się wyją- tek, realizacja funkcji VTCPUHQTO zostanie zatrzymana, a sterowanie przeniesione do funkcji OGFKCPACPCN[UKU. Poniewa funkcja OGFKCPACPCN[UKU równie nie przechwytuje ani nie obsługuje wyjątków, wyjątek będzie propagowany dalej w górę stosu wywołań funkcji. W efekcie równie funkcja OGFKCPACPCN[UKU zostanie przedwcześnie przerwana, przekazując sterowanie do wywołującego i tak dalej, a wyjątek zostanie przechwycony odpowiednią klauzulą ECVEJ. Je eli klauzuli takiej zabraknie (z czym mielibyśmy do czynienia w proponowanej funkcji) przerywane jest działanie całego programu, a na urzą- dzeniu wyjściowym wyświetlany jest komunikat o zgłoszeniu wątku (albo i nie, zale - nie od implementacji). Oba problemy mo emy rozwiązać za pośrednictwem pomocniczej funkcji, która będzie realizować wywołanie ITCFG wewnątrz instrukcji VT[ oraz zajmie się obsługą ewentual- nych wyjątków. Poniewa w tej funkcji wywołanie funkcji ITCFG będzie jawne, kompilator (na podstawie argumentów wywołania) nie będzie miał kłopotów z wytypowaniem wersji funkcji ITCFG do realizacji wywołania: FQWDNG ITCFGACWZ EQPUV 5VWFGPVAKPHQ U ] VT[ ] TGVWTP ITCFG U _ ECVEJ FQOCKPAGTTQT ] TGVWTP ITCFG UOKFVGTO UHKPCN _ _ Ta funkcja przechwytuje wyjątki zgłaszane w funkcji ITCFG. W przypadku pojawienia się wyjątku zostanie on obsłu ony w ramach klauzuli ECVEJ. Obsługa polega na wywo- łaniu funkcji ITCFG z trzecim argumentem o wartości — zało yliśmy przecie , e brak pracy domowej oznacza zero punktów. Je eli więc dany student nie odrobił adnej z prac, wtedy ogólna ocena pracy domowej będzie wynosiła równie . Do oceny końcowej liczone więc będą wyłącznie ocena z egzaminu końcowego i ocena pośrednia. Mo emy ju przepisać funkcję analityczną tak, aby korzystała z pomocniczego wywo- łania ITCFGACWZ: ta wersja działa znakomicie FQWDNG OGFKCPACPCN[UKU EQPUV XGEVQT5VWFGPVAKPHQ UVWFGPVU ] XGEVQTFQWDNG ITCFGU VTCPUHQTO UVWFGPVUDGIKP UVWFGPVUGPF DCEMAKPUGTVGT ITCFGU ITCFGACWZ TGVWTP OGFKCP ITCFGU _

33. 40 Accelerated C++. Practical Programming by Example Znając ju postać funkcji analitycznej, mo emy przejść do zdefiniowania funkcji YTKVGA CPCN[UKU, która wykorzystuje funkcję analityczną do porównania dwóch grup studentów: XQKF YTKVGACPCN[UKU QUVTGCO QWV EQPUV UVTKPI PCOG FQWDNG CPCN[UKU EQPUV XGEVQT5VWFGPVAKPHQ EQPUV XGEVQT5VWFGPVAKPHQ FKF EQPUV XGEVQT5VWFGPVAKPHQ FKFPV ] QWV PCOG OGFKCPC ITWRC UVWFGPVÎY UQNKFP[EJ CPCN[UKU FKF OGFKCPC ITWRC UVWFGPVÎY PKGUQNKFP[EJ CPCN[UKU FKFPV GPFN _ Funkcja ta jest zaskakująco krótka, choć wprowadza kolejne nowości. Pierwszą z nich jest sposób definiowania parametru reprezentującego funkcję. Definicja parametru CPCN[UKU wygląda identycznie jak deklaracja funkcji napisanej w §4.3/100 (co prawda w §10.1.2/230 przekonamy się, e ró nice są większe, ni się wydaje, mo emy je jednak pominąć jako nie mające wpływu na bie ące omówienie). Druga nowinka to typ wartości zwracanej przez funkcję — void. Zastosowanie typu XQKF jest ograniczone między innymi właśnie do definiowania typu wartości zwracanej. Wi- dząc funkcję zwracającą typ XQKF, widzimy funkcję, która tak naprawdę nie zwraca adnej wartości. Z takiej funkcji wychodzi się za pośrednictwem instrukcji TGVWTP pozba- wionej wartości, na przykład: TGVWTP Wykonanie funkcji zwracającej typ XQKF mo e zostać zakończone równie w wyniku dotarcia do klamry kończącej kod funkcji. W innych funkcjach takie zakończenie funkcji jest niedozwolone; w funkcjach niezwracających wartości mo emy pominąć instruk- cję TGVWTP. Teraz mo emy napisać pozostały kod programu: KPV OCKP ] studenci, którzy nie odrobili wszystkich zadań domowych XGEVQT5VWFGPVAKPHQ FKF FKFPV wczytaj wszystkie wpisy, pogrupuj je według kryterium odrobienia prac domowych YJKNG TGCF EKP UVWFGPV ] KH FKFACNNAJY UVWFGPV FKFRWUJADCEM UVWFGPV GNUG FKFPVRWUJADCEM UVWFGPV _ sprawdź, czy oba kontenery zawierają jakieś wpisy KH FKFGORV[ ] EQWV CFGP G UVWFGPVÎY PKG QFTQDK YU[UVMKEJ RTCE FQOQY[EJ TGVWTP _ KH FKFPVGORV[ ] EQWV 9U[UE[ UVWFGPEK QFTQDKNK YU[UVMKG RTCEG FQOQYG TGVWTP _

34. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 41 przystąp do analizy YTKVGACPCN[UKU EQWV OGFKCPC OGFKCPACPCN[UKU FKF FKFPV YTKVGACPCN[UKU EQWV TGFPKC CXGTCIGACPCN[UKU FKF FKFPV YTKVGACPCN[UKU EQWV OGFKCPC RTCE QFFCP[EJ QRVKOKUVKEACPCN[UKU FKF FKFPV TGVWTP _ Zostało ju tylko uzupełnić program o funkcje CXGTCIGACPCN[UKU i QRVKOKUVKEAOGFKCPA CPCN[UKU. 6.2.3. Wyznaczanie ocen na podstawie średniej ocen prac domowych Funkcja CXGTCIGACPCN[UKU powinna obliczań oceny studentów przy uwzględnieniu nie mediany, ale wartości średniej ocen prac domowych. Logicznym początkiem implementacji powinno być napisanie funkcji obliczającej wartość średnią elementów kontenera typu XGEVQT i następnie wykorzystanie jej w miejsce funkcji OGFKCP w funkcji obliczającej ocenę końcową (ITCFG): FQWDNG CXGTCIG EQPUV XGEVQTFQWDNG X ] TGVWTP CEEWOWNCVG XDGIKP XGPF XUKG _ Funkcja ta wywołuje funkcję CEEWOWNCVG, która — w przeciwieństwie do dotychczas stosowanych algorytmów biblioteki standardowej — definiowana jest w nagłówki PWOGTKE . Jak wskazuje nazwa tego nagłówka, udostępnia on narzędzia wykorzystywane w obliczeniach numerycznych. Funkcja CEEWOWNCVG dodaje serię wartości z zakresu określonego wartościami dwóch pierwszych argumentów, zakładając początkową sumę o wartości równej wartości trzeciego argumentu. Typ wartości zwracanej zale ny jest od typu trzeciego argumentu; z tego względu nie wolno w miejsce podać wartości — ta ostatnia jest bowiem wartością typu KPV, co przy dodawaniu zaowocowałoby obcięciem części ułamkowych składników sumy. Po uzyskaniu sumy wszystkich elementów kontenera dzielimy ją przez wartość XUKG , a więc przez liczbę elementów kontenera. Wynikiem dzielenia jest rzecz jasna średnia arytmetyczna wartości kontenera; średnia ta zwracana jest do wywołującego. Dysponując funkcją CXGTCIG mo emy wykorzystać ją w implementacji funkcji CXGTCIGA ITCFG realizującej zmodyfikowaną metodę oceniania studentów według średnich ocen z zadań domowych: FQWDNG CXGTCIGAITCFG EQPUV 5VWFGPVAKPHQ U ] TGVWTP ITCFG UOKFVGTO UHKPCN CXGTCIG UJQOGYQTM _

35. 42 Accelerated C++. Practical Programming by Example Tutaj do obliczenia średniej ocen studenta z zadań domowych wywoływana jest funkcja CXGTCIG. Wartość zwracana przez tę funkcję przekazywana jest bezpośrednio do funkcji ITCFG (patrz §4.1/82) wyliczającej ostateczną ocenę studenta. Dysponując tak rozbudowaną infrastrukturą, w prosty sposób utworzymy funkcję CXG TCIGACPCN[UKU: FQWDNG CXGTCIGACPCN[UKU EQPUV XGEVQT5VWFGPVAKPHQ UVWFGPVU ] XGEVQTFQWDNG ITCFGU VTCPUHQTO UVWFGPVUDGIKP UVWFGPVUGPF DCEMAKPUGTVGT ITCFGU CXGTCIGAITCFG TGVWTP OGFKCP ITCFGU _ Funkcję tę ró ni od funkcji OGFKCPACPCN[UKU (§6.2.2/155) jedynie nazwa i wywołanie CXGTCIGAITCFG w miejsce ITCFGACWZ. 6.2.4. Mediana kompletu ocen zadań domowych Ostatnia analiza, realizowana funkcją QRVKOKUVKEACPCN[UKUAUEJGOG, wyznacza ocenę studenta w oparciu o optymistyczne zało enie, e oceny studentów z tych prac domowych, których nie oddali, są identyczne z ocenami zadań, które zrealizowali. Przy takim zało- eniu będziemy obliczać medianę ocen tylko tych prac domowych, które zostały przez studenta oddane (przedło one do oceny). Medianę taką nazwiemy medianą optymi- styczną. Nale y oczywiście uwzględnić ewentualność taką, e student nie oddał adnej z prac domowych — w takim przypadku medianę jego ocen nale ałoby wyzna- czyć jako : mediana optymistyczna niezerowej liczby prac domowych ( dla zerowej liczby prac domowych) FQWDNG QRVKOKUVKEAOGFKCP EQPUV 5VWFGPVAKPHQ U ] XGEVQTFQWDNG PQPGTQ TGOQXGAEQR[ UJQOGYQTMDGIKP UJQOGYQTMGPF DCEMAKPUGTVGT PQPGTQ KH PQPGTQGORV[ TGVWTP ITCFG UOKFVGTO UHKPCN GNUG TGVWTP ITCFG UOKFVGTO UHKPCN OGFKCP PQPGTQ _ Powy sza funkcja wyodrębnia z ocen studenta niezerową liczbę ocen prac domowych i umieszcza je w nowym kontenerze typu XGEVQT o nazwie PQPGTQ. Mając niezerową liczbę ocen z zadań domowych, wywołujemy dla nich i pozostałych ocen studenta wer- sję funkcji ITCFG, zdefiniowaną w §4.1/82; wyliczana w miejscu przekazania argumentu mediana uwzględnia jedynie prace oddane. Jedyną nowością jest w powy szym kodzie sposób wypełniania kontenera PQPGTQ — wykorzystywana jest do tego funkcja TGOQXGAEQR[. Aby zrozumieć jej działanie, warto wiedzieć, e biblioteka standardowa udostępnia wersje „kopiujące” wielu typowych

36. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 43 algorytmów. Dla przykładu, algorytm TGOQXGAEQR[ realizuje zasadniczo to, co algorytm TGOQXG (czyli usuwa elementy z kontenera), tyle e elementy nie są usuwane z kontenera, a jedynie kopiowane do kontenera wskazywanym trzecim argumentem. Konkretnie, funkcja wyszukuje i „usuwa” z kontenera wszystkie elementy o wartości zgodnej z wartością zadaną jednym z argumentów wywołania. Wszystkie elementy sekwencji wejściowej, które nie zostały „usunięte”, kopiowane są do kontenera docelowego. Niebawem dowiemy się, co znaczy w tym kontekście „usunięcie” elementu. Funkcja TGOQXGAEQR[ przyjmuje trzy iteratory i wartość typu zale nego od typu kontenera. Tradycyjnie ju pierwsze dwa iteratory określają zakres elementów do przetworzenia. Trzeci iterator wskazuje miejsce w kontenerze docelowym. Implementacja algorytmu TGOQXGAEQR[ zakłada, e kontener docelowy dysponuje miejscem wymaganym do umieszczania w nim kolejnych kopii przetwarzanych elementów. W prezentowanym wywołaniu o odpowiedni rozmiar kontenera docelowego troszczy się iterator DCEMA KPUGTVGT. Efektem działania algorytmu TGOQXGAEQR[ w postaci, w jakiej został tu wywołany jest skopiowanie do kontenera PQPGTQ wszystkich niezerowych elementów kontenera UJQOGYQTM. Po sprawdzeniu, czy kontener PQPGTQ nie jest przypadkiem pusty, nastę- puje wyznaczenie z niego mediany i przekazanie jej do wywołania funkcji ITCFG, ob- liczającej ostateczną ocenę studenta. Je eli kontener PQPGTQ jest pusty, do wywołania ITCFG przekazywana jest — w miejsce mediany — wartość . Potrzebujemy jeszcze funkcji realizującej samą analizę z wykorzystaniem funkcji QRVKOKUVKEAOGFKCP. Jej implementacja będzie jednak ćwiczeniem dla Czytelnika. 6.3. Klasyfikacja studentów — podejście drugie W rozdziale 5. rozwiązywaliśmy zadanie kopiowania wpisów studentów, którzy nie zaliczyli kursu, do osobnego kontenera typu XGEVQT; wpisy tych studentów były te usuwane z kontenera źródłowego. Okazało się, e najprostsze rozwiązanie problemu klasyfikacji (dzielenia na grupy) cechuje się niedopuszczalną degradacją wydajności w miarę wzrostu rozmiaru danych wejściowych. Pokazaliśmy wtedy, jak problem małej wydaj- ności wyeliminować przy u yciu kontenera typu NKUV; obiecaliśmy sobie równie , e do problemu wrócimy przy okazji omawiania algorytmów. Dzięki algorytmom biblioteki standardowej mo emy zaproponować dwa kolejne roz- wiązania problemu klasyfikacji. Pierwsze z nich jest nieco wolniejsze, poniewa wykorzystuje dwa algorytmy i dwukrotnie odwiedza ka dy z elementów. Przy zastosowaniu bardziej specjalizowanego algorytmu to samo zadanie mo na rozwiązać w jednym prze- biegu, przeglądając ka dy z elementów zbioru wejściowego jednokrotnie.

37. 44 Accelerated C++. Practical Programming by Example 6.3.1. Rozwiązanie dwuprzebiegowe W pierwszym podejściu wykorzystamy strategię podobną do tej zakładanej w §6.2.4/158, kiedy chcieliśmy wyodrębnić z kontenera te wpisy, które zawierały niezerową liczbę ocen zadań domowych. Nie chcieliśmy wtedy w aden sposób modyfikować kontenera JQOGYQTM, więc do skopiowania wpisów o niezerowej liczbie ocen prac domowych do osobnego kontenera wykorzystaliśmy funkcję TGOQXGAEQR[. W naszym bie ącym zadaniu musimy ju nie tylko skopiować, ale faktycznie usunąć z pierwotnego kontenera elementy mające być umieszczone w kontenerze PQPGTQ: XGEVQT5VWFGPVAKPHQ GZVTCEVAHCKNU XGEVQT5VWFGPVAKPHQ UVWFGPVU ] XGEVQT5VWFGPVAKPHQ HCKN TGOQXGAEQR[AKH UVWFGPVUDGIKP UVWFGPVUGPF DCEMAKPUGTVGT HCKN RITCFG UVWFGPVUGTCUG TGOQXGAKH UVWFGPVUDGIKP UVWFGPVUGPF HITCFG UVWFGPVUGPF TGVWTP HCKN _ Interfejs programu jest identyczny z tym prezentowanym w §5.3/118, implementującym klasyfikację za pośrednictwem kontenerów typu XGEVQT i indeksów. Podobnie jak tam, tu równie przekazany w wywołaniu kontener typu XGEVQT ma docelowo zawierać wpisy tych studentów, którzy kurs zaliczyli, pozostałe wpisy mają zostać skopiowane do kontenera HCKN (tak e typu XGEVQT). Na tym podobieństwa się kończą. W oryginalnej wersji programu do przeglądania kolejnych elementów kontenera słu- ył iterator KVGT; wskazywane przez niego elementy były kopiowane do kontenera HCKN, a następnie, za pośrednictwem składowej GTCUG, usuwane z kontenera UVWFGPVU. Tym razem kopiowanie wpisów studentów, którzy nie przekroczyli progu zaliczenia, odbywa się za pośrednictwem funkcji TGOQXGAEQR[AKH. Funkcja ta działa podobnie jak TGOQXGA EQR[ (§6.2.4/158) z tym, e w miejsce bezpośredniej wartości porównania tu wyko- rzystywany jest predykat. Predykatem tym jest funkcja odwracająca działanie funkcji HITCFG (§5.1/110): DQQN RITCFG EQPUV 5VWFGPVAKPHQ U ] TGVWTP HITCFG U _ Przekazując do funkcji TGOQXGAEQR[AKH predykat, ądamy, aby funkcja „usunęła” ka dy element, dla którego wywołanie predykatu zwróci wartość VTWG. „Usuwanie” oznacza tu „niekopiowanie” — kopiowane są więc tylko te elementy, które nie spełniają predykatu (predykat daje dla nich wartość HCNUG). Predykat RITCFG zaś jest skonstruowany tak, e wywołanie TGOQXGAEQR[AKH kopiuje wpisy studentów, którzy oblali kurs. Następna instrukcja jest cokolwiek zło ona. Po pierwsze mamy w niej wywołanie TGOQXGA KH, „usuwające” elementy kontenera odpowiadające wpisom studentów z ocenami ne- gatywnymi. Znowu jednak cudzysłów otaczający słowo „usuwające” sugeruje, e tak naprawdę nie dochodzi do usunięcia elementów. Zamiast usuwać, funkcja TGOQXGAKH kopiuje wszystkie te elementy, które nie spełniają predykatu (tu: wszystkie wpisy stu- dentów, którzy kurs zaliczyli).

38. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 45 Wywołanie jest nieco karkołomne, poniewa zakresem źródłowym i docelowym funkcji TGOQXGAKH jest ten sam zakres tego samego kontenera. Funkcja ta kopiuje na początek kontenera elementy niespełniające predykatu. Załó my, przykładowo, e pierwotnie kontener zawierał wpisy siedmiu studentów z następującymi ocenami (rysunek 6.3): Rysunek 6.3. Przykładowa zawartość kontenera students Funkcja TGOQXGAKH pozostawi dwa pierwsze wpisy nietknięte, poniewa znajdują się one w odpowiednich miejscach (na początku kontenera). Następne dwa wpisy zostaną „usu- nięte” w tym sensie, e zostaną potraktowane jako puste miejsca do wykorzystania przez następne wpisy, które powinny pozostać w kontenerze. Piąty wpis, reprezentujący studenta pozytywnie zaliczającego kurs, jest zatem kopiowany na pierwszą „wolną” pozycję kontenera, a więc na pozycję pierwszego „usuniętego” elementu kontenera (rysunek 6.4): Rysunek 6.4. Zawartość kontenera students po przetworzeniu go funkcją remove_if W takim układzie efektem wykonania funkcji TGOQXGAKH będzie przesunięcie czterech wpisów studentów z ocenami pozytywnymi na początek kontenera — pozostałe wpisy pozostaną nietknięte. Aby wiadomo było, które z elementów kontenera nale y wziąć pod uwagę w dalszym przetwarzaniu, funkcja TGOQXGAKH zwraca iterator wskazujący element następny po ostatnim elemencie, który nie został „usunięty” (rysunek 6.5): Rysunek 6.5. Zawartość kontenera students a wartość zwracana przez funkcję remove_if Po uło eniu wpisów sumiennych studentów na początku kontenera, nale y go obciąć, usuwając fizycznie pozostałe wpisy. Obcięcie realizowane jest za pomocą niewyko- rzystywanej dotąd wersji składowej GTCUG. Przyjmuje ona dwa iteratory i usuwa wszystkie elementy z zakresu ograniczanego tymi iteratorami. Usuwając elementy pomiędzy iteratorem zwracanym przez funkcję TGOQXGAKH i iteratorem UVWFGPVUGPF , usuwamy z kontenera wszystkie wpisy studentów, którzy oblali kurs (rysunek 6.6): Rysunek 6.6. Zawartość kontenera students po wywołaniu składowej erase

39. 46 Accelerated C++. Practical Programming by Example 6.3.2. Rozwiązanie jednoprzebiegowe Przedstawione w poprzednim punkcie (§6.3.1/160) rozwiązanie działa znakomicie, ale nie oznacza to, e nie da się zadania rozwiązać jeszcze efektywniej. Widać bowiem, e kod prezentowany w §6.3.1/160 oblicza ocenę końcową ka dego studenta dwukrotnie — raz w funkcji TGOQXGAEQR[AKH, drugi raz w TGOQXGAKH. Choć nie istnieje algorytm biblioteki standardowej, który załatwiłby nasz problem w jednym wywołaniu, istnieje taki, którego wykorzystanie wią e się z zupełnie innym po- dejściem do rozwiązania — algorytm ten przyjmuje na wejście sekwencję wartości i zmienia jej uporządkowanie tak, aby wartości spełniające zadany predykat znajdo- wały się przed wartościami niespełniającymi predykatu. Algorytm ten dostępny jest w dwóch wersjach: RCTVKVKQP i UVCDNGARCTVKVKQP. Ró nica między nimi polega na tym, e RCTVKVKQP dopuszcza zmianę wzajemnego uporząd- kowania wartości tej w ramach tej samej kategorii, podczas gdy UVCDNGARCTVKVKQP zachowuje wzajemne uporządkowanie wartości jednej kategorii. Gdyby, na przykład, kontener wpisów studentów zostałby wcześniej posortowany alfabetycznie, to do po- działu studentów na grupy nale ałoby u yć algorytmu UVCDNGARCTVKVKQP. Obie wersje algorytmu zwracają iterator reprezentujący pierwszy element drugiej grupy wartości. Dzięki nim mo emy dokonać podziału studentów na dwie grupy w sposób następujący: XGEVQT5VWFGPVAKPHQ GZVTCEVAHKNG XGEVQT5VWFGPVAKPHQ UVWFGPVU ] XGEVQT5VWFGVPVAKPHQ KVGTCVQT KVGT UVCDNGARCTVKVKQP UVWFGPVUDGIKP UVWFGPVUGPF RITCFG XGEVQT5VWFGPVAKPHQ HCKN KVGT UVWFGPVUGPF UVWFGPVUGTCUG KVGT UVWFGPVUGPF TGVWTP HCKN _ Aby zrozumieć działanie powy szego kodu, najlepiej posłu yć się naszym hipotetycz- nym zbiorem danych (rysunek 6.7): Rysunek 6.7. Pierwotna zawartość kontenera students Po wywołaniu funkcji UVCDNGARCTVKVKQP otrzymujemy następujące uporządkowanie ele- mentów kontenera (rysunek 6.8): Rysunek 6.8. Zawartość kontenera students po wywołaniu stable_partition

40. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 47 Kontener HCKN został skonstruowany jako kopia wpisów studentów sklasyfikowanych jako oblewających kurs, czyli wpisów znajdujących się w zakresie =KVGT UVWFGPVU GPF . Elementy tego zakresu zostały następnie usunięte z kontenera UVWFGPVU. Uruchamiając nasze rozwiązania wykorzystujące algorytmy biblioteki standardowej, zauwa ymy, e wykonywane są one z wydajnością porównywalną z wydajnością naszego rozwiązania wykorzystującego kontenery typu NKUV. Zgodnie z oczekiwaniami, wraz ze wzrostem liczby wpisów podawanych na wejście programu program wykorzy- stujący kontener typu list wyraźnie zwiększa przewagę nad swoim odpowiednikiem wy- korzystującym kontener XGEVQT. Tymczasem obie wersje algorytmiczne są tak efektywne, e czas ich wykonania dla zbioru 75 000 wpisów jest w du ej mierze determinowany wydajnością operacji wejścia. Aby porównać efekty działania obu tych wersji, trzeba analizować osobno czas wykonania wyłącznie funkcji GZVTCEVAHCKNU. Pomiar czasu potwierdził, e implementacja jednoprzebiegowa działa prawie dwukrotnie szybciej od implementacji dwuprzebiegowej. 6.4. Algorytmy, kontenery, iteratory Zrozumienie koncepcji kontenerów, iteratorów i algorytmów wymaga przyjęcia do wia- domości podstawowego zało enia biblioteki standardowej wyra anego zdaniem: Algorytmy operują na elementach kontenerów — nie na samych kontenerach. Funkcje UQTV, TGOQXG czy RCTVKVKQP przesuwają elementy na nowe pozycje w ramach ich kontenera macierzystego, nie zmieniają jednak właściwości samego kontenera. Przy- kładowo, wywołanie TGOQXGAKH nie zmienia rozmiaru kontenera, którego elementami ope- ruje — ogranicza się do kopiowania elementów wewnątrz kontenera. To rozró nienie jest szczególnie istotne w zrozumieniu sposobu, w jaki algorytmy od- wołują się do kontenerów określanych w tych algorytmach jako kontenery docelowe. Przyjrzyjmy się bli ej sposobowi u ycia funkcji TGOQXGAKH z punktu §6.3.1/160. Było to wywołanie o postaci: TGOQXGAKH UVWFGPVUDGIKP UVWFGPVUGPF HITCFG Wywołanie to nie modyfikuje rozmiaru kontenera UVWFGPVU. Kopiuje tylko elementy, dla których predykat HITCFG daje wartość HCNUG na początek kontenera, pozostawiając resztę elementów nietkniętą. Je eli zachodzi potrzeba obcięcia kontenera typu XGEVQT w celu pozbycia się „usuniętych” elementów, musimy to zrobić samodzielnie. W naszym kodzie przykładowym zapisaliśmy: UVWFGPVUGTCUG TGOQXGAKH UVWFGPVUDGIKP UVWFGPVUGPF HITCFG UVWFGPVUGPF Tutaj składowa GTCUG modyfikuje kontener, usuwając sekwencję określaną argumentami. Wywołanie to skraca kontener UVWFGPVU tak, aby zawierał wyłącznie po ądane wpisy. Zauwa my, e GTCUG, jako funkcja operująca nie tylko elementami kontenera, ale i nim samym (zmieniając jego rozmiar), musi być metodą obiektu kontenera.

41. 48 Accelerated C++. Practical Programming by Example Warto te uświadomić sobie kategorie interakcji pomiędzy iteratorami i algorytmami oraz pomiędzy iteratorami i operacjami na kontenerach. Przekonaliśmy się ju (w §5.3/118 i §5.5.1/122) o tym, e operacje na kontenerach, jak GTCUG czy KPUGTV uniewa niają iteratory elementu usuwanego. Co wa niejsze, w przypadku typów XGEVQT i UVTKPI operatory takie jak KPUGTV i GTCUG powodują równie uniewa nienie wszelkich iteratorów odnoszących się do elementów znajdujących się za elementem wstawianym (usuwanym). Fakt potencjalnego uniewa niania iteratorów w wyniku działania tych operacji zmusza do ostro ności przy ewentualnym zachowywaniu wartości iteratorów w zmiennych pętli. Równie wywołania funkcji takich jak RCTVKVKQP czy TGOQXGAKH, przemieszczających elementy wewnątrz kontenera, mogą doprowadzić do podmiany elementu wskazywanego przez iteratory kontenera — po wywołaniu jednej z takich funkcji nie mo na polegać na poprzednich wartościach iteratorów i odwoływać się za ich pomocą do ele- mentów kontenera. 6.5. Podsumowanie Modyfikatory typów: UVCVKE typ zmienna; Dla definicji lokalnych modyfikator UVCVKE oznacza deklarację zmiennej przechowywanej statycznie. Wartość takiej zmiennej jest podtrzymywana pomiędzy wykonaniami zasięgu, w którym zmienna została zdefiniowana. Zmienna taka będzie te inicjalizowana przed pierwszym jej u yciem. Kiedy program opuszcza zasięg zmiennej, jej wartość jest zapamiętywana do czasu ponownego wkroczenia programu w jej zasięg. W §13.4/317 zobaczymy, e interpretacja modyfikatora UVCVKE zmienia się w zale ności od kontekstu. Typy. Sposób wykorzystania wbudowanego typu XQKF jest ograniczone; jednym z takich zastosowań jest określenie typu wartości zwracanej przez funkcję — funkcja zadekla- rowana jako zwracająca wartość typu XQKF nie zwraca adnej wartości. Kod takiej funkcji nale y kończyć instrukcją TGVWTP. Mo na te pominąć instrukcję TGVWTP — funkcja zostanie zakończona po dotarciu do końca jej ciała. Adaptory iteratorów to funkcje zwracające iteratory. Najpopularniejszymi takimi funkcjami są adaptory generujące iteratory KPUGTVAKVGTCVQT, a więc iteratory, które dynamicz- nie zwiększają rozmiar skojarzonego z nimi kontenera. Iteratorów takich mo na u ywać jako określenia miejsca przeznaczenia w algorytmach kopiujących. Adaptory zdefinio- wane są w nagłówku KVGTCVQT . Wśród nich znajdziemy: DCEMAKPUGTVGT E Zwraca iterator kontenera E pozwalający na dołączanie elementów na koniec kontenera E. Kontener musi obsługiwać metodę RWUJADCEM (obsługują ją, miedzy innymi, kontenery typu NKUV, XGEVQT i ciągi typu UVTKPI).

42. Rozdział 6. ♦ Korzystanie z algorytmów biblioteki standardowej 49 HTQPVAKPUGTVGT E Zwraca iterator kontenera E pozwalający na wstawianie elementów na początek kontenera E. Kontener musi obsługiwać metodę RWUJAHTQPV (obsługuje ją kontener typu NKUV, ale nie XGEVQT i UVTKPI). KPUGTVGT E KV Jak DCEMAKPUGTVGT, tyle e wstawia elementy przed iterator KV. Algorytmy. O ile nie zaznaczono inaczej, algorytmy wykorzystywane w tekście rozdziału definiowane były w nagłówku CNIQTKVJO . Znajdziemy tam następujące algorytmy: CEEWOWNCVG D G V Tworzy zmienną lokalną i inicjalizuje ją kopią wartości V (typu zgodnego z typem wartości V, co oznacza, e typ ten ma zasadnicze znaczenie dla sposobu działania algorytmu CEEWOWNCVG) zwiększoną o wartości wszystkich elementów z zakresu =D G. Algorytm zdefiniowany w nagłówku PWOGTKE . HKPF D G V HKPFAKH D G R UGCTEJ D G D G Algorytmy wyszukujące określoną wartość w sekwencji elementów z zakresu =D G. Algorytm HKPF wyszukuje wartość V; HKPFAKH poddaje ka dy z elementów testowi prawdziwości predykatu R; UGCTEJ wyszukuje w sekwencji =D G sekwencji =D G. EQR[ D G F TGOQXGAEQR[ D G F V TGOQXGAEQR[AKH D G F R Algorytmy kopiujące sekwencję z zakresu =D G do miejsca docelowego wskazywanego wartością F. Algorytm EQR[ kopiuje całość wskazanej sekwencji; TGOQXGAEQR[ kopiuje wszystkie elementy ró ne od V; TGOQXGAEQR[AKH kopiuje wszystkie elementy, dla których predykat R ma wartość HCNUG. TGOQXGAKH D G R Zmienia uporządkowanie elementów w kontenerze w zakresie =D G, tak aby elementy niespełniające zadanego predykatu R znalazły się na początku kontenera. Zwraca iterator wskazujący element następny za ostatnim elementem przeniesionym na początek kontenera. TGOQXG D G V Podobna do TGOQXGAKH, z tym, e w miejsce predykatu stosuje porównanie z wartością V. VTCPUHQTO D G H F Wykonuje funkcję H dla ka dego elementu sekwencji =D G; wartość zwracaną przez funkcję H umieszcza w F.

43. 50 Accelerated C++. Practical Programming by Example RCTVKVKQP D G R UVCDNGARCTVKVKQP D G R Grupuje elementy w zakresie =D G w zale ności od predykatu R, tak aby elementy spełniające predykat znajdowały się przed elementami, dla których predykat daje wartość HCNUG. Zwraca iterator odnoszący się do pierwszego elementu grupy niespełniającej predykatu, ewentualnie zwraca G, je eli wszystkie elementy zakresu spełniały predykat. Wersja UVCDNGARCTVKVKQP zachowuje wzajemne uporządkowanie elementów w ramach grup. Ćwiczenia Ćwiczenie 6.0. Skompiluj, uruchom i sprawdź działanie programów prezentowanych w tym rozdziale. Ćwiczenie 6.1. Zmodyfikuj funkcję HTCOG i JECV z §5.8.1/130 i §5.8.3/132 tak, aby korzystały z iteratorów. Ćwiczenie 6.2. Napisz program testujący działanie funkcji HKPFAWTNU. Ćwiczenie 6.3. Jak działa poni szy fragment kodu? XGEVQTKPV W XGEVQTKPV X EQR[ WDGIKP WGPF XDGIKP Napisz program zawierający taki fragment, skompiluj go i uruchom. Ćwiczenie 6.4. Popraw program napisany w ramach poprzedniego ćwiczenia. Mo na to zrobić na, co najmniej, dwa sposoby. Zaimplementuj oba i opisz wzajemne zalety i wady obu roz- wiązań. Ćwiczenie 6.5. Napisz funkcję analityczną korzystającą z funkcji QRVKOKUVKEACPCN[UKU. Ćwiczenie 6.6. Zauwa , e funkcja z poprzedniego ćwiczenia oraz funkcje z §6.2.2/155 i §6.2.3/158 realizują to samo zadanie. Połącz je w jedną funkcję analityczną.

44. ♦ Korzystanie z algorytmów biblioteki standardowej 51 Ćwiczenie 6.7. Fragment programu analitycznego z §6.2.1/152, odpowiedzialny za wczytanie i klasy- fikację wpisów studentów na podstawie liczby wykonanych prac domowych jest podobny do implementacji funkcji GZVTCEVAHCKNU. Napisz funkcję, która będzie rozwią- zywała podobne podzadania. Ćwiczenie 6.8. Napisz pojedynczą funkcję, którą będzie mo na wykorzystać do klasyfikowania stu- dentów w zale ności od wskazanego kryterium. Sprawdź poprawność działania tej funkcji, stosując ją w miejsce funkcji GZVTCEVAHCKNU; wykorzystaj nową funkcję w progra- mie analizującym oceny studentów. Ćwiczenie 6.9. Wykorzystaj algorytm biblioteki standardowej do konkatenacji wszystkich elementów kontenera typu XGEVQTUVTKPI .

C++. Potęga języka. Od przykładu do przykładu

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (19)

Ähnlich wie C++. Potęga języka. Od przykładu do przykładu

Ähnlich wie C++. Potęga języka. Od przykładu do przykładu (19)

Mehr von Wydawnictwo Helion

Mehr von Wydawnictwo Helion (20)

C++. Potęga języka. Od przykładu do przykładu