Det finns två operatorgrupper som vi hittills inte har tagit upp, och den första av

Andra operatorer Bilaga E Andra operatorer Det finns två operatorgrupper som vi hittills inte har tagit upp, och den första av dessa består av de bitvisa operatorerna, vilka gör det möjligt att manipulera enskilda bitar i ett värde. Dessa operatorer är ett arv från C. Den andra gruppen består av två indirekta operatorer för medlemmar, och dessa är tillägg i C++. Den här bilagan ger en kort sammanfattning av de här operatorerna. Bitvisa operatorer De bitvisa operatorerna opererar på bitarna i binära heltalsvärden. Operatorn vänsterskift t.ex. flyttar bitarna åt vänster, och den bitvisa negationsoperatorn byter ettor mot nollor och nollor mot ettor. Allt som allt har C++ sex sådana operatorer: <<, >>, ~, &, och ^. Skiftoperatorerna Operatorn vänsterskift har följande syntax: värde << skift Här är värde det heltalsvärde som ska skiftas, och skift är antalet bitpositioner: 13 << 3 betyder att alla bitar i värdet 13 ska skiftas tre positioner åt vänster. De övergivna positionerna fylls på med nollor och de bitar som skiftas förbi slutet kastas, se figur E.1. Figur E.1 Operatorn vänsterskift. Eftersom varje bitposition representerar ett värde som är dubbelt så stort som värdet närmast till höger (se bilaga A), innebär skiftning med en position åt vänster detsamma som att multiplicera värdet med 2. På samma sätt innebär skiftning med två positioner åt vänster multiplicering med 2 2, och skiftning n positioner innebär multiplicering med 2 n. Alltså är värdet för 13 << 3 detsamma som 13 x 2 3 eller 104. 1047

Bilaga E Operatorn vänsterskift ger C++ en egenskap som man ofta finner i assemblerspråk. En skiftoperator i assembler ändrar dock innehållet i ett register, medan operatorn i C++ ger ett nytt värde utan att förändra det ursprungliga. Betrakta t.ex. följande: int x = 20; int y = x << 3; Den här koden ändrar inte värdet i x. Uttrycket x << 3 använder värdet i x för att producera ett nytt värde, ungefär som x + 3 ger ett nytt värde utan att ändra x. Om man vill använda operatorn vänsterskift för att ändra variabelvärdet måste man dessutom använda tilldelning: Antingen vanlig tilldelning eller operatorn <<=, som kombinerar vänsterskift med tilldelning. x = x << 4; y <<= 2; // vanlig tilldelning // skiftning och tilldelning Operatorn högerskift (>>) skiftar som man skulle kunna förvänta sig bitarna åt höger och har följande syntax: värde >> skift Här är värde det heltalsvärde som ska skiftas, och skift är antalet bitar som ska skiftas. Exempelvis betyder 17 >> 2 att alla bitar i värdet 17 ska skiftas två positioner åt höger. För heltal som är unsigned fylls de övergivna positionerna på med nollor och de bitar som skiftas förbi slutet kastas. För heltal som är signed kan övergivna positioner fyllas på med nollor, i annat fall med värdet på den bit som ursprungligen låg längst till vänster. Valet är implementeringsberoende, se figur E.2. Figur E.2 Operatorn högerskift. Att skifta en position åt höger är detsamma som en heltalsdivision med 2. Generellt är skiftning n positioner åt höger detsamma som en heltalsdivision med 2 n. C++ definierar också en operator för högerskift-och-tilldelning (>>=) om man vill ersätta värdet i en variabel med det skiftade värdet: int q = 43; q >>= 2; // ersätt 43 med 43 >> 2, eller 10 I vissa system ger operatorerna vänster- och högerskift snabbare heltalsmultiplikationer och divisioner med 2 än vad som är fallet med multiplikations- och divisionsoperatorer- 1048

Andra operatorer na, men i takt med att kompilatorerna blir bättre på att optimera kod minskar sådana skillnader. De logiska bitvisa operatorerna De logiska bitvisa operatorerna motsvarar de vanliga logiska operatorerna, bortsett från att de arbetar med värdet bit för bit istället för som en helhet. Jämför t.ex. den vanliga negationsoperatorn (!) och den bitvisa negationsoperatorn (~). Operatorn! omvandlar ett sant värde (icke-noll) till falskt (0) och ett falskt värde (0) till sant (1). Operatorn ~ omvandlar varje enskild bit till sin motsats (1 till 0 och 0 till 1). Ta t.ex. en unsigned char med värdet 3: unsigned char x = 3; Uttrycket!x har värdet 0. För att se värdet på ~x skriver vi det i binär form: 00000011. Varje nolla omvandlas sedan till ett och varje etta till noll, vilket det ger det binära värdet 11111100, eller 252 i det decimala talsystemet, se figur E.3. Det nya värdet kallas ursprungsvärdets komplement. Figur E.3 Operatorn bitvis negation. Operatorn bitvis ELLER (, eng. OR) kombinerar två heltalsvärden till ett nytt heltalsvärde. Varje bit i det nya värdet sätts till 1 om den ena eller båda av de motsvarande bitarna i de ursprungliga värdena är 1. Om båda motsvarande bitar är 0 sätts biten till 0, se figur E.4. Figur E.4 Operatorn bitvis ELLER. Tabell E.1 sammanfattar hur operatorn kombinerar bitar. 1049

