Strömmar. Iteratorer. Funktionsobjekt. TDIU04 Programmering i C++, standardbibliotek. Containrar Iteratorer Algoritmer Funktionsobjekt

Transkript

1 TDIU04 Föreläsning 1 1 TDIU04 Programmering i C++, standardbibliotek TDIU04 Föreläsning 1 2 Containrar Iteratorer Algoritmer Funktionsobjekt Kursens mål är att du ska få en god översikt av C++ standardbibliotek, framför allt avseende containrar iteratorer algoritmer Strömmar funktionsobjekt och lambdauttryck stödkomponenter (t.ex. std::pair) lära dig hur man använder standardbibliotekets komponenter för att lösa uppgifter lära dig grundläggande egenskaper för klasstyper (struct och class) Containrar Iteratorer Algoritmer Principiella krav som gäller för laborationer och tentamen laborationer ska lösas med hjälp av standardbibliotekskomponenter, om möjligt standardbibliotekskomponenter ska används för att lösa tentamensuppgifter, om möjligt undvik speciellt handskrivna repetitioner for, while, do använd algoritmer i stället, om möjligt program ska alltså både lösa sina uppgifter och göra det med de medel som kursen behandlar korrekt resultat (utdata) enbart är inte tillräckligt för att bli godkänd på en laboration kan komplettering krävas, även om programmet i princip fungerar vid tentamen ges poängavdrag för bristande användning av standardbibliotekskomponenter om möjligt innebär att det finns passade komponenter i standardbibioteket program blir enkla lösningen blir naturlig Lambdauttryck är i många fall ett bra alternativ till funktionsobjekt. Funktionsobjekt TDIU04 Föreläsning 1 3 Containrar iteratorer algoritmer funktionsobjekt (forts.) vector<int> v; vector<int>::iterator sort(v.begin(), v.end()); // sorterar med < TDIU04 Föreläsning 1 4 Exempel 1: Sortering std::list #include <list> list<int> lst; int x; while (cin >> x) lst.push_back(x); lst.sort(); // list har inbyggd sortering sort(v.begin(), v.end(), greater<int>); // funktionsobjekt motsvarande > Alternativ syntax som fungerar för alla intervalliteratorer ( range access -funktioner): sort(begin(v), end(v), greater<int>); for (list<int>::const_iterator it = lst.cbegin(); it!= lst.cend(); ++it) cout << *it << ; cout << \n ; return 0; Kommer vi vanligtvis att föredra. Inläsningen och utskriften kan göras utan handskrivna repetitioner (while, for)

2 TDIU04 Föreläsning 1 5 Exempel 2: Sortering std::vector #include <vector> #include <algoritm> vector<int> v; int x; while (cin >> x) v.push_back(x); sort(v.begin(), v.end()); TDIU04 Föreläsning 1 6 Exempel 3: Algoritmen sort fungerar även på vanligt fält #include <algorithm> int a[1000]; int n = 0; int x; while (cin >> x) a[n++] = x; sort(a, a + n); auto past_end = v.cend(); for (auto it = v.cbegin(); it!= past_end; ++it) cout << *it << ; cout << \n ; // vector<int>::const_iterator int* past_end = a + n; for (int* p = a; p!= past_end; ++p) cout << *p << ; cout << \n ; return 0; return 0; TDIU04 Föreläsning 1 7 Range access -funktioner Enhetlig syntax för intervalliteratorer. int a[] 7, 2, 9, 4, 8, 6, 1, 5, 3 ; TDIU04 Föreläsning 1 8 Sekvenscontainrar fem grundtyper Elementen lagras i en strikt sekventiell ordning. array vector<int> v begin(a), end(a) ; sort(begin(a), end(a)); sort(begin(v), end(v)); Följande ska finnas (GCC 4.8 har enbart begin() och end()): begin() cbegin() rbegin() crbegin() vector deque end() cend() rend() crend() Inkluderingar som deklarerar range access : <iterator> forward_list <array> <deque> <forward_list> <list> <vector> <map> <set> <unordered_map> <unordered_set> <regex> <string> <initializer_list> list <valarray> array och forward_list ingår endast som orientering i kursen.

3 TDIU04 Föreläsning 1 9 Sekvenscontainrar tre adapterklasser Tre speciella men vanliga datastrukturer. kallas sekvensadaptrar eftersom de lagrar sina element internt i en sekvenscontainer och anpassar gränssnittet stack TDIU04 Föreläsning 1 10 Associativa containrar Elementen sätts in och återfinns baserat på en söknyckel (kan vara värdet som ska lagras). de (ordande) associativa containrarna implementeras vanligtvis med ett höjdbalanserat binärt sökträd, t.ex. röd-svart träd. map multimap set multiset deoordnade associativa containrarna implementeras som en hashtabell unordered_map unordered_multimap unordered_set unordered_multiset queue Mer om (ordnade) associativa containrar på Fö 5. Oordnade associativa containrar ingår inte i kursen. priority_queue prioritet Mer om sekvensadaptrar på föreläsning 4. TDIU04 Föreläsning 1 11 Intervallbaserad for-sats Ett smidigt alternativ om man ska iterera över ett intervall, t.ex. en container eller ett fält, och ingen algoritm direkt passar. vector<int> v 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ; // storlek 10 string a[] "foo", "fie", "fum" ; // dimension N == 3 två former, antingen där ett uttryck anger det som ska itereras över for (string x : a) // intervallet bestäms av [a, a + N) cout << x << ; for (int& x : v) x += 2; // intervallet bestäms av [v.begin(), v.end()) eller där en initierarlista listar värden som ska itereras över här med auto för att deklarera x typen bestäms ur elementtypen for (auto x : 0, 1, 1, 2, 3, 5, 8, 13, 21 ) cout << x << ; ett temporärt objekt tmp av typ std::initializer_list<int> skapas för initierarlistan intervallet bestäms av [tmp.begin(), tmp.end()) TDIU04 Föreläsning 1 12 Iteratorer Kan ses som pekare som kan peka på elementen i en container och vet hur man förflyttar sig mellan elementen. containeriteratorer kan peka på element i en container varje containertyp har sina egna iteratorer strömiteratorer kan bindas till en ström gör att vi kan läsa och skriva strömmar med iteratoroperationer insättariteratorer (insättare) binds till en container används för att sätta in element i en container minnessäkert move-iteratorer (flyttiteratorer) elements värden flyttas från källan till destinationen, i stället för att som vanligt kopieras källans element nollställs typiskt förbi-slutet-iterator ett speciellt iteratorvärde som anger slutet för en container, en ström eller annan typ av intervall av värden används främst för att jämföra andra iteratorer med har vi nått slutet? elementåtkomst genom avreferering med * eller -> (om objekten är av klasstyp) många inbyggda operationen på containrar har iteratorer som argument och/eller som returvärde de allra flesta algoritmer använder iteratorer för att operera på containrar och andra datasamlingar, inklusive strömmar felaktig användning av en iterator kan ge exekveringsfel, t.ex. segmentation fault

