Operatory 1. Priorytety i wiązanie

Transkrypt

1 Operatory 1 Operatorami są pojawiające się w tekście programu leksemy (znak dodawania, znak gwiazdki, znak procentu) które są interpretowane jako żądanie wywołania odpowiednich funkcji operujących na danych określonych przez wyrażenia sąsiadujące z danym operatorem - są to argumenty tego operatora. Operatory generalnie dzielą się na jedno- i dwuargumentowe. Jak w większości (choć nie we wszystkich!) języków programowania, w C/C++ zapis operatorów dwuargumentowych jest infiksowy (wrostkowy), czyli operator stawiany jest pomiędzy swoimi argumentami. Z kolei zapis operatorów jednoargumentowych, z dwoma wyjątkami, jest prefiksowy (przedrostkowy), czyli operator stawiamy przed argumentem. Istnieje w C/C++ również jeden operator trzyargumentowy: operator selekcji (operator warunkowy? :). Priorytety i wiązanie Zapis infiksowy, wygodny i naturalny dla ludzi, prowadzi jednak do sytuacji, gdy z samego zapisu nie wynika kolejność wykonania działań w złożonych wyrażeniach. Na przykład w wyrażeniu a + b / c zmienna b może być traktowana jako prawy argument operatora dodawania albo lewy argument operatora dzielenia. W pierwszym przypadku obliczymy (a + b)/c, a w drugim a+(b/c) otrzymując różny wynik. Aby uniknąć tego rodzaju wieloznaczności, wprowadzono pojęcie priorytetu operatorów. Według priorytetu operatory dzielą się na szereg grup, w ramach których priorytety są jednakowe. W sytuacjach, jak opisana powyżej, gdy to samo wyrażenie może być potraktowane jako argument dwóch operatorów, najpierw zostanie wykonana operacja opisywana przez ten z tych dwóch operatorów który ma wyższy priorytet. Jeśli natomiast oba mają ten sam priorytet, kolejność wykonywania operacji będzie określona ich wiązaniem: od lewej do prawej dla operatorów o wiązaniu lewym i od prawej do lewej dla operatorów o wiązaniu prawym. Aby ta reguła nie prowadziła do sprzeczności, operatory o takim samym priorytecie muszą mieć taki sam kierunek wiązania (co w istocie zachodzi). A zatem w wyrażeniu a + b / c najpierw zostanie wykonane dzielenie, gdyż ma wyższy priorytet od dodawania. Ale w wyrażeniu a + b - c najpierw zostanie wykonane dodawanie, gdyż ma ten sam priorytet co odejmowanie, a oba operatory mają wiązanie lewe. Dla operatora przypisania wiązanie jest prawe. Tak więc w wyrażeniu a=b=c przypisanie b=c 1 W oparciu o: 1

2 wykonane zostanie najpierw, a jego wynik (wartość b po tej operacji) przypisany będzie do zmiennej a. Ale np. operator wyboru składowej ( kropka ) ma wiązanie lewe, zatem obiekt.sklad1.sklad2 oznacza: najpierw wybierz składową sklad1 obiektu obiekt, potem z wynikowego obiektu składową sklad2. Wszystkie prefiksowe (przedrostkowe) operatory jednoargumentowe mają wiązanie prawe: najpierw działa operator z prawej strony, czyli bliższy argumentu. Tak więc *++p to to samo co *(++p), natomiast ++*p to ++(*p), bo choć przedrostkowy operator inkrementacji ' ++' i operator wyłuskania wartości (dereferencji) ' *' mają ten sam priorytet, oba mają wiązanie prawe. Przegląd operatorów W tabeli poniżej przedstawiono wszystkie operatory języka C++. W prawej kolumnie użyte są oznaczenia klasa: nazwa klasy sklad: składowa klasy lub przestrzeni nazw wyr: wyrażenie pnazw: nazwa przestrzeni nazw obiekt: obiekt klasy wsk: wskaźnik lnaz: l-nazwa typ: nazwa typu nazw: nazwa Operatory podzielone są na 17 grup - każda grupa odpowiada operatorom o tym samym priorytecie. Grupy wymienione są w kolejności od grupy operatorów o priorytecie najwyższym, w dół według malejącego priorytetu. Tabela: Operatory w języku C++ Priorytet 17 1 zasięg klasy klasa::sklad 2 zasięg przestrzeni nazw pnazw::sklad 3 zasięg globalny ::nazw Priorytet 16 4 wybór składowej obiekt.sklad 5 wybór składowej wsk->sklad 6 wybór elementu przez indeks wsk[wyr] 7 wywołanie funkcji wyr(lista_wyr) 8 konstrukcja wartości typ(lista_wyr) 9 przyrostkowe zmniejszenie lwart przyrostkowe zwiększenie lwart++ 11 statyczna identyfikacja typu typeid(typ) 12 dynamiczna identyfikacja typu typeid(wyr) 13 statyczna konwersja static_cast<typ>(wyr) 2

3 14 dynamiczna konwersja dynamic_cast<typ>(wyr) 15 konwersja wymuszona reinterpret_cast<typ>(wyr) 16 konwersja uzmienniająca const_cast<typ>(wyr) Priorytet pobranie rozmiaru obiektu sizeof wyr 18 pobranie rozmiaru typu sizeof(typ) 19 przedrostkowe zmniejszenie - -lwart 20 przedrostkowe zwiększenie ++lwart 21 negacja bitowa wyr 22 negacja logiczna!wyr 23 minus jednoargumentowy -wyr 24 plus jednoargumentowy +wyr 25 wyłuskanie adresu &lwart 26 dereferencja *wyr 27 przydział pamięci na obiekt new typ 28 przydział pam. na obiekt z inicjowaniem new typ(lista_wyr) 29 lokalizujący przydział pamięci new (lista_wyr) typ 30 jak wyżej, z inicjowaniem new (lista_wyr) typ(lista_wyr) 31 zwolnienie pamięci delete wsk 32 zwolnienie pamięci tablicowej delete [] wsk 33 rzutowanie (konwersja) (typ)wyr Priorytet wybór składowej przez wskaźnik wsk->*wsk 35 wybór składowej przez wskaźnik wsk.*wsk Priorytet mnożenie wyr * wyr 37 dzielenie wyr / wyr 38 reszta z dzielenia wyr % wyr Priorytet dodawanie wyr + wyr 40 odejmowanie wyr - wyr Priorytet przesunięcie bitowe w lewo wyr wyr 42 przesunięcie bitowe w prawo wyr wyr Priorytet mniejsze od wyr < wyr 3