Bilaga E Tabell E.1 Värden på b1 b2 Bitvärden b1 = 0 b1 = 1 b2 = 0 0 1 b2 = 1 1 1 Operatorn = kombinerar operatorn bitvis ELLER med tilldelning: a = b; // sätt a till a b Operatorn bitvis exklusivt ELLER (^, eng. XOR) kombinerar två heltalsvärden till ett nytt heltalsvärde. Varje bit i det nya värdet sätts till 1 om den ena, men inte båda av motsvarande bitar i de ursprungliga värdena är 1. Om båda motsvarande bitar är 0 sätts biten till 0, se figur E.5. Figur E.5 Operatorn bitvis exklusivt ELLER. Tabell E.2 sammanfattar hur operatorn ^ kombinerar bitar. Tabell E.2 Värden på b1 ^ b2 Bitvärden b1 = 0 b1 = 1 b2 = 0 0 1 b2 = 1 1 0 Operatorn ^= kombinerar operatorn bitvis exklusivt ELLER med tilldelning: a ^= b; // sätt a till a ^ b Operatorn bitvis OCH (&, eng. AND) kombinerar två heltalsvärden till ett nytt heltalsvärde. Varje bit i det nya värdet sätts till 1 endast om båda motsvarande bitar i det ursprungliga värdet är 1. Om någon eller båda av de motsvarande bitarna är 0 sätts biten till 0, se figur E.6. 1050

Andra operatorer Figur E.6 Operatorn bitvis OCH. Tabell E.3 sammanfattar hur operatorn & kombinerar bitar. Tabell E.3 Värden på b1 & b2 Bitvärden b1 = 0 b1 = 1 b2 = 0 0 0 b2 = 1 0 1 Operatorn &= kombinerar operatorn bitvis OCH med tilldelning: a &= b; // sätt a till a & b Alternativa representationer av bitvisa operatorer C++ tillhandahåller alternativa representationer för flera bitvisa operatorer, se tabell E.4. Detta med tanke på platser där de traditionella bitvisa operatorerna inte ingår i teckenuppsättningen. Tabell E.4 Standard & &= Alternativa representationer för bitvisa operatorer Alternativ representation bitand and_eq bitor = or_eq - compl ^ xor ^= xor_eq 1051

Bilaga E Dessa alternativ medger att man skriver exempelvis följande satser: b = compl a bitand b; // detsamma som b = ~a & b; c = a xor b; // detsamma som c = a ^ c; Några vanliga operatortekniker på bitnivå Styrning av maskinvara innebär ofta att vissa enskilda bitar ska avläsas eller ställas som 1 eller 0. De bitvisa operatorerna erbjuder sätt att utföra sådana aktiviteter, och vi ska snabbt gå igenom de vanligaste metoderna. I det följande representerar flerabitar ett generellt värde medan bit representerar värdet på en viss bit. Bitar numreras från höger till vänster med början från 0, vilket betyder att värdet för biten i position n är 2 n. Ett heltal med endast bit nummer 3 satt till 1 har alltså värdet 2 3, eller 8. Generellt uttryckt svarar varje enskild bit mot sin potens av två, enligt beskrivningen av binära tal i bilaga A. Vi använder därför termen bit för att representera en potens av två, vilket motsvarar denna bit satt till 1 och alla andra bitar satta till 0. Ettställa (slå på) en bit Följande två operationer ettställer, slår på, den bit i flerabitar som svarar mot den bit som representeras av bit: flerabitar = flerabitar bit; flerabitar = bit; Båda sätter bit till 1 oavsett dess tidigare värde. Detta beror på att 1 ELLER ger resultatet 1 med både 1 och 0. Alla andra bitar i flerabitar lämnas orörda. Detta beror på att 0 ELLER 1 ger 1 och 0 ELLER 0 ger 0. Ställa om (vippa) en bit Följande båda operationer ställer om, vippar, den bit i flerabitar som representeras av bit. Med andra ord ettställs biten om den var 0 och nollställs om den var 1: flerabitar = flerabitar ^ bit; flerabitar ^= bit; 1 XOR 0 ger 1, vilket ettställer en nollställd bit, och 1 XOR 1 ger 0, vilket nollställer en ettställd bit. Alla andra bitar i flerabitar lämnas orörda. Detta beror på att 0 XOR 0 ger 0, och 0 XOR 1 ger 1. Nollställa (slå av) en bit Följande båda operationer nollställer den bit i flerabitar som representeras av bit: flerabitar = flerabitar & ~bit; flerabitar &= ~bit; Satserna nollställer biten oavsett dess tidigare värde. Först ger operationen ~bit ett heltal med alla bitar satta till 1, utom den bit som ursprungligen var satt till 1, som nollställs. 0 OCH 1 liksom 0 OCH 0 blir båda 0, varför biten ifråga nollställs. Alla andra bitar i 1052