4 TDIU04 Föreläsning 1 13 Containeriteratorer TDIU04 Föreläsning 1 14 Iteratorpositioner Varje containertyp har sina specifika iteratorer. varje containertyp har nästlade typdefinitioner för containerns iteratortyper begin() it end() iterator const_iterator iterator för att iterera från början till slutet av en container måste användas om containern är const kan användas då elementen inte ska ändras reverse_iterator iterator för att iterera från slutet till början av en container const_reverse_iterator se const_iterator och medlemsfunktioner som returnerar iteratorer rend() rit rbegin() begin() end() rbegin() rend() cbegin() cend() crbegin() crend() Avreferering av en bakåtiterator ger elementet före iteratorpositionen. *rit ger det markerade elementet i positionen till vänster om rit när rit har nått samma position som rend() får man inte avreferera rit användningen av en bakåtiteratorer är helt naturlig Exempel: for (vector<int>::const_iterator it = v.cbegin(); it!= v.cend(); ++it) cout << *it << ; inget ska ändras under iterationen väljer const-iteratorer for (vector<int>::const_reverse_iterator rit = v.crbegin(); rit!= v.crend(); ++rit) cout << *rit << \n ; stegas baklänges med ++ egentligen inget man direkt behöver fundera över normalt bakåtiteratorer fungerar i praktiken som man förväntar sig! nödvändigt att känna till och följa om man ska konstruera egna containeriteratorer TDIU04 Föreläsning 1 15 Iteratorkategorier Random Access Bidirectional Forward / \ Input Output Representerar huvudsakligen två egenskaper hur en iterator kan förflyttas framåt bakåt elementvis godtyckligt hur man kan operera på element som en iterator pekar på läsa skriva Representerar inga verkliga iteratortyper används för kategorisering namnen används tioll exempel för att ange vilka krav olika algoritmer ställer på de iteratorer de tar TDIU04 Föreläsning 1 16 Operationer på iteratorer Förutom kopiering och tilldelning finns följande operationer för de olika iteratorkategorierna: Input Output Forward Bidirectional Random Access ==!= Ja Ja Ja Ja Ja * Läs Skriv Läs + Skriv Läs + Skriv Läs + Skriv -> Läs Skriv Läs + Skriv Läs + Skriv Läs + Skriv ++ Ja Ja Ja Ja Ja -- Ja Ja + += - -= Ja < <= > >= Ja it[n] Ja advance(it, n) Ja Ja Ja Ja distance(it1, it2) Ja Ja Ja Ja forward_list de oordnade associativa containrarna list set multiset map multimap vector deque array

5 TDIU04 Föreläsning 1 17 Exempel 4: Iteratoroperationer Vissa iteratoroperationer nedan kräver random access-iteratorer. int a[] 1, 2, 3, 4, 5, 6, 7, 8, 9 ; vector<int> v1 begin(a), end(a) ; // a är en pekare till första elementet // range access -funktioner vector<int> v2 begin(v1), end(v1) ; vector<int>::iterator first = begin(v1); // initiering (kopieringsinitieringssyntax) vector<int>::iterator past_end = end(v1); cout << *first << \n ; cout << *(past_end - 1) << \n ; cout << past_end - first << \n ; cout << first[5] << \n ; vector<int>::iterator it first ; // avreferering // aritmetik // avstånd // indexering // kopiering (direktinitieringssyntax) vector<int>::iterator middle; middle = begin(v2) + (end(v2) - begin(v2)) / 2; // tilldelning v2.erase(middle, end(v2));

6 TDIU04 Föreläsning 2 18 Strömiteratorer Iteratorer som kan bindas till strömmar. iteratoroperationer kan användas för att läsa eller skriva strömmar algoritmer kan appliceras på strömmar exempel på användning av strömiterator istream_iterator och ostream_iterator istream_iterator<int> input infile ; istream_iterator<int> eof; ostream_iterator<int> output cout, "\n" ; copy(input, eof, output); den typ av värden som ska läsas eller skrivas anges som instansieringsargument int istream_iterator använder operator>> för att läsa värden ostream_iterator använder operator<< för att skriva värden strömiterator kräver inkludering av <iterator> TDIU04 Föreläsning 2 19 Exempel 5: Strömiteratorer #include <algorithm> #include <fstream> #include <iterator> #include <vector> int main(int argc, char* argv[]) if (argc!= 2) cout << "använd: " << argv[0] << " fil\n"; return 1; ifstream infile argv[1] ; if (!infile) cout << "kunde inte öppna " << argv[1] << \n ; return 2; istream_iterator<int> input infile ; istream_iterator<int> eof; vector<int> v input, eof ; // konstruktor som tar ett iteratorintervall copy(begin(v), end(v), ostream_iterator<int>cout, "\n"); TDIU04 Föreläsning 2 20 Insättariteratorer (insättare) Iteratorer som kan bindas till containrar använder insättningsoperationer som lägger till minne vid behov algoritmer kan användas även då containrar som ska ta emot data inte säkert har tillräcklig kapacitet på förhand exempel på användning av en insättariterator (back_insert_iterator) istream_iterator<int> input cin ; istream_iterator<int> eos; vector<int> v; // tom, har typiskt ingen kapacitet TDIU04 Föreläsning 2 21 Exempel 6: Insättariteratorer #include <algorithm> #include <deque> #include <iterator> #include <vector> vector<int> v; copy(input, eos, back_inserter(v)); skapas med hjälpfunktionen back_inserter(container) sätter in element i container den bundits till med push_back() minne läggs till vid behov de andra insättariteratorerna är front_insert_iterator skapas med front_inserter(container) använder push_front(x) insert_iterator skapas med inserter(iterator, container) använder insert(iterator, x) insättariteratorerna kräver inkludering av <iterator> Det finns dock ett enklare sätt att göra ovanstående: vector<int> v istream_iterator<int>cin, istream_iterator<int> ; istream_iterator<int> input cin ; istream_iterator<int> eos; copy(input, eos, back_inserter(v)); deque<int> d; copy(begin(v), end(v), front_inserter(d)); copy(begin(d), end(d), ostream_iterator<int>cout, "\n"); return 0;