4 44 mniejsze lub równe wyr <= wyr 45 większe od wyr > wyr 46 większe lub równe wyr >= wyr Priorytet 9 47 równe wyr = = wyr 48 nierówne wyr! = wyr Priorytet 8 49 koniunkcja bitowa wyr & wyr Priorytet 7 50 bitowa różnica symetryczna wyr ^ wyr Priorytet 6 51 alternatywa bitowa wyr wyr Priorytet 5 52 koniunkcja (iloczyn) logiczna wyr && wyr Priorytet 4 53 alternatywa (suma) logiczna wyr wyr Priorytet 3 54 selekcja wyr? wyr : wyr Priorytet 2 55 przypisanie lwart = wyr 56 dodawanie z przypisaniem lwart += wyr 57 odejmowanie z przypisaniem lwart -= wyr 58 mnożenie z przypisaniem lwart *= wyr 59 dzielenie z przypisaniem lwart /= wyr 60 reszta z przypisaniem lwart %= wyr 61 przesunięcie w lewo z przypisaniem lwart = wyr 62 przesunięcie w prawo z przypisaniem lwart = wyr 63 iloczyn bitowy z przypisaniem lwart &= wyr 64 alternatywa bitowa z przypisaniem lwart = wyr 65 różnica bitowa z przypisaniem lwart ^= wyr Priorytet 1 66 zgłoszenie wyjątku throw wyr 67 operator przecinkowy wyr, wyr Niektóre z tych operatorów, szczególnie te związane z klasami, konwersjami, przestrzeniami nazw i obsługą wyjątków zostaną przedstawione później. 4

5 Operatory zasięgu Operatory te, o najwyższym priorytecie, wymienione w tabeli operatorów na pozycjach 1-3, zapisywane za pomocą symbolu czterokropka (' ::'). Operator zasięgu globalnego ::. Zmienne globalne mogą być przesłonięte, jeśli wewnątrz funkcji (lub bloku) zadeklarujemy inną zmienną o tej samej nazwie (choć niekoniecznie tym samym typie). Wówczas nazwa tej zmiennej w ciele funkcji odnosi się do zmiennej lokalnej. Zmienna globalna istnieje, ale jest w zakresie funkcji (bloku) niewidoczna. Nie znaczy to, że nie mamy do niej dostępu. Do przesłoniętej zmiennej globalnej możemy odwołać się poprzez operator zasięgu ' ::' ( czterokropek ). Jeśli na przykład przesłonięta została zmienna o nazwie k, to do globalnej zmiennej o tej nazwie odwołać się można poprzez nazwę kwalifikowaną ::k. Operatory zasięgu klasy (pozycja pierwsza w tabeli) będzie omówiony na wykładzie o klasach. przesl.cpp Widoczność i przesłanianie zmiennych 1. #include <iostream> 2. using namespace std; int k; //zmienna globalna int main(void) 7. { 8. cout << " k: " << k << endl; 9. cout << "::k: " << ::k << endl; int k = 10; cout << " k: " << k << endl; 14. cout << "::k: " << ::k << endl; ::k = 1; cout << " k: " << k << endl; 19. cout << "::k: " << ::k << endl; { 22. int k = 77; 23. cout << "W bloku:" << endl; 24. cout << " k: " << k << endl; 25. cout << "::k: " << ::k << endl; 26. } cout << "Po bloku:" << endl; 29. cout << " k: " << k << endl; 30. cout << "::k: " << ::k << endl; 31. } 5