Andra operatorer flerabitar lämnas orörda. Detta beror på att 1 OCH 1 i likhet med 1 OCH 0 ger det värde som biten hade från början. Här är ett kortare sätt att göra samma sak: flerabitar &= ~bit; Testa en bits värde Anta att vi vill avgöra huruvida den bit som motsvarar bit är ettställd i flerabitar. Följande test fungerar inte nödvändigtvis: if (flerabitar == bit) // inte bra Detta beror på att även om motsvarande bit i flerabitar är satt till 1 kan också andra bitar vara satta till 1. Likheten ovan är sann bara när endast den motsvarande biten är 1. Knepet är att först utföra operationen flerabitar OCH bit. Detta ger värdet 0 i alla andra bitpositioner, eftersom 0 OCH 1 liksom 0 OCH 0 är 0. Bara den bit som svarar mot bitvärdet lämnas orörd eftersom både 1 OCH 1 och 1 OCH 0 ger detta värde. Rätt sätt att testa blir då: if ((flerabitar & bit) == bit) // testar en enstaka bit I verkliga livet brukar programmerare ofta förenkla det här testet till följande: if (flerabitar & bit) // testar en enstaka bit Eftersom bit består av en bit som är satt till 1 och resten satta till 0 är värdet för flerabitar & bit antingen 0 (vilket ger testresultatet false) eller bit, vilket utvärderas som true eftersom det är icke-noll. Indirekta operatorer för medlemmar C++ tillåter definition av pekare till medlemmarna i en klass, men den processen är inte enkel. För att se vad den innefattar ska vi titta på en exempelklass med vissa inbyggda problem: class Example private: int feet; int inches; public: Example(); Example(int ft); ~Example(); void show_in() const; void show_ft() const; void use_ptr() const; ; Betrakta nu medlemmen inches. Utan ett specifikt objekt är inches endast en etikett, det vill säga klassen definierar inches som en medlemsidentifierare. Men det behövs ett objekt innan du faktiskt har allokerat minne: 1053

Bilaga E Example ob; // nu existerar ob.inches Man specificerar alltså ett minnesområde genom att använda identifieraren inches tillsammans med ett specifikt objekt. (I en medlemsfunktion kan man utelämna objektets namn, men då blir objektet underförstått det som pekaren pekar på.) C++ låter dig definiera en medlemspekare till identifieraren inches enligt följande: int Example::*pt = &Example::inches; Det här pekaren skiljer sig en aning från en vanlig (eng. regular) pekare. En vanlig pekare pekar på ett specifikt minnesområde. Men pekaren pt pekar inte på ett specifikt minnesområde eftersom deklarationen inte identifierar ett specifikt objekt. Istället identifierar pekaren pt platsen på inches-medlemmen inom vilket Example-objekt som helst. Precis som identifieraren inches är pt utformat för att användas i samverkan med en objektidentifierare. Uttrycket *pt får samma roll som identifieraren inches. Du kan alltså använda en objektidentifierare för att specificera vilket objekt som ska kommas åt och pekaren pt för att specificera inches-medlemmen av det objektet. En klassmetod kan exempelvis använda den här koden: int Example::*pt = &Example::inches; Example ob1; Example ob2; Example *pq = new Example; cout << ob1.*pt << endl; // visa inches-medlemmen av ob1 cout << ob2.*pt << endl; // visa inches-medlemmen av ob2 cout << po->pt << endl; // visa inches-medlemmen av *po Här är.* och -> indirekta operatorer för medlemmar. När man har ett visst objekt, t.ex. ob1, identifierar ob1.*pt inches-medlemmen av ob1. På samma sätt identifierar pq->pt inches-medlemmen av det objekt som pq pekar på. Att ändra objekt i exemplet ovan ändrar vilken inches-medlem som används. Men du kan även ändra själva pekaren pt. Eftersom feet är av samma typ som inches kan du ändra pt så att den pekar på feet-medlemmen istället för inches-medlemmen. ob1.*pt kommer då istället att åsyfta feet-medlemmen av ob1: pt = &Example::feet; cout << ob1.*pt << endl; // ändra pt // visa feet-medlemmen av ob1 Kombinationen *pt får samma roll som ett medlemsnamn och kan användas för att identifiera olika medlemsnamn (av samma typ). Man kan även använda medlemspekare för att identifiera medlemsfunktioner. Syntaxen blir då något mer invecklad. Du kanske kommer ihåg att deklarationen av en pekare till en vanlig funktion av typen void med inga argument såg ut så här: void (*pf) (); // pf pekar på en funktion Deklarationen av en pekare till en medlemsfunktion måste indikera att funktionen tillhör en viss klass. Så här deklarerar du en pekare till en metod i klassen Example: void (Example::*pf) () const; // pf pekar på en medlemsfunktion i Example 1054