7 TDIU04 Föreläsning 2 22 Flyttiteratorer (move-iteratorer) move_iterator är en iteratoradapter. har samma egenskaper som den underliggande iteratorn skapas med hjälpfunktionen make_move_iterator(iterator) dess avrefereringsoperator omvandlar värdet som returneras av den underliggande iteratorns avrefereringsoperator till en rvalue-referens value_type&& operator*() const; vissa algoriter kan anropas med flyttiteratorer för att ersätta kopiering med flytt list<string> sistream_iterator<string>cin, istream_iterator<string>; // Kopiera strängarna i s till v1 vector<string> v1 begin(s), end(s) ; // Flytta strängarna i s till v2 TDIU04 Föreläsning 2 23 Sekvenscontainrar översikt jämförelse minneshantering iteratorer konstruktorer destruktor kopieringstilldelning (hela containrar) storlek och kapacitet elementåtkomst modifierare jämförelse (hela containrar) specialiserade algoritmer (endast en swap) speciella operationer för containertyperna list och forward_list vector<string> v2 make_move_iterator(begin(s)), make_move_iterator(end(s)) ; // Elementen i s är nu tomma strängar TDIU04 Föreläsning 2 24 Sekvenscontainrar initiering, kopiering, tilldelning, destruering Alla sekvenscontainrar har defaultkonstruktor, kopieringskonstruktor destruktor och kopieringstilldelningsoperator vector<int> v1; vector<int> v2v1; v2 = v1; array<int, 100> a; flyttkonstruktor och flytttilldelningsoperator används typiskt då källan är ett temporärt objekt (rvalue, kompilatorn vet) vector<int> fun(); vector<int> v3fun(); v3 = fun(); vector<int> v4std::move(v1); // hjälpfunktion för att framkalla flytt v4 = std::move(v2); konstruktor som tar en initierarlista (brace initializer list) TDIU04 Föreläsning 2 25 Sekvenscontainrar initiering, kopiering, tilldelning, destruering (forts.) Alla sekvenscontainrar utom array har konstruktor för initiering med n värdeinitierade element Observera, här fungerar inte..., tolkas som initierarlista vector<int> v6(10); konstruktor för initiering med n element med ett specifikt värde vector<int> v6(10, -1); konstruktor förr initiering med värden från ett intervall vector<int> v7 begin(v6), end(v6) ; tilldelningsoperator som tar en initierarlista som högerargument v7 = 1, 2, 3 ; medlemsfunktioner som motsvarar tilldelning v5.assign( 1, 2, 3 ); // värden från en initierarlista v6.assign(10, -1); // 10 element med värdet -1 v7.assign(begin(v6), end(v6)); // värden från intervallet [v6.begin(), v6.end()) vector<int> v5 1, 2, 3 ;

8 TDIU04 Föreläsning 2 26 Sekvenscontainrar operationer Storlek, kapacitet vector deque list forward_list array n = c.size() size() == max_size() för array m = c.max_size() c.resize(sz) c.resize(sz, x) n = c.capacity() b = c.empty() c.reserve(n) c.shrink_to_fit() minska kapacitetet, kanske till size() Elementåtkomst x = c.front() x = c.back() x = c[i] x = c.at(i) T* p = data(); TDIU04 Föreläsning 2 27 Sekvenscontainrar operationer (forts.) Modifierare vector deque list forward_list array c.push_back(x) c.pop_back() c.push_front(x) c.pop_front() it = c.insert(c.begin(), x) it = c.insert(c.begin(), n, x) it = c.insert(c.begin(), 1, 2, 3 ) c.insert(c.begin(), it1, it2) it = c.erase(c.begin()) it = c.erase(c.begin(), c.end()) c1.swap(c2) c.clear() TDIU04 Föreläsning 2 28 Sekvenscontainrar operationer (forts.) Modifierare vector deque list forward_list array c.emplace(args) c.emplace_front(args) c.emplace_back(args) c.emplace_after(args) c.emplace(pos, args) emplace sätta in på plats eller i position objekt skapas direkt på plats i containern, utan kopiering eller flytt av annat objekt (i form av argument) args är en argumentlista som utgörs av inget, ett eller flera argument om elementtypen för c är T, används args för att skapa ett objekt av typen T som sedan sätts in i c args måste alltså passa för att ges som argument till en konstruktor för T TDIU04 Föreläsning 2 29 Sekvenscontainrar operationer (forts.) Jämförelser vector deque list forward_list array c1 == c2 c1!= c2 c1 < c2 c1 <= c2 c1 > c2 c1 >= c2 Specialiserad algoritm swap(c1, c2) vector<pair<int, string>> v; v.emplace_back(17, "foo"); v.push_back(make_pair(17, "foo")); // pair-objekt skapas på plats av konstruktor för pair // make_pair skapar ett pair-objektet som sedan kopieras och destrueras