6 Zmienna k zadeklarowana w linii 4 jest zmienną globalną. Jest zatem widoczna i w funkcji main. W liniach 8 i 9 drukujemy wartości k - ponieważ k nie zostało przesłonięte inną zmienną, w tym miejscu programu zarówno k, jak i ::k odnoszą się do tej samej zmiennej - zmiennej globalnej. W linii 11 wprowadzamy lokalną dla funkcji main zmienną k. Przesłania ona globalne k; od tej pory użycie w funkcji main nazwy k oznacza odniesienie się do zmiennej lokalnej. Tym niemniej, zmienna globalna jest wciąż dostępna: trzeba tylko odnosić się do niej za pomocą pełnej nazwy kwalifikowanej operatorem zakresu - widzimy to w linii 14. Podobnie, wewnątrz funkcji można zmienić wartość zmiennej globalnej, jeśli prawidłowo się do niej odwołujemy (linia 16). W liniach wprowadzamy blok wewnętrzny zanurzony w bloku, jakim jest ciało funkcji main. Wprowadzona w tym bloku zmienna k całkowicie przesłania lokalną dla main zmienną k. Wewnątrz tego zagnieżdżonego bloku mamy dostęp wyłącznie do k z tego bloku i k globalnego. Możemy się o tym przekonać patrząc na wynik programu k: 0 ::k: 0 k: 10 ::k: 0 k: 10 ::k: 1 W bloku: k: 77 ::k: 1 Po bloku: k: 10 ::k: 1 Grupa operatorów o priorytecie 16 Są to operatory o różnym charakterze wymienione w tabeli operatorów na pozycjach : Pierwsze dwa '.', ' ->'(operator kropka i strzałka, dotyczą struktur i klas. 6: Operator ' []' wyboru elementu (indeksowania) tablicy znamy. Przypomnijmy, że w C/C++ wyrażenie tab[i] jest wygodniejszą formą zapisu wyrażenia *(tab+i). 7: Operator wywołania funkcji - pozycja 7 w tabeli operatorów - oznaczamy, jak zwykle, nawiasami okrągłymi ' ()': func(k, m, 5) Zatem podanie nazwy funkcji z nawiasami okrągłymi powoduje wywołanie funkcji (jeśli pojawia się w instrukcji wykonywalnej, a nie w definicji lub deklaracji). Ale nie zawsze nazwa funkcji występuje z nawiasami. Czasem chcemy odnieść się do funkcji jako takiej, jako obiektu, a nie powodować jej wywołanie. W takich sytuacjach używamy nazwy funkcji bez nawiasów - ma ona wtedy interpretację wskaźnika do funkcji. 6

7 8: Operator konstrukcji wartości,- na pozycji 8 w tabeli - dotyczy klas. Omówimy go na wykładzie o tworzeniu obiektów. Tu tylko wspomnijmy, że w C++ można konstruować obiekty typów prostych ( int, double,...) tak jakby były one obiektami jakiejś klasy. Zatem int(3) kreuje zmienną typu int i inicjuje ją wartością 3 - składnia jest wobec tego taka, jak gdybyśmy tworzyli obiekt klasy int i wysyłali wartość 3 do konstruktora (tak zwanego konstruktora kopiującego). 9-10: Przyrostkowe operatory zmniejszenia i zwiększenia (postdekrementacji i postinkrementacji) - na pozycji 9 i 10 w tabeli - zmniejszają (zwiększają) wartość swojego argumentu (który wyjątkowo stoi po ich lewej stronie) o jeden. Czynią to jednak po obliczeniu wartości wyrażenia, w skład którego wchodzą. Tak więc po int a = 1; int b = a++; wartość a wynosi 2, ale wartość b wynosi 1, bo w trakcie opracowywania drugiej instrukcji a miało wciąż wartość 1; zwiększenie a nastąpi dopiero po zakończeniu wykonywania instrukcji przypisania. Argumentem postinkrementacji i postdekrementacji musi zawsze być l-nazwa (l-nazwa to wyrażenie, które może wystąpić po lewej stronie przypisania); dlatego np. (x+y)++ //BLAD nie ma sensu i jest błędne, gdyż wyrażenie (x+y) nie jest l-wartością (choć jest p-wartością)(lwartość to wyrażenie identyfikujące daną, która ma określony, dostępny w programie adres w pamięci, zaś P-wartość to wyrażenie, które ma określoną wartość). Tak więc argument operatorów postdekrementacji i postinkrementacji musi być l-nazwą: ale co z rezultatem działania tego operatora na l-nazwę? W C/C++ dla przyrostkowych operatorów zmniejszenia i zwiększenia wynik nie jest l-wartością, ale dla operatorów przedrostkowych wynik jest l-wartością. Dlatego int k = 5; int m = (++k)--; jest prawidłowe. Wyrażenie w nawiasach jest l-nazwą, bo użyty został operator preinkrementacji; można było zatem zastosować następnie operator postdekrementacji. Wynikiem działania tego z kolei operatora nie jest już l-wartość, ale ponieważ użyliśmy jej tylko po prawej stronie przypisania, więc wszystko jest w porządku. Wartość k będzie oczywiście wynosić po tym przypisaniu 5, a wartością zmiennej m będzie 6. Gdybyśmy nie użyli nawiasów int k = 5; int m = ++k--; // ZLE!!! kod byłby błędny: ponieważ priorytet postdekrementacji jest wyższy niż preinkrementacji, więc najpierw obliczone byłoby wyrażenie k- -. Wynik nie byłby l-wartością więc podziałanie nań 7

8 operatorem ' ++' spowodowałoby błąd. Warto pamiętać, że wyrażenie ++w nie jest całkowicie równoważne instrukcji w=w+1. Ta druga forma jest normalną instrukcją przypisania, a zatem najpierw zostanie obliczona wartość wyrażenia po prawej stronie, a potem lokalizacja l-wartości po lewej stronie. Zatem jeśli w jest wyrażeniem złożonym (np. zawiera wywołania funkcji), to wyrażenie to będzie obliczane dwukrotnie. Natomiast podczas opracowywania wyrażenia ++w, samo w będzie obliczane jednokrotnie. Rzadko ma to jakieś znaczenie, ale czasem zrozumienie tego może nas ustrzec przed trudno wykrywalnymi błędami : Operator identyfikacji typu typeid - na pozycji 11 i 12 w tabeli operatorów - pozwala na uzyskanie identyfikatora typu podczas kompilacji, a więc statycznie, jak również identyfikatora typu obiektu (ogólnie p-wartości) w czasie wykonania programu, a więc dynamicznie (RTTI; runtime type identification). Przykład zastosowania tego operatora podany jest poniżej w programie sizes.cpp : Operatory konwersji (rzutowania) - na pozycjach w tabeli operatorów - pozwalają na, w miarę bezpieczną, konwersję wartości jednego typu na wartość innego typu. Ponieważ stosowanie konwersji często, choć nie zawsze, świadczy o złej konstrukcji programu i stwarza okazję do użycia błędnych lub zależnych od implementacji konstrukcji programistycznych, nadano tym operatorom celowo tak długą i niewygodną do pisania formę. Grupa operatorów o priorytecie 15 Do tej grupy również należą operatory o różnym charakterze. W tabeli wymienione są na pozycjach : Pierwsze dwa, z pozycji 17 i 18, dotyczą pobierania rozmiaru za pomocą operatora sizeof. Rezultat jest typu size_t (który jest tożsamy z pewnym typem całkowitym bez znaku, np. unsigned long). Operator ten jest jednoargumentowy. Argumentem może być nazwa typu (w nawiasie okrągłym) lub wyrażenie (nawias jest wtedy niekonieczny). Rozpatrzmy przykład: sizes.cpp Operator sizeof 1. #include <iostream> 2. #include <typeinfo> 3. using namespace std; typedef int TABINT15[15]; void siz(tabint15 t1, TABINT15& t2) { 8. cout << "G. t1 w siz: " << sizeof t1 << endl; 9. cout << "H. t2 w siz: " << sizeof t2 << endl; 10. } 11. 8

9 12. int main() { 13. TABINT15 tab1; 14. int tab2[15]; 15. int *tab3 = tab2; if (typeid(tab1) == typeid(tab2)) 18. cout << "A. Typy tab1 i tab2 takie same" << endl; 19. else 20. cout << "A. Typy tab1 i tab2 nie takie same" << endl; if (typeid(tab2) == typeid(tab3)) 23. cout << "B. Typy tab2 i tab3 takie same" << endl; 24. else 25. cout << "B. Typy tab2 i tab3 nie takie same" << endl; cout << "C. TABINT15: " << sizeof(tabint15) << endl; 28. cout << "D. tab1 : " << sizeof tab1 << endl; 29. cout << "E. tab2 : " << sizeof(tab2) << endl; 30. cout << "F. tab3 : " << sizeof tab3 << endl; 31. siz(tab2, tab2); 32. } Wynik tego programu A. Typy tab1 i tab2 takie same B. Typy tab2 i tab3 nie takie same C. TABINT15: 60 D. tab1 : 60 E. tab2 : 60 F. tab3 : 4 G. t1 w siz: 4 H. t2 w siz: 60 ilustruje warte zrozumienia własności C/C++. W linii 2 dołączamy plik nagłówkowy typeinfo, aby mieć dostęp do narzędzi związanych z identyfikacją typów. W linii 5 wprowadzamy, za pomocą instrukcji typedef, inną nazwę typu piętnastoelementowa tablica liczb całkowitych. Jak widać z linii 27 i pierwszej linii wydruku, operator sizeof prawidłowo rozpoznał rozmiar typu TABINT15. Zauważmy też, że w linii 27 nie można pominąć nawiasów, bo TABINT15 jest nazwą typu. W liniach 13 i 14 definiujemy tablice tab1 i tab2 na dwa sposoby - za pomocą wprowadzonej nazwy TABINT15 i bezpośrednio. W liniach porównujemy typy tych zmiennych. Linia 'A' wydruku pokazuje, że rzeczywiście są one takie same. W linii 15 definiujemy zmienną tab3 typu int* i przypisujemy do niej wartość zmiennej tab2. Przypisanie jest prawidłowe, ale nie zapominajmy, że zachodzi przy tym konwersja standardowa: typy tab2 i tab3 nie są takie same, co widzimy z linii 'B' wydruku. W liniach drukujemy rozmiary typu TABINT15 i zmiennych tab1, tab2 i tab3. Wszystkie 9

10 rozmiary, za wyjątkiem tab3, wynoszą 60, co odpowiada tablicy piętnastu czterobajtowych liczb. Natomiast rozmiar tab3 jest 4, gdyż jest to zmienna typu wskaźnikowego, a nie tablicowego. W linii 31 posyłamy tę samą tablicę tab2 poprzez dwa argumenty do funkcji siz. Pierwszy parametr funkcji jest typu TABINT15, więc wydawałoby się, że funkcja wie, że argument będzie tablicą. Drukując jednak (linia 'G' wydruku) wewnątrz funkcji rozmiar zmiennej t1, widzimy, że jest to wskaźnik o rozmiarze 4 - jest tak, gdyż przy wysyłaniu tab2 do funkcji przez wartość i tak zmienna została zrzutowana do typu wskaźnikowego (na stosie został położony adres pierwszego elementu tablicy i nic więcej). Drugi parametr funkcji siz jest zadeklarowany jako odniesienie. Teraz żadnej konwersji nie ma, bo nie jest w ogóle tworzona żadna zmienna lokalna, której należałoby przypisać wartość argumentu. Wewnątrz funkcji t2 jest teraz inną nazwą dokładnie tej samej zmiennej, która w funkcji main nazywa się tab2. Zatem i informacja o typie jest ta sama i ' sizeof t2' drukuje 60 (linia 'H' wydruku) : Przedrostkowe operatory zmniejszenia i zwiększenia (predekrementacji i preinkrementacji) występujące w tabeli na pozycjach 19 i 20, działają podobnie do przyrostkowych operatorów zmniejszenia i zwiększenia. Są jednak ważne różnice: operatory te zmniejszają (zwiększają) swój argument przed jego użyciem do obliczenia wartości wyrażenia, w skład którego wchodzą. Tak więc po int a = 1; int b = ++a; wartość a wynosi 2, ale wartość b wynosi również 2, bo w trakcie opracowywania drugiej instrukcji zmienna a zostła zwiększona jeszcze przed wykonaniem przypisania. Wynikiem działania operatora preinkrementacji lub predekrementacji jest l-nazwa (pamiętamy, że tak nie było dla operatorów postinkrementacji lub postdekrementacji) : Na pozycjach 21 i 22 występują operatory negacji: bitowej i logicznej. Omówimy je poniżej razem z innymi operatorami logicznymi i bitowymi : Jednoargumentowy operator ' +' jest właściwie operatorem identycznościowym, czyli takim, który nic nie robi (ang. no-op). Istnieje tylko dla wygody, aby wyrażenia typu ' k = +5' miały sens. Operatory wyłuskania adresu i dereferencji będą omówione na II roku : Operatory new i delete z pozycji służą do dynamicznego alokowania i zwalniania pamięci: będą omówione na II roku. Ostatni operator z tej grupy, oznaczany parą nawiasów okrągłych, to operator rzutowania. Jest on operatorem jednoargumentowym: wynikiem działania tego operatora na p-wartość pewnego typu jest odpowiadająca tej wartości p-wartość innego typu - tego wymienionego w nawiasie. Z 10

11 operatora tego należy korzystać oględnie; w większości przypadków jego zastosowanie świadczy raczej o złym stylu programowania. Czasem jest jednak przydatny. Na przykład w drugiej instrukcji fragmentu double x = 7; int k = (int)x; rzutowanie wartości zmiennej x jest wskazane, gdyż wartość ta, jako wartość szerszego typu, może być wpisana do zmiennej typu węższego, jakim jest typ int, tylko ze stratą informacji (precyzji). Choć nie jest to błąd, to kompilator zwykle wypisuje ostrzeżenia; jeśli zastosujemy jawne rzutowanie, ostrzeżeń nie będzie. Rzutowanie zawsze działa na p-wartość i w wyniku daje inną p-wartość, ale nigdy l-wartość. W szczególności rzutowanie nie zmienia typu żadnej zmiennej. Zamiast operatora rzutowania w C++ zaleca się stosowanie bezpieczniejszych operatorów konwersji, wymienionych w tabeli na pozycjach Grupa operatorów o priorytecie 14 Należą do tej grupy dwa operatory wyboru składowej, rzadko stosowane, które omówione będą wykładzie na temat klas w C++. Operatory arytmetyczne 36-40: Wymienione w tabeli na pozycjach operatory arytmetyczne mają oczywiste znaczenie i ich działanie jest niemal takie samo jak w większości innych języków. Występują czasem drobne różnice: np. w Javie operator reszty ' %' może mieć dowolne agumenty numeryczne, również typu double. W C/C++ operator ten wymaga argumentów typu całkowitego. Pewien kłopot mogą sprawiać wyrażenia z wartościami ujemnymi jako argumentami. Wiemy, że dzielenie liczb typu całkowitego daje w wyniku liczbę całkowitą, czyli ewentualna część ułamkowa jest obcinana. Jeśli wynik jest dodatni, to dokładna wartość ilorazu jest obcinana w dół, czyli w kierunku zera. A jeśli wynik jest ujemny? W C/C++ jest to niezdefiniowane i może zależeć od implementacji - w większości współczesnych implementacji jednak obcięcie jest zawsze w kierunku zera. Dla operatora reszty spełniona jest zawsze zasada a = (a/b)*b + a%b dla b różnego od zera. Wynika z niej, przy założeniu, że obcinanie w dzieleniu całkowitoliczbowym jest zawsze w kierunku zera, zasada następująca: wartość a%b jest równa co do modułu wartości a % b i ma znak taki, jaki znak ma a (kreski oznaczają wartość bezwzględną). Ilustruje to poniższy programik: 11

12 mod.cpp Operator reszty 1. #include <iostream> 2. using namespace std; int main() 5. { 6. int i, j; i = 19; j = 7; cout << " 19 / 7 = " << i/j << endl; 9. i =-19; j = 7; cout << "-19 / 7 = " << i/j << endl; 10. i = 19; j =-7; cout << " 19 / -7 = " << i/j << endl; 11. i =-19; j =-7; cout << "-19 / -7 = " << i/j << endl; i = 19; j = 7; cout << " 19 % 7 = " << i%j << endl; 14. i =-19; j = 7; cout << "-19 % 7 = " << i%j << endl; 15. i = 19; j =-7; cout << " 19 % -7 = " << i%j << endl; 16. i =-19; j =-7; cout << "-19 % -7 = " << i%j << endl; 17. } którego wynikiem jest 19 / 7 = 2-19 / 7 = / -7 = / -7 = 2 19 % 7 = 5-19 % 7 = % -7 = 5-19 % -7 = -5 Ta zasada będzie inna, jeśli obcinanie w dzieleniu całkowitoliczbowym jest zawsze w dół, a nie w kierunku zera. Dlatego lepiej unikać stosowania operatora reszty dla liczb ujemnych. Operatory relacyjne i porównania 43-48: Wymienione w tabeli operatory relacyjne (pozycje 43-46: ' <', ' <=', ' >', ' >=') i porównania (pozycje 47 i 48: ' ==', '!=') mają oczywistą interpretację. Wyrażenie ' a == b' ma wartość logiczną odpowiadającą na pytanie czy wartość a jest równa wartości b. Wyrażenie ' a!= b' ma wartość logiczną odpowiadającą na pytanie czy wartość a jest różna od wartości b. Argumentami mogą być dwa skalary, czyli p-wartości liczbowe, lub dwa adresy (wartości zmiennych wskaźnikowych lub wynik operacji wyłuskania adresu). Wynikiem operacji jest wartość logiczna true lub false. Wartości logiczne reprezentowane są w zasadzie przez wartości całkowite: wartość 0 jest równoważna false, a dowolna wartość niezerowa true. Obowiązuje to również dla wartości wskaźnikowych: wartość pusta ( NULL) jest interpretowana jako false, a każda inna jako true. 12

13 Operatory logiczne 22, 52-53: Operatory logiczne są wymienione w tabeli na pozycjach 22 (! negacja logiczna; ten operator jest oczywiście jednoargumentowy), 52 i 53 ( && koniunkcja i alternatywa logiczna). Argumenty mogą mieć wartość całkowitą; wówczas wartości zostaną zinterpretowane według normalnej zasady 0 lub NULL false, niezero, nie- NULL true. Obliczona wartość jest typu logicznego: alternatywa (suma logiczna) daje wynik true wtedy i tylko wtedy gdy choć jeden z argumentów ma wartość true, natomiast koniunkcja (iloczyn logiczny) ma wartość true tylko jeśli oba argumenty są true. Koniunkcja i alternatywa są skrótowe. Oznacza to, że prawy argument nie jest w ogóle obliczany, jeśli po obliczeniu lewego wynik jest już przesądzony. Tak więc dla koniunkcji (' &&') prawy argument nie będzie w ogóle obliczany, jeśli lewy argument okazał się równy false - całe wyrażenie musi bowiem wtedy mieć wartość false niezależnie od wartości prawego argumentu; dla alternatywy prawy argument nie będzie obliczany, jeśli lewy okazał się true - całe wyrażenie musi bowiem mieć wtedy wartość true niezależnie od wartości prawego argumentu. Na przykład, jeśli a, b i r są zmiennymi typu całkowitego, to przypisanie r = a && b; jest równoważne if (a == 0) r = 0; else { if (b == 0) r = 0; else r = 1; } a przypisanie r = a b; jest równoważne if (a!= 0) r = 1; else { if (b!= 0) r = 1; else r = 0; } Rozpatrzmy jeszcze jeden przykład ilustrujący skrótowość dwuargumentowych operatorów logicznych: 13

14 skrot.cpp Skrótowość operatorów koniunkcji i alternatywy 1. #include <iostream> 2. using namespace std; bool fun(int k) 5. { 6. k = k - 3; 7. cout << "Fun zwraca " << k << endl; 8. return k; 9. } int main() 12. { 13. if ( fun(1) && fun(2) && fun(3) && fun(4) ) 14. cout << "Koniunkcja true" << endl; 15. else 16. cout << "Koniunkcja false" << endl; if ( fun(1) fun(2) fun(3) fun(4) ) 19. cout << "Alternatywa true" << endl; 20. else 21. cout << "Alternatywa false" << endl; 22. } W linii 13 sprawdzany jest warunek w postaci koniunkcji wartości logicznych zwracanych przez funkcję fun (równie dobrze mogłyby to być wartości całkowite). Ponieważ fun(3) zwraca, 0 czyli logiczne false, funkcja w ogóle nie zostanie już wywołana z argumentem 4, bo wynik już jest znany: wartością całego wyrażenia w nawiasie musi być false niezależnie od tego, co zwróciłaby funkcja fun dla argumentu 4. Widzimy to z wydruku Fun zwraca -2 Fun zwraca -1 Fun zwraca 0 Koniunkcja false Fun zwraca -2 Alternatywa true Podobnie dla alternatywy w linii 18. Już pierwsze wywołanie funkcji fun dało wynik true (odpowiada to niezerowej wartości zwracanej, w tym przypadku -2). Alternatywa jest prawdziwa, gdy choć jeden argument jest true, wobec tego po wywołaniu fun(1) wynik całego wyrażenia jest znany ( true) i wywołań fun(2), fun(3) i fun(4) nie będzie. Operatory bitowe 21, 41-42, 49-51: Operatory bitowe wymienione są w tabeli na pozycjach 21 (~ negacja bitowa), 41 i 42 (przesunięcie bitowe) i ( & koniunkcja, ^ różnica symetryczna i alternatywa 14

15 bitowa). Argumentami muszą być wartości całkowite, wynik też jest typu całkowitego. Obowiązują przy tym normalne reguły konwersji argumentów do typu wspólnego. Operatory bitowe nie interesują się wartościa liczbową argumentów, ale ich reprezentacją bitową. Przypomnijmy, że zwyczajowo numeruje się bity reprezentujące wartości zmiennych, poczynając od zera, od bitu najmniej znaczącego (odpowiadającego współczynnikowi przy zerowej potędze dwójki) do bitu najbardziej znaczącego. Reprezentując graficznie układ bitów, bit zerowy umieszcza się po prawej stronie, a bit najbardziej znaczący po lewej. Rozpatrzmy zatem bardziej szczegółowo działanie poszczególnych operatorów bitowych na wartości liczbowe. Jeden z nich - negacja bitowa - jest jednoargumentowy, pozostałe są dwuargumentowe. Operator bitowej negacji (' '), działając na wartość całkowitą zwraca nową wartość, w której wszystkie bity ulegają odwróceniu: tam, gdzie w argumencie był bit ustawiony (czyli miał umowną wartość 1), w wartości wynikowej będzie on nieustawiony (co odpowiada umownej wartości 0) - jak na rysunku, gdzie dla uproszczenia zilustrowane jest działanie opertatora negacji bitowej dla wartości typu char, a więc jednobajtowej (ośmiobitowej). Oczywiście negacja jest inwolutywna, czyli dwukrotne jej zastosowanie prowadzi do wartości wyjściowej. Alternatywa bitowa (' ') jest operatorem dwuargumentowym: dla kolejnych pozycji sprawdzane są pojedyncze bity w obu argumentach i obliczana ich suma logiczna: w wyniku bit na odpowiadającej pozycji jest jedynką (bit ustawiony), jeśli w którymkolwiek argumencie bit na tej pozycji był ustawiony, a zero, gdy w obu argumentach na tej pozycji również występowało zero (jak na rysunku poniżej). Alternatywa bitowa (tzw. ORowanie) jest często stosowana do ustawiania najrozmaitszych opcji. Na przykład w C++, otwarte do czytania lub pisania pliki mają szereg trybów, którym odpowiadają pewne stałe całkowite, np. ios::in, ios::out, zdefiniowane w klasie ios (dlatego odwołujemy się do nich poprzez operator zakresu klasy - czterokropek). W programie bits.cpp drukujemy reprezentację bitową kilku tego rodzaju stałych. Widzimy, że są to pełne potęgi dwójki, a więc w 15