Andra operatorer Detta talar om att pf kan användas i samma sammanhang som en Example-metod. Observera att termen Example::*pf måste skrivas inom parentes. Du kan tilldela adressen för en viss medlemsfunktion till den här pekaren: pf = &Example::show_inches; Observera att till skillnad från vid tilldelning till en vanlig funktionspekare kan och måste adressoperatorn användas här. När denna tilldelning gjorts kan ett objekt användas för att aktivera medlemsfunktionen: Example ob3(20); (ob3.*pf) (); // aktivera show_inches() genom att använda objektet ob3 Hela konstruktionen ob3.*pf måste omges av parentestecken för att klart och tydligt identifiera att uttrycket representerar ett funktionsnamn. Eftersom show_feet() har samma prototyp som show_inches() kan pf också användas för att komma åt metoden show_feet(): pf = &Example::show_feet; (ob3.*pf) (); // använd show_feet () på objektet ob3 Klassdefinitionen i listning E.1 har en use_ptr()-metod som använder medlemspekare för att komma åt både datamedlemmar och funktionsmedlemmar i klassen Example. Listning E.1 memb_pt.cpp // memb-pt.cpp -- indirekta pekare till klassmedlemmar #include <iostream> using namespace std; class Example private: int feet; int inches; public: Example(); Example(int ft); ~Example(); void show_in(); void show_ft() const; void use_ptr() const; ; Example::Example() feet = 0; inches = 0; Example::Example(int ft) feet = ft; inches = 12 * feet; 1055

Bilaga E Example::~Example() void Example::show_in() const cout << inches << tum\n ; void Example::show_ft() const cout << feet << fot\n ; void Example::use_ptr() const Example yard(3); int Example::*pt; pt = &Example::inches; cout << Sätt pt till &Example::inches:\n ; cout << this->pt: << this->*pt << endl; cout << yard.*pt: << yard.*pt << endl; pt = &Example::feet; cout << Sätt pt till &Example::feet:\n ; cout << this->pt: << this->*pt << endl; cout << yard.*pt: << yard.*pt << endl; void (Example::*pf) () const; pf = &Example::show_in; cout << Sätt pf till &Example::show_in:\n ; cout << Använder (this->*pf) (): ; (this->*pf) (); cout << Använder (yard.*pf) (): ; (yard.*pf) (); int main() Example car(15); Example van(20); Example garage; cout << car.use_ptr() utmatning:\n ; car.use_ptr(); cout << \nvan.use_ptr() utmatning:\n ; van.use_ptr(); return 0; Här är ett prov på utmatningen från programmet i listning E.1: car.use_ptr() utmatning: Sätt pt till &Example::inches: this->pt: 180 yard.*pt:: 36 Sätt pt till &Example::feet: 1056

Andra operatorer this->pt: 15 yard.*pt:: 3 Sätt pf till &Example::show_in: Använder (this->*pf) (): 180 tum Använder (yard.*pf) (): 36 tum van.use_ptr() utmatning: Sätt pt till &Example::inches: this->pt: 240 yard.*pt:: 36 Sätt pt till &Example::feet: this->pt: 20 yard.*pt:: 3 Sätt pf till &Example::show_in: Använder (this->*pf) (): 240 tum Använder (yard.*pf) (): 36 tum Det här exemplet tilldelar pekarvärden under kompileringen. För en mer sofistikerad klass kan man använda medlemspekare till datamedlemmar och metoder för vilka den medlem som exakt associeras med pekaren bestäms under programmets körning. 1057

1058 Bilaga E