9 TDIU04 Föreläsning 2 30 Speciella operationer för list och forward_list Eftersom list och forward_list inte har Random Access-iteratorer, kan en del generella algoritmer inte användas. Inbyggda versioner som motsvarar generell algoritm TDIU04 Föreläsning 2 31 Exempel på generella algoritmer copy kopierar från ett intervall till ett annat int a[] 1, 2, 3, 4, 5 ; c.remove(x) c.remove_if(pred) c.unique() c.unique(pred) c1.merge(c2) ta bort element x ta bort element x om pred(x) är sant ta bort på varandra följande ekvivalenta element, == används vid jämförelse ta bort på varandra följande ekvivalenta element, pred används vid jämförelse samsortera c1 och c2; båda måste vara ordnade med <; c2 töms vector<int> v; copy(begin(a), end(a), back_inserter(v)); ostream_iterator<int> out cout, " " ; copy(begin(v), end(v), out); c1.merge(c2, comp) samsortera c1 och c2; båda måste vara ordnade med comp; c2 töms c1.sort() ordna elementen med < c1.sort(comp) ordnar elementen med comp c1.reverse() placera elementen i omvänd ordning Det finns också ett antal speciella medlemsfunktioner, överlagrade i flera versioner, relaterade till insättning, splicing och radering insert(), splice(), och erase() för list insert_after(), splice_after(), och erase_after() för forward_list insättning påverkar inte källan splicing tar bort elementen ifråga från källan copy_backward kopierar baklänges char c[] = a, b, c, d ; char result[4]; copy_backward(begin(c), end(c), end(result)); count räknar hur många gånger ett värde förekommer i ett intervall string s "standardbiblioteksfunktioner" ; auto n = count(begin(s), end(s), s ); TDIU04 Föreläsning 2 32 equal avgör om två intervall innehåller parvis lika värden if ( equal(begin(v1), end(v1), begin(v2)) ) cout << "Lika!\n"; fill tilldelar ett värde till elementen i ett intervall vector<int> v(10); fill(begin(v), end(v), 1); for_each anropar en unär funktion för varje element i ett intervall funktionen är här given som ett lambdauttryck for_each(begin(v), end(v), [](int x) cout << setw(8) << x; ); Observera att for_each även returnerar funktionen. TDIU04 Föreläsning 2 33 remove tar bort alla förekomster av ett värde remove(begin(v), end(v), x) Observera! storleken size() minskar ej skräpelement finns kvar i slutet returnerar iterator till det nya, logiska slutet pekar på det första skräpelementet erase tar bort element anpassar storleken I kombination med remove ta bort alla x och radera skräpelementen i slutet v.erase(remove(begin(v), end(v), x), end(v); min- och maxvärde cout << max(x, y) << \n ; // använder < cout << max(x, y, comp) << \n ; // använder comp it = max_element(begin(v), end(v)); auto p = minmax_element(begin(v), end(v)); // returnerar två iteratorer i ett pair cout << p.first << ", " << p.second << endl;

10 TDIU04 Föreläsning 2 34 Implementering av copy() Som ett exempel på hur en algoritm kan vara implementerad. template<typename InputIterator, typename OutputIterator> OutputIterator copy(inputiterator first, InputIterator last, OutputIterator result) for (; first!= last; ++result, ++first) *result = *first; return result; intervallet [first, last) stegas igenom result stegas parallellt med first för varje element i intervallet tilldelas det element som result pekar på tilldelning ökar inte kapacitet vid behov motsvarande element i result måste finnas returnerar en iterator som pekar på förbi-sist-kopierade koden ovan är rensad från vissa kontroller som kompilatorn gör på first, last och result TDIU04 Föreläsning 2 35 Enkla lambdauttryck Ett lambdauttryck är ett uttryck som definierar en anonym funktion. [](int x) ->int return 2*x + 1; inleds med lambdaintroduceraren [] sedan följer en vanlig funktionsparameterlista resultattyp kan anges efter parameterlistan om ingen resultattyp anges måste det finnas en return-sats som returnerar ett värde, som då bestämmer resultattypen [](int x) return 2*x + 1; avslutas med en vanlig funktionskropp ett enkelt sätt att skapa enkla funktionsobjekt (kallas closure objects == funktion + referensomgivning ) Exempel: int a[] 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ; vector<int> v; transform(begin(a), end(a), back_inserter(v), [](int x) return 2*x + 1; ); copy(begin(v), end(v), ostream_iterator<int>cout, " "); //

11 TDIU04 Föreläsning 3 36 Klasstyper struct och class (även union) struct väljs då inga medlemmar behöver skyddas medlemmarna i en struct är underförstått public struct Node int data; Node* next; ; enkel, klassisk posttyp den ovan är så enkel att den uppfyller kraven för att vara ett aggregat class väljs då vissa medlemmar ska vara skyddade för direkt åtkomst class Node public: // typiskt olika medlemsfunktioner för att operera på Node-objekt private: int data; Node* next; ; gäller typiskt datamedlemmar private eller protected (vid härledning) aggregat får inte ha medlemmar som är private eller protected (det finns tre krav till) TDIU04 Föreläsning 3 37 Grundläggande frågor vid konstruktion av klasser initiering objekt ska ha ett väldefinierat initialvärde (tillstånd) alla datamedlemmar bör (ska) initieras datamedlemmar av enkel typ (int, double, bool, etc.) initieras inte automatiskt då de är medlemmar i klasser datamedlemmar av klasstyp initieras, om inte annat, av sin defaultkonstruktor int x; // ospecificerat initialvärde, såvida inte en global variabel, i så fall 0 string s1; // initieras till tom sträng oavsett var deklarationen finns destruering ett klassobjekt som upphör att existera ska destrueras klassens destruktor körs datamedlemmar av enkel typer behöver inte destrueras på något sätt för datamedlemmar av klasstyp körs destruktorn för datamedlemmen i fråga typexemplet är att återlämna dynamiskt minne efter destrueringen tas minnesutrymmet för objektet tillbaka kopiering ett objekt kopieras då det används för att initiera ett annat objekt string s2s1; // s2 initieras till samma värde som s1 ett objekt kopieras då det används för att tilldela ett annat objekt ett nytt värde s1 = s2; // s1 tilldelas samma värde som s2 flytt (move) kan i vissa situationer göras i stället för kopiering källobjektets innehåll flyttas till destinationsobjektet TDIU04 Föreläsning 3 38 Klass Clock Objekt av typen Clock ska lagra timme, minut och sekund samt tidszon timme kan variera mellan 0 och 23, minut och sekund mellan 0 och 59 vi väljer int för lagring av dessa för tidszoner finns förkortningar som varierar mellan tre till fem tecken, till exempel UTC för Coordinated Universal Time ULAT för Ulaanbaatar Time (UTC+08) EASST för Easter Island Standard Summer Time (UCT-5) vi väljer std::string för lagring version 0 en första ansats så enkel att kraven för att vara ett aggregat uppfylls initierarlistor kan användas men nackdelarna överväger version 1 en enkel struct alla medlemmar är direkt tillgängliga (underförstått public) datamedlemmarna deklareras med initierare (det får aggregat numera ha) operationerna definieras som vanliga funktioner programmering i C version 2 en class med mer kontroll över data datamedlemmarna skyddas mot direkt åtkomst genom att specificeras private operationerna definieras som medlemsfunktioner (public) ett aggregat får inte ha egendefinierade konstruktorer version 3 med egendefinierad konstruktor TDIU04 Föreläsning 3 39 Clock version 0 Alla medlemmar är direkt tillgängliga (underförstått public) struct Clock int hour; int min; int sec; std::string time_zone; ; Clock c1; // initieras motsvarande?,?,?, "" c1.hour = 8; c1.min = 15; c1.sec = 30; c1.time_zone = "UTC"; Clock c2 12, 25, 30, "GMT" ; Clock c3(c1); c3 = c2; c3 = 10, 21, 30, "CET" ; // punktoperatorn för medlemsåtkomst är inbyggd (liksom piloperatorn) // datamedlemmarna initieras från en initierarlista aggregatinitiering // c3 initieras som en kopia av c1 kopieringskonstruktor // c3 tilldelas samma värde som c2 kopieringstilldelning // c3 tilldelas från en initierarlist att initiering och tilldelning med initierarlista är tillåtet beror på att Clock är ett aggregat i deklarationen av c3 kan inte användas Clock är ett aggregate konflikt med initierarlistsyntax

12 TDIU04 Föreläsning 3 40 Clock version 1 Datamedlemmar kan ha initierare i deklarationen (i C++14 är detta även tillåtet för aggregat). struct Clock int hour0; // 0-23 int min0; // 0-59 int sec0; // 0-59 std::string time_zone"utc"; ; ett väldefinierat initialvärde är garanterat Clock c; // initieras motsvarande 0, 0, 0, "UTC" Clock är ett aggregat (C++14) Clock c 12, 25, 30, "GMT" ; c = 10, 21, 30, "CET" ; c.hour = 15; Clock* p = new Clock; p->time_zone = "CET"; delete p; // tillåtet i C++14 // tillåtet i C++14 // punktoperatorn för medlemsåtkomst // piloperatorn för medlemsåtkomst via pekare // objektet p pekar på destrueras, minnet tas tillbaka TDIU04 Föreläsning 3 41 Clock version 1 (forts.) Operationerna för Clock definieras som vanliga funktioner. en del funktioner finns för att ändra tiden eller för att göra komplicerade saker, exempelvis void set(clock& c, int h, int m, int s, const std::string& tz = ""); std::string set_time_zone(clock& c, const std::string& tz); void tick(clock& c); andra finns för att ge åtkomst till värden, exempelvis int get_hour(const Clock& c); std::string get_time_zone(const Clock& c); std::string str(const Clock& c); den del finns för att ge åtkomst till data åtkomstfunktioner en del finns för att ändra tiden eller göra komplicerade saker vid ändring ska dessa säkerställa att tidsvärdena är korrekta datamedlemmarna kan manipuleras direkt riskfyllt! datamedlemmarna ska skyddas för direkt åtkomst enbart relevanta operationer på dem ska kunna utföras TDIU04 Föreläsning 3 42 Clock version 2 class Clock public: int get_hour() const return hour; int get_min() const return min; int get_sec() const return sec; void set(int h, int m, int s, const std::string& tz = ""); std::string get_time_zone() const return time_zone ; void tick(); std::string str() const; private: int hour0; // 0 23 int min0; // 0 59 int sec0; // 0 59 std::string time_zone"uct"; ; datamedlemmarna skyddas mot direkt manipulation (private) Clock är inte ett aggregate kan endast kommas åt utifrån via medlemsfunktionerna (public) const-funktionerna kan inte ändra datamedlemmar åtkomstfunktioner (accessfunktioner) icke-const-funktionerna kan ändra datamedlemmar modifierare TDIU04 Föreläsning 3 43 Clock version 2 (forts.) Separatdefinierade medlemsfunktioner. void Clock::set(int h, int m, int s, const std::string& tz) if (h < 0 h > 23 m < 0 m > 59 s < 0 s > 59) throw std::out_of_range"clock::set"; hour = h; min = m; sec = s; if (!tz.empty()) time_zone = tz; de enklare medlemsfunktionerna har definierats i klassdefinitionen smaksak, stilfråga medlemsfunktion som definieras separat måste anges med kvalificerat namn Clock::namn för övrigt som en vanlig funktionsdefinition om felaktiga värden ges kastas undantaget std::out_of_range någonstans måste detta fångas om programmet ska överleva datamedlemmar används med sina enkla namn i medlemsfunktionerna

13 TDIU04 Föreläsning 3 44 Clock version 2 (forts.) Clock c1; for (int i = 0; i < 3600; ++i) if (i % 60 == 0) cout << c1.str() << \n ; c1.tick(); cout << c1.str() << endl; c1.set(10, 15, 30); Clock c2c1; cout << c2.str() << endl; c2.set_hour(21); c1 = c2; cout << c1.str() << endl; // initieras till 00:00:00 [UTC] Vem gör det? // 1 timmas iteration // skriver ut 00:00:00 [UTC] och sedan för varje minut // medlemsfunktioner anropas med speciell syntax punktoperatorn // 01:00:00 [UTC] // tidszon ändras inte // c2 blir en kopia av c1 Vem gör det? // 10:15:30 [UTC] // c1 tilldelas samma värde som c2 Vem gör det? // 21:15:30 [UTC] När main() avslutas upphör Clock-objekten att existera det innebär att de ska destrueras Vem gör det? Vad innebär det? TDIU04 Föreläsning 3 45 Speciella medlemsfunktioner orientering delvis överkurs Utöver de medlemsfunktioner som vi har deklarerat för Clock genereras följande av kompilatorn: defaultkonstruktor medför att alla datamedlemmar med defaultinitiering eller med en initierare i sin deklaration initieras Clock(); Clock c1; kopieringskonstruktor och flyttkonstruktor gör medlemsvis kopiering respektive flytt Clock(const Clock& other); Clock c2c1; Clock(Clock&& other);? kopieringstilldelningsoperator och flyttilldelningsoperator gör medlemsvis kopieringstilldelning respektive flyttilldelning Clock& operator=(const Clock& rhs); c1 = c2; Clock& operator=(clock&& rhs);? destruktor medför att alla datamedlemmar av klasstyp destrueras. ~Clock(); då objekt upphör existera någon konstruktor körs alltid då ett nytt objekt skapas destruktorn körs alltid då ett objekt är på väg att försvinna, innan minnet tas tillbaka (automatiskt eller i samband med delete) de kompilatorgenererade versionerna för Clock fungerar bra alla datamedlemmar är garanterat initierade std::string har sina egna speciella medlemsfunktioner time_zone initieras, kopieras och destrueras korrekt TDIU04 Föreläsning 3 46 Speciella medlemsfunktioner orientering delvis överkurs (forts.) Situationer där de speciella medlemsfunktionerna körs ibland i det fördolda Clock fun(clock c4) // argumentet i anropet (c2) kopieras till c4 av kopieringskonstruktorn Clock c5c4; // kopieringskonstruktorn kopierar datamedlemmarna i c4 till motsvarande medlem i c5 return c5; // ett temporärt Clock-objekt skapas flyttkonstruktorn initierar detta med c5 Clock c1; // c1 initieras av defaultkonstruktorn till 0, 0, 0, "CET" Clock c2(c1); Clock c3 = c1; c2 = c3; c1 = fun(c2); // kopieringskonstruktorn kopierar datamedlemmarna i c1 till motsvarande medlem i c2 // kopieringskonstruktorn gör även detta! // kopieringstilldelningsoperatorn gör tilldelningen c2 blir en kopia av c3 // fun returnerar ett temporärt objekt flyttilldelningsoperatorn gör tilldelningen när fun() returnerar upphör c5 att existera destruktorn körs när main() returnerar upphör c1, c2 och c3 att existera destruktorn körs för dessa kompilatorn noterar att c5 är nära slutet på sin livstid när fun() returnerar väljer flytt i stället för kopiering kompilatorn noterar även att fun() returnerar ett temporärt objekt väljer flytt i stället för kopiering TDIU04 Föreläsning 3 47 Clock version 3 Egendefinierad konstruktor som kan ta timma, minut och sekund samt, om så önskas, tidszon (har defaultvärde). när man deklarerar någon konstruktor kommer inte defaultkonstruktorn att genereras automatiskt Clock c; // inte möjligt deklaration med default får kompilatorn att genererar defaultkonstruktorn class Clock public: Clock() = default; ; Clock(int h, int m, int s, const std::string& tz = "") set_if_check(h, m, s); if (!tz.empty()) time_zone = tz; // annars "UTC" Clock c210, 15, 30, "CET"; Clock c310, 15, 30; en konstruktor deklareras med klassens namn före parameterlistan har ingen resultattyp inte ens void för övrigt som för vanlig medlemsfunktion // motsvarar 10, 15, 30, "UTC"

14 TDIU04 Föreläsning 3 48 Clock version 3 (forts.) Medlemsinitierarlista. Clock(int h, int m, int s, const std::string& tz = "") : hourh, minm, secs, time_zonetz en medlemsinitierarlista placeras mellan parameterlistan och funktionskroppen inleds med semikolon består av en lista av medlemsinitierare, separerade med komma om en medlemsinitierare finns utförs inte en eventuell initierare i datamedlemmens definition eller () kan användas i medlemsinitierararna ger ofta mer läsbar kod ger effektivare kod för medlemmar av klasstyp vissa slags datamedlemmar måste initieras med en medlemsinitierare kan inte tilldelas konstanter referenser ingen kontroll av initialvärdena görs av denna konstruktor TDIU04 Föreläsning 3 49 Klassmallen std::tuple Kan användas för att skapa tupler. objekt med ett godtyckligt antal element av godtycklig typ, även inga element. behändig som resultattyp för funktioner som ska returnera flera värden class Clock public: using clock_tuple = std::tuple<int, int, int, std::string>; ; clock_tuple get() const return make_tuple(hour, min, sec, time_zone); Clock c10, 15, 0, "CET"; int h, m, s; string tz; tie(h, m, s, tz) = c.get(); tie(h, m, s, ignore) = c.get(); // tie är en hjälpfunktion packar upp den tupel som returneras i variablerna // vi är inte intresserade av tidszonen clock_tuple är en nästlad typ make_tuple() är en hjälpfunktion för att skapa ett tuple-objekt för de argument som ges som element tie() är en hjälpfunktion som packar upp elementen i en tuple i motsvarande variabler TDIU04 Föreläsning 3 50 Aggregat sammanfattning Ett aggregat kan vara ett fält ( array á la C) kan listinitieras (aggregatinitieras) int a[10] 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ; men inte tilldelas med initierarlista en klass (struct, class, union) med kraven inga egendefinierade konstruktorer bara de kompilatorgenererade får finnas inga icke-statiska medlemmar som är private eller protected inga basklasser (ärver inte från annan klass) inga virtuella funktioner Clock version 0 är ett aggregat klassaggregat kan både initieras och tilldelas med initierarlista Clock c1; // initieras 0, 0, 0, "" Clock c2 10, 15 ; // initieras 10, 15, 0, "" c = 12, 0, 0, "CET" ; Clock* p = new Clock; // initieras 0, 0, 0, "" TDIU04 Föreläsning 3 51 Sammanfattning Fö 3 Av det vi har gått igenom på Fö 3 är följande viktigt. grundläggande förståelse av klasstyperna struct och class välj struct om alla medlemmar ska vara allmänt tillgängliga (public) välj class om det ska finnas medlemmar som är private känna till olika alternativ att initiera datamedlemmar kunna skriva en egen konstruktor för en enkel klass förstå skillnaden mellan const eller icke-const medlemsfunktion använda public och private för att styra åtkomst till medlemmar nästlade typer i klasser Du kommer att använda struct för att definiera enkla funktionsobjekt. känna till aggregat antingen en enkel klasstyp typiskt struct och typiskt med enbart datamedlemmar eller ett fält ( array ) aggregatinitiering initierarlista och listinitiering det finns en mallklass std::initializer_list som används för att representera initierarlistor TDDI14 Objektorienterad programmering, för DI1, kommer att behandla klasser och objektorientering på djupet.

15 TDIU04 Föreläsning 4 52 Sekvensadaptrar adapterklasser som representerar tre klassiska datastrukturer stack queue priority_queue har internt en sekvenscontainer där elementen lagras stack deque queue deque priority_queue vector har ett förenklat gränssnitt antalet operationer är påtagligt reducerat i jämfört med sekvenscontainern som används internt operationerna omdöpta enligt tradition t.ex. push, top och pop för stack inga iteratorer ej relevant för dessa datastrukturer TDIU04 Föreläsning 4 53 Sekvensadaptrar konstruktion, kopiering, tilldelning och destruering Alla sekvensadaptrar har defaultkonstruktor, kopieringskonstruktor, kopieringstilldelningsoperator och destruktor priority_queue<int> pq1; move-konstruktor och move-tilldelningsoperator används framför allt då källan är ett temporärt objekt konstruktor för initiering med element från en container vector<int> v;... queue<int> q1v; priority_queue har dessutom konstruktor som tar en jämförare default är std::less (motsvarar <) priority_queue<int, std::greater<int>> pq2; konstruktor för initiering med element från ett iteratorintervall priority_queue<int> pq2begin(v), end(v); Det finns också versioner av ovanstående som även tar en allokator. TDIU04 Föreläsning 4 54 Sekvensadaptrar operationer Storlek, kapacitet stack queue priority_queue n = a.size() b = a.empty() Elementåtkomst stack queue priority_queue x = a.top() x = pq.front() x = pq.back() Modifierare stack queue priority_queue a.push(x) a.pop() a.emplace(args) Jämförelse stack queue priority_queue ==!= < <= > >= TDIU04 Föreläsning 4 55 Klassen pair Klass för att lagra värdepar används till exempel av all map-containrar. Förenklad definition: template <class T1, class T2> struct pair typedef T1 first_type; typedef T2 second_type; ; T1 first; T2 second; pair(); pair(const T1& x, const T2& y); template <class U, class V> pair(const pair<u, V>& p); har kopieringskonstruktor, kopieringstilldelningsoperator och destruktor, samt operator== och operator<. har flyttkonstruktor och flyttilldelningsoperator har hjälpfunktion make_pair för att skapa pair-objekt vector< pair<int, string> > v; int i = 4711; string s = "foobar"; v.push_back(make_pair(i, s)); // samma som pair<int, string>(i, s) // typomvandlande konstruktor

16 TDIU04 Föreläsning 4 56 operator<< och operator>> för strömmar Mönster för att överlagra operator<< och operator>> för strömmar T är typiskt en klasstyp (class eller struct) kan även vara en sammansatt typ av annat slag, t.ex. uppräkningstyp (enum) eller pekartyp TDIU04 Föreläsning 4 57 Exempel 7: operator<< för uppräkningstyp Switch enum Switch Off, On ; ostream& operator<<(ostream& os, const T& t) // utskrift av t:s värde return os; ostream& operator<<(ostream& os, Switch s) return os << (s == Off? "Off" : s == On? "On" : ""); Switch s Off ; // undantag från regeln istream& operator>>(istream& is, T& t) // inläsning av t:s värde return is; cout << s << \n ; s = On; cout << s << \n ; s = static_cast<switch>(2); cout << s << \n ; // 0 defaultmässigt Off med operator<< enligt ovan // 1 defaultmässigt On med operator<< enligt ovan // 2 defaultmässigt inget ("") med operator<< enligt ovan Hur fungerar dessa operatorer vid skrivning och läsning av inbyggda datatyper? return 0; TDIU04 Föreläsning 4 58 Exempel 8: Namnrymd /* * Switch.h */ #ifndef SWITCH_H #define SWITCH_H #include <iosfwd> namespace Switch_ns enum Switch Off, On ; std::ostream& operator<<(std::ostream&, Switch); std::istream& operator>>(std::istream&, Switch&); // namespace Switch_ns #endif TDIU04 Föreläsning 4 59 Exempel 8: Namnrymd (forts.) /* * Switch.cc */ #include "Switch.h" ostream& Switch_ns:: operator<<(ostream& os, Switch s) os << (s == Off? "Off" : s == On? "On" : ""); return os; istream& Switch_ns:: operator>>(istream& is, Switch& s) s = static_cast<switch>(-1); // ATT GÖRA! return is; Alternativt kan samma form av namnrymdsdeklaration som finns i h-filen användas för att omsluta definitionerna av operatorerna, då utan namnrymdsprefixet framför operator<< och operator>>.

17 TDIU04 Föreläsning 4 60 Exempel 8: Namnrymd (forts.) #include "Switch.h" using namespace Switch_ns; Switch s Off ; cout << s << \n ; // Off s = On; cout << s << \n ; // On TDIU04 Föreläsning 4 61 Åtkomst till namn i en namnrymd using-direktiv öppnar namnrymden using namespace Switch_ns; using-deklaration gör ett enskilt namn synligt using Switch_ns::Switch; using Switch_ns::Off; kvalificerat namn anger det fullständiga namnet Switch_ns::Switch s = Switch_ns::Off; return 0; När kompilatorn letar efter funktioner som passar in på ett funktionsanrop utgår den från argumentens typ. i detta fall ostream, deklarerad i namnrymden std, och Switch, deklarerad i namnrymden Switch_ns kompilatorn kommer att leta efter operator<<(ostream&, const Switch) i dessa namnrymder ADL "Argument Dependent Lookup" TDIU04 Föreläsning 4 62 Standardundantag TDIU04 Föreläsning 4 63 Exempel 9: Undantagshantering exception logic_error runtime_error bad_typeid bad_cast bad_weak_pointer bad_exception bad_function_call bad_alloc domain_error invalid_argument length_error out_of_range furure_error range_error overflow_error underflow_error system_error bad_array_new_length ios_base::failure kastas t.ex. av: otillåtna funktionsvärden bitset-konstruktor objektlängd överskrids at() funktioner i trådbiblioteket vissa beräkningar bitset::to_long() vissa beräkningar systemrelaterade fel ios_base::clear() typeid dynamic_cast shared_ptr-konstruktorer exception specification function::operator() new new[] string alphabet"abcdefghijklmnopqrstuvwxyz"; int pos; cin.exceptions(ios::badbit ios::failbit); try cout << "Ge en bokstavsposition (1-26): "; cin >> pos; cout << "Bokstaven är: " << alphabet.at(pos - 1) << \n ; catch (const out_of_range& e) cout << "out_of_range: " << e.what() << \n ; catch (const ios::failure& e) cout << "ios::failure: " << e.what() << \n ; catch (const exception& e) cout << "exception: " << e.what() << \n ; catch (...) cout << "Ett oväntat fel har inträffat!\n"; // ois::failure ska kastas vid fel i cin

18 TDIU04 Föreläsning 4 64 Egendefinierad undantagsklass Receptet är enkelt: välj lämplig standardundantagsklass som basklass exempelvis std::logic_error välj det standardundantag som bäst kategoriserar felet definiera två konstruktorer en för std::string en för C-strängar övrig funktionalitet ärvs, till exempel medlemsfunktionen what() class my_exception : public std::logic_error public: explicit my_exception(const std::string& what_arg) : std::logic_error(what_arg) explicit my_exception(const char* what_arg) : std::logic_error(what_arg) ; explicit innebär att konstruktorerna inte kan användas för implicit typomvandling exceptionobjekt ska bara skapas i throw-uttryck TDIU04 Föreläsning 4 65 Undantagshantering några rekommendationer Använd undantag för att hantera fel. dock inte om lokala styrstrukturer är fullt tillräckliga separerar ordinarie kod och felhanteringskod Försök att minimera antalet try-block. Funktioner som hör till programkomponenter ska inte skriva ut felmeddelanden eller avsluta program. kasta endast undantag och låt sedan anroparen/användaren bestämma vad som ska göras Se till att frigöra resurser som erhållits innan ett undantag genereras. t.ex. minne som tilldelats med new undantagssäker programmering (exception-safe programming) Låt main() fånga och rapportera alla slags fel sist utpost. Förutsätt inte att alla fel är härledda från exception. använd ellips i lämpliga situationer catch (...) throw my_exception("panik");

19 TDIU04 Föreläsning Associativa containrar Snabb åtkomst till data baserat på söknycklar följande associativa containrar är ordnade itererar man över dem erhålles elementen i nyckelordning map multimap set multiset set-containrar lagrar enbart nycklar (värden) map-containrar lagrar nyckel-värde-pair använder pair för att lagra en nyckel och ett associerat värde i de (ordnade) associativa containrar är elementen ordnade efter nyckel parametriserade med avseende på nyckeltyp och ordningsrelation (och minnesallokator) i map-versionerna associeras även en godtycklig typ med nyckeln, värdetyp implementeras typiskt med ett binärt sökträd (t.ex. ett röd-svart träd, ett höjd-balanserat binärt sökträd) icke-multi-varianterna tillåter enbart unika nycklar två element kan inte ha samma nyckel multi-varianterna tillåter ekvivalenta nycklar flera element kan ha samma nyckel, även det associerade värdet kan vara samma dessutom finns motsvarande oordnade associativa containrar TDIU04 Föreläsning Associativa containrar konstruktion, kopiering, tilldelning och destruering Alla associativa containrar har defaultkonstruktor, kopieringskonstruktor, kopieringstilldelningsoperator och destruktor map<int, string> m; multi_set<string> ms; move-konstruktor och move-tilldelningsoperator konstruktor och tilldelningsoperator för att initiera/tilldela med värden från en initierarlista konstruktor för att initiera med värden från ett intervall unordered_map unordered_multimap unordered_set unordered_multiset elementen lagras i en hashtabell behandlas inte i denna kurs TDIU04 Föreläsning Associativa containrar operationer TDIU04 Föreläsning Associativa containrar operationer (forts.) Storlek, kapacitet map multimap set multiset n = a.size() n = a.max_size() b = a.empty() Jämförelse map multimap set multiset ==!= < <= > >= Elementåtkomst map multimap set multiset x = a[k] x = a.at(k) Anm: om ett element med nyckel k inte finns i en map, skapas det av operator[], med det associerade värdet defaultinitierat. En referens till det associerade värdet returneras och kan användas för att tilldela ett värde. Modifierare map multimap set multiset pair<iterator, bool> p = a.insert(x); 1, 3 it = a.insert(x) 1 it = a.insert(pos, x) 1 a.insert(first, last) a.insert( x, y, z ) pair<iterator, bool> p = a.emplace(args); 2, 3 it = a.emplace(args) 2 it = a.emplace_hint(pos, args) 2 a.erase(it) n = a.erase(k) a.erase(first, last) a1.swap(a2) a.clear() 1) i fallen map och multimap har x typen pair (nyckel värde) 2) i fallen map och multimap ska args var värden motsvarande ett nyckel värde-par 3) använd hellre auto