16 ich reprezentacji bitowej występuje tylko jedna jedynka na odpowiedniej pozycji - dla ios::out na pozycji pierwszej, dla ios::trunc na pozycji czwartej (licząc, jak zwykle, od zera) itd. Zatem stałą określającą tryb otwartego pliku jako pliku jednocześnie do pisania i do czytania będzie ios::in ios::out i będzie zawierać jedynki na pozycjach zerowej i pierwszej (konkretne pozycje mogą zależeć od implementacji - należy zawsze odwoływać się do tych stałych poprzez ich nazwy). Koniunkcja bitowa ('&') jest też operatorem dwuargumentowym: dla kolejnych pozycji sprawdzane są pojedyncze bity w obu argumentach i obliczany ich iloczyn logiczny: w wyniku bit na odpowiadającej pozycji jest jedynką (bit ustawiony), jeśli w obu argumentach bit na tej pozycji był ustawiony, a zero, gdy w którymkolwiek z argumentów na tej pozycji występowało zero (patrz rysunek). Koniunkcja bitowa (tzw. ANDowanie) jest często stosowana do tzw. maskowania. Wspomnieliśmy, że stała określająca tryb pliku ma na pozycji trzeciej (licząc od zera) jedynkę, jeśli ustawiony plik został otwarty w trybie in, a zero, jeśli nie. Jeśli stała określająca tryb nazywa się tryb, to maskowanie jej ze stałą 8 (= 2 3 ) odpowie na pytanie, czy bit in jest czy nie jest ustawiony. Reprezentacja 8 składa się z samych zer, z wyjątkiem pozycji trzeciej (czwarty bit od prawej), na której bit jest ustawiony. Zatem obliczając koniunkcję dostaniemy na wszystkich innych pozycjach na pewno zero, na pozycji czwartej zaś jedynkę, jeśli w tryb ten bit był ustawiony, a zero, jeśli nie był. Zatem wartość wyrażenia tryb & 8 będzie niezerowa wtedy i tylko wtedy, jeśli bit in był w zmiennej tryb ustawiony, niezależnie od stanu innych bitów w tej zmiennej. Operator bitowej różnicy symetrycznej ('^') jest też operatorem dwuargumentowym: dla kolejnych pozycji sprawdzane są pojedyncze bity w obu argumentach i obliczana jest ich różnica symetryczna: wynikowy bit na odpowiadającej pozycji jest jedynką (bit ustawiony), jeśli w obu argumentach bity na tej pozycji były różne, a zerem jeśli w obu argumentach na tej pozycji występowały bity takie same - dwa zera albo dwie jedynki. 16