20 TDIU04 Föreläsning Associativa containrar operationer (forts.) Map- och set-operationer map multimap set multiset it = a.find(k) n = a.count(k) it = a.lower_bound(k) it = a.upper_bound(k) pair<iter, iter> p = a.equal_range(k); 1 Specialiserad operation swap(a1, a2) 1) använd hellre auto TDIU04 Föreläsning Exempel 10: std::map #include <map> #include <string> #include <utility> map<int, string> m; int key; string value; while (cin >> key) cin >> value; m[key] = value; cout << m.size() << "nyckel/värde-par inlästa:\n"; for (auto it = cbegin(m); it!= cend(m); ++it) cout << it->first << ": " << it->second << \n ; // map<int, string>::const_iterator TDIU04 Föreläsning Exempel 11: std::map (exempel 10 modifierat) #include <map> #include <string> #include <utility> using Map = map<int, string>; Map m; int key; string value; while (cin >> key) cin >> value; m[key] = value; cout << m.size() << "nyckel/värde-par inlästa:\n"; TDIU04 Föreläsning Exempel 12: std::multimap #include <map> #include <string> #include <utility> using Map = multimap<int, string>; Map m; int key; string value; cout << "Ange nyckel/värde-par (0 avslutar):\n"; while (cin >> key && key!= 0) cin >> value; m.emplace(key, std::move(value)); // m.insert(make_pair(key, std::move(value))); for (const auto& p : m) cout << p.first << ": " << p.second << \n ; // const pair<int, string> forts. nästa sida!

21 TDIU04 Föreläsning TDIU04 Föreläsning do cout << "\nge en söknyckel (0 avslutar): "; cin >> key; if (key!= 0) cout << "Det finns " << m.count(key) << " poster:\n"; auto p = m.equal_range(key); // pair<map::iterator, Map::iterator> for (Map::const_iterator it = p.first; it!= p.second; ++it) cout << it->first << ": " << it->second << \n ; while (key!= 0); return 0; Exempel 13: std::set #include <set> #include <iterator> ostream& operator<<(ostream& os, const set<int>& s) copy(begin(s), end(s), ostream_iterator<int>os, " "); return os; set<int> s; int x; cout << "Sätter in 5, 1, 8, 4, 1 i ett tomt set s.\n"; s.insert(5); s.insert(1); s.insert(8); s.insert(4); s.insert(1); cout << "\nantal värden i s är" << s.size() << \n ; cout << "s innehåller:\n"; cout << s << \n ; forts. nästa sida! TDIU04 Föreläsning TDIU04 Föreläsning do cout << "\nsök på värdet (0 avbryter): "; cin >> x; if (x!= 0) if (s.find(x)!= end(s)) cout << x<< " hittades!\n"; else cout << x<< " hittades inte!\n"; while (x!= 0); return 0; Exempel 14: std::multiset #include <set> #include <utility> #include <iterator> template<typename T> ostream& operator<<(ostream& os, const multiset<t>& s) copy(begin(s), end(s), ostream_iterator<t>os, " "); return os; multiset<int> ms; cout << "Sätter in 5, 1, 8, 4, 1 i ett tomt multiset ms.\n"; ms.insert(5); ms.insert(1); ms.insert(8); ms.insert(4); ms.insert(1); forts. nästa sida!