17 Różnica symetryczna (obliczanie jej nazywane bywa XORowaniem) ma ciekawą i użyteczną własność, wynikającą z natępującej tabelki logicznej dla tego działania: b m b m (b m) m z której wynika, że dwukrotne XORowanie dowolnego bitu b z dowolną maską m przywraca pierwotną wartość tego bitu - w tabeli kolumna pierwsza i ostatnia są takie same. Ta własność XORowania jest wykorzystywana między innymi w grafice komputerowej. Przesunięcia bitowe (' «' i '»') są operatorami dwuargumentowymi: lewy argument jest tu pewną wartością całkowitą na bitach której operacja jest przeprowadzana, prawy argument, również całkowity, określa wielkość przesunięcia. Wyobraźmy sobie, że lewy argument w ma układ bitów jak w górnej części rysunku. Przesunięcie w tej zmiennej bitów w lewo o dwa, ' w = w «2', odpowiada przesunięciu wszystkich bitów o dwie pozycje w lewo (w kierunku pozycji bardziej znaczących). Bity wychodzące z lewej strony są tracone bezpowrotnie. Z prawej strony wchodzą bity zerowe. Tak więc po wykonaniu tej instrukcji reprezentacja zmiennej w będzie taka jak w środkowej części rysunku. Analogicznie, po przesunięciu teraz bitów w prawo o trzy pozycje (' w = w» 3') otrzymamy reprezentację zmiennej w jak w dolnej części rysunku (pod pewnymi warunkami - patrz niżej). O ile przesuwanie w lewo jest zawsze dobrze określone według wspomnianych zasad, rzecz jest bardziej skomplikowana przy przesuwaniu w prawo. Wychodzące z prawej strony bity są tracone, tak jak te z lewej strony przy przesuwaniu w lewo. Ale nie jest jasne, jakie bity wchodzą z lewej strony przy przesuwaniu w prawo. W większości implementacji przyjęto następującą konwencję: jeśli typem wartości lewego argumentu jest typ bez znaku ( unsigned), to przy przesuwaniu w prawo wchodzą z lewej strony bity zerowe; jeśli natomiast typem wartości lewego argumentu jest typ ze znakiem ( signed), to przy przesuwaniu w prawo reprodukowany jest z lewej strony bit znaku, czyli skrajny lewy bit - jeśli było to zero, to zero, jeśli była to jedynka, to jedynka. Prawy argument operatora przesunięcia, wskazujący na wielkość tego przesunieęcia, zawsze 17