22 TDIU04 Föreläsning if (ms.empty()) cout << "ms är tom\n"; else cout << "ms är inte tom\n"; cout << "ms har storleken " << ms.size() << "\n\n"; cout << "ms innehåller:\n" << ms << "\n\n"; cout << "Det finns " << ms.count(1) << " 1:or i ms.\n"; TDIU04 Föreläsning Exempel 15: Egendefinierad funktionsobjektsklass logical_xor struct logical_xor bool operator()(bool lhs, bool rhs) return (lhs &&!rhs) (!lhs && rhs); ; return 0; cout << boolalpha; // false/true i stället för 0/1 cout << logical_xor(true, false) << \n ; // temporärt objekt skapas logical_xor XOR; // xor finns, ersättningssymbol för ^ cout << XOR(false, true) << \n ; cout << XOR.operator()(false, true) << \n ; // vanlig medlemsfunktionsanropssyntax Observera logical_xor enligt ovan kommer att förbättras i flera avseenden! TDIU04 Föreläsning Användning av funktionsobjekt i kombination med algoritmer TDIU04 Föreläsning Exempel 16: Mallifiering av logical_xor version 1 vector<bool> b1; vector<bool> b2; // b1 och b2 fylls på // Stega från början till slutet av b1 och från början av b2, resultatet i b1 transform(begin(b1), end(b1), begin(b2), begin(b1), logical_xor); // b1 innehåller nu b1 xor b2 ett temporärt objekt skapas med uttrycket logical_xor generellt gäller att om T är en datatyp kan man med uttrycket T eller T() skapa ett värdeinitierat objekt av typen T om T är en klasstyp initieras objektet med defaultkonstruktorn om T är en numerisk typ initieras objektet till noll om logical_xor hade varit en vanlig funktion transform(begin(b1), end(b1), begin(b2), begin(b1), logical_xor); template<typename T> struct logical_xor bool operator()(const T& lhs, const T& rhs) return (lhs &&!rhs) (!lhs && rhs); ; Mallifiera logical_xor byt bool mot formell typ T för parametrarna returtypen ska alltid vara bool deklarera T som en malltypparameter typename eller class uttrycklig instansiering (specialisering) krävs i denna situation: transform(begin(b1), end(b1), begin(b2), begin(b1), logical_xor<bool>); enbart namnet anges funktionspekare överförs