18 powinien być nieujemny i mniejszy od rozmiaru w bitach wartości, na której dokonujemy przesunięcia. Co się dzieje, jeśli te warunki nie są spełnione w C/C++ może zależeć od implementacji i wobec tego lepiej takich konstrukcji unikać. bits.cpp Operacje na bitach f-cje wypisujące bitowe (2-kowe) reprezentacje argumentów 1. #include <iostream> 2. using namespace std; void bitschar(char k) 5. { 6. int bits = 8*sizeof(k); 7. unsigned char mask = 1<<(bits-1); 8. for (int i = 0; i < bits; i++) { 9. cout << (k & mask? 1 : 0); 10. mask >>= 1; 11. } 12. cout << endl; 13. } void bitsshort(short k) 16. { 17. int bits = 8*sizeof(k); 18. unsigned short mask = 1<<(bits-1); 19. for (int i = 0; i < bits; i++) { 20. cout << (k & mask? 1 : 0); 21. mask >>= 1; 22. } 23. cout << endl; 24. } void bitsint(int k) 27. { 28. int bits = 8*sizeof(k); 29. unsigned int mask = 1<<(bits-1); 30. for (int i = 0; i < bits; i++) { 31. cout << (k & mask? 1 : 0); 32. mask >>= 1; 33. } 34. cout << endl; 35. } int main() 38. { 39. short s = -1; int i = 259; cout << "char 'a' : "; bitschar('a'); 42. cout << "short -1 : "; bitsshort(s); 43. cout << "int 259 : "; bitsint(i); 44. cout << endl; 45. cout << "ios::in : "; bitsint(ios::in); 46. cout << "ios::out : "; bitsint(ios::out); 47. cout << "ios::app : "; bitsint(ios::app); 48. cout << "ios::in ios::out\n "; 49. bitsint(ios::in ios::out); 50. } 18

19 Na początku tego programu definiujemy trzy niemal identyczne funkcje, których zadaniem jest wypisanie bitowej reprezentacji argumentu. Funkcje różnią się tylko typem argumentu: może nim być char, short lub int. Przyjrzyjmy się jednej z tych funkcji, na przykład funkcji bitschar. W linii 6 sprawdzamy, jaki jest rozmiar w bitach wartości argumentu k (tu oczywiście wiemy, że będzie to 8, bo sizeof(k) dla k typu char da jedynkę (1 bajt)). Następnie tworzymy maskę mask typu unsigned char. Chodzi nam o to, aby długość maski była taka jak długość k, ale by była to zmienna na pewno bez znaku w ten sposób przy przesuwaniu w prawo będą z lewej strony wchodzić zera. Maskę inicjujemy w linii 7 wartością ' 1 «7' (bo bits wynosi 8). Reprezentacja jedynki to siedem bitów zerowych i jeden, prawy (czyli najmłodszy), bit ustawiony. Przesuwając ten układ bitów w lewo otrzymamy liczbę, której reprezentacją jest jedynka i siedem zer (jedynka tym razem z lewej strony). Robimy to po to, by pętla drukująca, która teraz następuje, przebiegała przez kolejne bity liczby k od lewej do prawej, a nie odwrotnie. Następnie w pętli (linie 8-11) obliczamy koniunkcję bitową k z maską mask. Ponieważ maska ma tylko jeden bit ustawiony, w ten sposób sprawdzamy, czy odpowiedni bit jest też ustawiony w k. Jeśli tak, to wynikiem koniunkcji będzie jakaś wartość niezerowa, interpretowana jako true w pierwszym argumencie operatora selekcji, a zatem wartością tejże selekcji ' (k & mask? 1 : 0)' będzie jedynka, która zostanie wypisana na ekranie. Jeśli w k odpowiedni bit nie jest ustawiony, wydrukowane zostanie zero. W linii 11 przesuwamy bity w masce o jeden w prawo. Ponieważ zadbaliśmy, aby maska była typu bez znaku, z lewej strony będą wchodzić same zera. Zatem w kolejnych przebiegach pętli maska cały czas będzie zawierać dokładnie jedną jedynkę, wędrującą od lewej do prawej. A więc w kolejnych przebiegach pętli sprawdzone i wydrukowane będą, w kolejności od lewej do prawej, wszystkie bity zmiennej k. Podobnie działają pozostałe dwie funkcje: bitshort i bitint - jedyna różnica to typ argumentu. W programie głównym drukujemy reprezentację bitową kilku liczb całkowitych. Wyniki wyglądają następująco: char 'a' : short -1 : int 259 : ios::in : ios::out : ios::app : ios::in ios::out Widać, że reprezentacją liczby -1 są jedynki na wszystkich bitach. Znak 'a' odpowiada, jak łatwo policzyć, wartości całkowitej = = 97, co rzeczywiście jest kodem ASCII litery 'a'. Dalej ilustrujemy to, co mówiliśmy o stałych ios::in, ios::out itd. Widzimy, że są to pełne potęgi dwójki, a więc w ich reprezentacji bitowej występuje tylko jedna jedynka na odpowiedniej pozycji: 19

20 w stałej ios::trunc na pozycji czwartej (licząc od zera), a w stałej ios::out na pozycji pierwszej. Obliczając ich alternatywę (sumę) bitową otrzymujemy liczbę, wktórej reprezentacji bitowej te i tylko te dwa bity są ustawione (ostatnia linia wydruku). Operatory przypisania 55-65: Na pozycjach tabeli wymienione są operatory zwykłego przypisania (' =') oraz złożone operatory przypisania. 55: Lewa strona przypisania musi być l-nazwą. Tak więc double x; x + 2 = 7; // NIE POPRAWNE jest niepoprawne, natomiast double x, *y = &x; *(y + 2) = 7; byłoby legalne (choć prawdopodobnie bez sensu), bo wyłuskanie wartości daje w wyniku l-wartość. Wykonanie przypisania polega na obliczeniu wartości prawej strony i umieszczeniu wyniku pod adresem l-wartości występującej po stronie lewej. Zauważmy asymetrię: prawa strona mówi co policzyć, lewa gdzie zapisać wynik. Wartością i typem całego wyrażenia przypisania jest wartość i typ lewej strony po wykonaniu przypisania. Całe przypisanie jest l-nazwą. Na przykład drukuje '6 2'. int m = 1, n = 2; (m=n) = 6; cout << m << " " << n << endl; W programie poniżej przypis.cpp: Wykorzystanie wartości przypisania 1. #include <iostream> 2. using namespace std; int main() 5. { 6. int k; 7. while ( (k = cin.get())!= '\n' ) 8. cout << "Wprowadzono znak '" << (char)k 9. <<, o kodzie ASCII " << k << endl; 10. } 20

21 w linii 7 przypisujemy do k wartośc znaku - czyli jego kod ASCII - odczytaną z klawiatury za pomocą metody get wywołanej na rzecz obiektu cin. Całe przypisanie ' (k = cin.get())' ma wartość k po przypisaniu; tę wartość porównujemy z predefiniowaną stałą EOF, oznaczającą koniec strumienia danych. Zauważmy, że nawias wokół tego wyrażenia był konieczny, bowiem priorytet porównania,!=, jest wyższy niż priorytet operatora przypisania, a nam chodzi o to, aby najpierw dokonać przypisania, a dopiero jego wynik porównać z EOF. Przykładowe uruchomienie tego programu daje Ala ma...[enter] Wprowadzono znak 'A', o kodzie ASCII 65 Wprowadzono znak 'l', o kodzie ASCII 108 Wprowadzono znak 'a', o kodzie ASCII 97 Wprowadzono znak ' ', o kodzie ASCII 32 Wprowadzono znak 'm', o kodzie ASCII 109 Wprowadzono znak 'a', o kodzie ASCII 97 Wprowadzono znak '.', o kodzie ASCII 46 Wprowadzono znak '.', o kodzie ASCII 46 Wprowadzono znak '.', o kodzie ASCII 46 cpp> Dzięki temu, że wartością całego wyrażenia z przypisaniem jest wartość lewej strony po jego wykonaniu, przypisania można stosować kaskadowo. Tak więc int k = 7, j, m; int n = m = j = k; jest prawidłowe: ponieważ wiązanie operatora przypisania jest od prawej, wartością wyrażenia ' m = j = k', równoważnego ' m = (j = k)', jest wartość m po przypisaniu (czyli w naszym przypadku 7). Ta wartość zostanie użyta do zainicjowania definiowanej zmiennej n. Efektem ubocznym będzie nadanie wartości również zmiennym m i j. Zauważmy, że instrukcja byłaby błędna, gdyby któraś ze zmiennych m, j, k nie była utworzona wcześniej : Złożone operatory przypisania (pozycje tabeli) pozwalają na prostszy zapis niektórych przypisań: tych, w których ta sama l-nazwa występuje po lewej i prawej stronie przypisania. Zamiast instrukcji a = b; gdzie symbol '@ ' oznacza któryś z operatorów + - * / % & można użyć instrukcji b; Drobna różnica, najczęściej bez znaczenia, pomiędzy tymi instrukcjami polega na tym, że w drugiej z nich wartość a jest obliczana jednokrotnie, a w pierwszej dwukrotnie. Zwykle druga z tych form, ' 21