23 TDIU04 Föreläsning Exempel 17: Mallifiering av logical_xor version 2 template <typename T> struct logical_xor bool operator()(const T& lhs, const T& rhs) const return (lhs &&!rhs) (!lhs && rhs); ; using first_argument_type = T; using second_argument_type = T; using result_type = bool; Två förbättringar till argument- och returtyperna deklareras som nästlade typer standardiserade namn används krävs av vissa komponenter i standardbiblioteket använd i deklarationer i komponenten i fråga deklarera operator() som const kan då användas även i sammanhang där konstanthet gäller TDIU04 Föreläsning Exempel 18: Generera fibonaccital i en vector class Fibonacci public: Fibonacci() : F_n0, F_n11 ; unsigned long long int operator()() const unsigned long long int next_fibf_n; F_n = F_n1; F_n1 = next_fib + F_n; return next_fib; private: mutable unsigned long long int F_n; mutable unsigned long long int F_n1; vector<unsigned long long int> v(21); generate(begin(v), end(v), Fibonacci); copy(begin(v), end(v), ostream_iterator<unsigned long long int>cout, " "); TDIU04 Föreläsning Exempel 19: Aritmetiska standardfunktionsobjekt Används om en aritmetisk operation ska utföras av en algoritm. TDIU04 Föreläsning Exempel 20: Standardfunktionsobjekt för jämförelser Används om en jämförelseoperation relationsoperation eller likhetsoperation ska utföras av en algoritm. int a[] 1, 2, 3, 4, 5, 6, 7, 8, 9 ; vector<int> v1begin(a), end(a); vector<int> v2begin(a), end(a); vector<int> v3(v1.size()); // lite indata att fylla v1 och v2 nedan med vector<int> v1 0, 2, 4, 5, 5, 7, 8, 8, 9 ; vector<int> v2 1, 2, 3, 4, 5, 6, 7, 8, 9 ; vector<bool> v3(v1.size()); transform(begin(v1), end(v1), begin(v2), begin(v3), equal_to<int>); transform(begin(v1), end(v1), begin(v2), begin(v3), plus<int>); copy(begin(v3), end(v3), ostream_iterator<int>cout, " "); exempel på en av de aritmetiska standardfunktionsobjektsklasserna plus instansieras för den typ av värden som additionen (+) ska appliceras på copy(begin(v3), end(v3), ostream_iterator<bool>cout, " "); exempel på en av standardfunktionsobjektsklasserna för jämförelse equal_to instansieras för den typ av värden som likhetstestet (==) ska appliceras på