22 b', jest efektywniejsza. Jako przykład zastosowania rozpatrzmy program: zloz.cpp Przypisania złożone 1. #include <iostream> 2. using namespace std; void bitsint(int k) 5. { 6. unsigned int mask = 1<<31; 7. for (int i = 0; i < 32; i++, mask >>= 1) { 8. cout << (k & mask? 1 : 0); 9. if (i%8 == 7) cout << " "; 10. } 11. cout << endl; 12. } int main() 15. { 16. unsigned int k = 255<<24 153<<16 255<<8 255; 17. cout << "k przed: "; bitsint(k); 18. (k <<= 8) >>= 24; 19. cout << "k po: "; bitsint(k); 20. } Funkcja bitsint jest tu podobna do tej z programu bits.cpp - tak samo służy do drukowania bitowej reprezentacji liczby całkowitej. W tej wersji z góry założyliśmy, że typ int jest czterobajtowy. Prócz tego przesuwanie maski przenieśliśmy do części inkrementującej nagłówka pętli, umieszczając tam dwie instrukcje wyrażeniowe oddzielone przecinkiem (o operatorze przecinkowym - w jednym z następnych podrozdziałów ). Dodaliśmy też drukowanie spacji po każdej grupie ośmiu bajtów, aby uczynić wydruk bardziej przejrzystym. W linii 16 konstruujemy liczbę o z góry zadanej reprezenatcji bitowej. Wyrażenie ' 255 «24' daje liczbę z samymi jedynkami w najstarszym bajcie (255 to osiem jedynek, następnie przesunięte o 24 pozycje w lewo). Wyrażenie ' 153 «16' to układ bajtów przesunięty w lewo o 16 pozycji, czyli do bajtu trzeciego od lewej. Z kolei ' 255 «8' daje osiem jedynek w bajcie drugim, a samo osiem jedynek w bajcie najmłodszym. Suma (alternatywa) bitowa składa wszystkie te bajty: otrzymujemy zatem liczbę o reprezentacji przedstawionej w pierwszej linii wydruku: k przed: k po: Operator przypisania złożonego zastosowaliśmy w linii 18. Wyrażenie ' (k «= 8)' powoduje przesunięcie w zmiennej k wszystkich bitów w lewo o osiem pozycji. Zatem zawartość bajtu najstarszego zostaje zgubiona, bajt przechodzi na jego pozycję, a kolejne dwa, czyli 22

23 pierwszy i drugi, stają się drugim i trzecim (od lewej). Bajt najmłodszy wypełniany jest zerami. Wynik całego wyrażenia jest l-nazwą, a zatem ma sens zastosowanie do niego następnego przypisania złożonego: tym razem przesuwamy zawartość zmiennej k o 24 pozycje w prawo. Ponieważ zmienna k jest bez znaku, z lewej strony wchodzą same zera, a 24 najmłodsze bity wychodzą z prawej strony. Układ bitów po tej operacji znajduje się na pozycji najmłodszego bajtu. W efekcie widzimy, że operacja ' (k «= 8)»= 24' daje w efekcie liczbę równą tej, której reprezentacja binarna zawarta była w trzecim od lewej bajcie wyjściowej liczby. W podobny sposób można by wyciąć zawartość pozostałych bajtów. Takie wycinanie pojedynczych bajtów stosuje się na przykład przy kodowaniu trzech (albo czterech) składowych koloru w jednej liczbie. Operator selekcji 54: Operator selekcji jest jedynym operatorem trzyargumentowym. Jego składnia: b? w1 : w2 Najpierw obliczana jest wartość wyrażenia b i ewentualnie konwertowana do typu bool. Jeśli jest to true, obliczane jest wyrażenie w1, a wyrażenie w2 jest ignorowane. Wartością całego wyrażenia jest wartość w1. Jeśli jest to false, obliczane jest wyrażenie w2, a wyrażenie w1 jest ignorowane. Wartością całego wyrażenia jest wtedy wartość w2. Jeśli w1 i w2 są l-nazwami, to i wartość operatora selekcji jest l-nazwą. Klasyczny przykład zastosowania operatora selekcji to implementacja funkcji max zwracającej większą z wartości swych argumentów: int maxim(int a, int b) { return a > b? a : b; } Inny przykład zastosowania operatora selekcji podany zostanie w następnym podrozdziale. Operator zgłoszenia wyjątku 66: Na pozycji 66 w tabeli operatorów występuje operator zgłoszenia wyjątku throw: omówiony zostanie później. Operator przecinkowy 67: Operator przecinkowy jest dwuargumentowy: po dwóch stronach przecinka dwa wyrażenia wyr1, wyr2 Działanie jego polega na: obliczeniu wyrażenia wyr1 i zignorowaniu resultatu; obliczeniu wyrażenia wyr2; jego wartość staje się wartością całego wyrażenia. 23

24 Często operator przecinkowy stosuje się w części inicjalizacyjnej lub inkrementującej nagłówka pętli for; przykład to linia 7 programu zloz.cpp. Inny, nieco dziwaczny, przykład ilustruje program: przec.cpp Operator przecinkowy 1. #include <iostream> 2. using namespace std; int main() 5. { 6. int r = 0; 7. int k; while (cin >> k, k) { 10. r += k > 0? (cout << "Dodatnia\n", +1) 11. : (cout << "Ujemna\n", -1); 12. } 13. cout << "Roznica ilosci dodatnich i ujemnych : " 14. << r << endl; 15. } Operator przecinkowy jest tu użyty w linii 9 w warunku pętli while. Mamy tu pierwsze wyrażenie, ' cin» k', wczytujące kolejną daną z klawiatury, i drugie, po prostu k, dzięki któremu pętla skończy się, gdy wczytana zostanie liczba 0 (gdyż wartością całego wyrażenia przecinkowego jest wartość prawego argumentu). W pętli do r dodawana jest (operator złożonego przypisania) wartość nieco skomplikowanego wyrażenia. Jest to operator selekcji sprawdzający znak k; w każdym przypadku rezultat będzie wartością wyrażenia przecinkowego. Dla k dodatnich będzie to wartość ' cout «"Dodatnia\n", +1', czyli +1 z efektem ubocznym polegającym na wypisaniu słowa "Dodatnia". Analogicznie, dla k ujemnych od r odjęte zostanie 1, a jako efekt uboczny wypisane będzie słowo "Ujemna". Po wyjściu z pętli wypisywana jest różnica między ilością wczytanych liczb dodatnich i ujemnych. Na przykład wynik programu może być następujący: 2 Dodatnia 6 Dodatnia -3 Ujemna 6 Dodatnia -1 Ujemna 3 Dodatnia 0 Roznica ilosci dodatnich i ujemnych : 2 24