Vad är en mall och vilka är dess egenskaper? Övning 3. En funktionsmall

Vad är en mall och vilka är dess eenskaper? Övnin 3 Daens övnin behandlar två ämnen: ffl mallar (en. templates). En mall kan ses som en avancerad form av makro, eller en avbildninar från listor av typer och konstanter till funktioner och klasser. ffl Gör det möjlit att e en enda typoberoende beskrivnin av en enerell funktionalitet. ffl det standardiserade mallbiblioteket (en. Standard Template Library (STL)). ffl Motverkar copy-paste -prorammerin och underlättar underhåll. Vi kommer att å ienom ett par exempel för varje företeelse. ffl Inen run-time -kostnad och trots det stark typnin. ffl Försvårar debuprocessen och ökar normalt kompilerinstiden. En funktionsmall Vårt första exempel på funktionsmall visar dels runderna i syntaxen och beränsninar i användninen, och dels nåra typer av automatisk konverterin som kan ske vid anrop. #include <alorithm> void printmin ( const U &a, const U &b ) f std ::cout << "Minimum of " << a << " and " << b << " is: " << std ::min ( a, b) << endl ; template <class T> void printvec ( T Λ s, int size ) f for ( int i = 0; i < size ; i++) f std ::cout << Λ(s + i) << "," ; std ::cout << endl ; int xi = 4, yi = 5; float xf = 4.35, yf = 3.79; char xc = a, yc = b ; char ac [] = "hej" ; printmin ( xi, yi ); // qualification printmin ( xf, yf ); // conversion printmin ( xc, yc ); // printmin ( xc, yf ); //!! different types printmin<int>(xi, yc ); // different types // OK, explicit! printvec ( ac, 3); // array > pointer // conversion >./a.out Minimum of 4 and 5 is: 4 Minimum of 4.35 and 3.79 is: 3.79 Minimum of a and b is: a Minimum of 4 and 98 is: 4 h,e,j,

Vad var det som hände? Ännu en funktionsmall Betrakta anropet printmin(xi, yi). 1. Vid anropet undersöker kompilatorn om det finns en template vid namn printmin. Det finns det. 2. Kompilatorn kollar sedan vad första parametern xi har för typ. Eftersom xi är en int så måste mallparametern U vara en int. 3. Eftersom samma mallparameter U används både för första och andra parametern mallen såmåste även yi vara en int, vilket den är. 4. Anropet örs till en konkret instansierin av mallen, som i sin tur har instansierat std::min. void printmin ( const int &a, const int &b ) f std ::cout << "Minimum of " << a << " and " << b << " is: " << std ::min ( a, b) << endl ; Följande exempel är tänkt att visa dels att en mall kan ta en icketypparameter och dels hur man kan välja en instansierin enom att e (delvisa) explicita mallparametrar vid ett anrop. template <int scale, class U, class V> double rectarea ( U lenth, V width ) f return scale Λ lenth Λ width ; int li = 3, wi = 4; float lf = 4.79, wl = 5.63; // partial explicit parameters std ::cout << "RA = "<< rectarea<4>(lf, wi) << endl ; // explicit parameters std ::cout << "RA = "<< rectarea <4, int, float>(li, wl) << endl ; Specialiserin av funktionsmall Följande exempel illustrerar hur en mall kan specialiseras och vad som skiljer specialiserade mallfunktioner från vanlia funktioner. #include <strin> U minimum ( U &a, U &b ) f if ( a < b ) f return a ; else f return b ; typedef char Λ pchar ; // specialization template <> pchar minimum<pchar>(pchar & a, pchar &b ) f if ( strcmp ( a, b ) < 0) f return a ; else f return b ; // function that matches template lon minimum ( lon a, lon b ) f if ( a < b ) f return a ; else f return b ; int xi = 2, yi = 3; lon xl = 5, yl = 7; char Λ xs = "Hejsan" ; char Λ ys = "Hoppsan" ; std ::cout << "min(" << xi << ", " << yi << ")=" << minimum ( xi, yi) << endl ; std ::cout << "min(" << xs << ", " << ys << ")=" << minimum ( xs, ys) << endl ; std ::cout << "min(" << xl << ", " << yi << ")=" << minimum ( xl, yi) << endl ;

En klassmall Låt oss öra en enkel stack med mallar som låter oss använda den för odtyckli typ. class Stack ; class StackNode f friend class Stack<U>; private : StackNode ( U v, StackNode Λ b ) : value ( v ), below ( b ) f StackNode () f StackNode Λ below ; U value ; ; class Stack f Stack () : top ( NULL ) f Stack () f while (!isempty () ) pop (); bool isempty () f return top == NULL ; Stack& put ( U v) f top = new StackNode<U>(v, top ); return Λ this ; U pop () f StackNode<U> Λtmp ; U value ; if (! isempty () ) f tmp = top ; top = top >below ; value = tmp >value ; delete tmp ; return value ; else f std ::cerr << "Error: empty stack!\n" ; exit (1); private : StackNode<U> Λtop ; ; Specialiserin Vår stack funerar dålit med stränar, varför? Låt oss specialisera den så att den funerar som det förväntas. template <> StackNode<char Λ > ::StackNode<char Λ >( char Λ v, StackNode<char Λ> Λb ) : below ( b ) f value = new char [ strlen ( v ) + 1]; strcpy ( value, v ); template <> StackNode<char Λ > :: StackNode<char Λ > () f delete [] value ; Klassmallar med förvalda värden på mallparametrar En skillnad mellan funktionsmallar och klassmallar är att de senare tillåter förvalda värden på mallparametrar, som dessutom kan bero på tidiare mallparametrar! template <class T1 = int, class T2 = T1, int size =10> class DBuffer f DBuffer () f first = new T1 [ size ]; second = new T2 [ size ]; DBuffer () f delete [] first ; delete [] second ; T1 Λ first ; T2 Λ second ; ;

Nyckelordet typename DBuffer<> b1 ; // 2x10 int DBuffer<float> b2 ; // 2x10 float DBuffer<lon, lon, 23> b3 ; // 2x23 lon DBuffer<lon, float, 23> b4 ; // 23 lon, // 23 float Det finns ett tillfälle när det är svårt för kompilatorn att avöra huruvida en rad är en deklaration eller en multiplikation. Då måste man använda nyckelordet typename. class A f class B f // either this...... ; int B ; // or this! ; template <class T> class C f typename T ::B Λ ptr ; // declaration T ::B Λ ptr ; // multiplication ; Kompilerinsprocessen med mallar C++ Standard Library Hör mallar hemma i.h-filer eller i.cpp-filer? I denna kurs placeras all mallkod i.h-filer. ffl Eentlien vore det trevlit med samma uppdelnin som vanlit. Dvs implementationen av en mall borde finnas i en.cpp-fil, och deklarationen borde finnas i en.h-fil. ffl Å andra sidan sker instansierin vid behov.därför måste inte bara deklarationen utan hela mallen finnas tillänli för kompilatorn. En nackdel med detta förfarande är att en instansierin kan upprepas om samma mallparametrar används ifleraolikakällkodsfiler som kompileras separat. Det finns dock flera svar påfråan. Intresserade studenter kan titta på http://cc.nu.or/ onlinedocs/cc-3.3.1/cc/template- Instantiation.html#Template%20Instantiation. Standardbiblioteket tillhandahåller förstås en rad funktioner och trevlia livsförenklande saker för prorammerare och vi år ienom en liten del av detta. Detaljerad information hittar ni i Josuttis bok The C++ Standard Library, eller på webben http://www.si.com/tech/stl/. Allt i standardbiblioteket är definierat i namnutrymmet (namespace) vid namn std, eller undernamnutrymmen till detta. Det betyder att man för att använda nåot ur biblioteket ör följande: 1. Inkluderar lämpli headerfil, tex #include <strin>. 2. Vid användandet skriver std::strin, usin std::strin;, eller använder usin namespace std; för att komma åt funktionaliteten.

auto ptr: Ett första exempel Största delen av standardbiblioteket utörsavthe Standard Template Library (STL). Detta är en flexibel samlin mallklasser och mallfunktioner, men ffl focus lier på effektivitet,ochintepå säkerhet ffl det har flera olika författare, vilket ör biblioteket spretit. Det krävs därför viss förståelse för att använda mer än det mest basala. auto ptr är en typ av intellient pekare. Iden är att auto ptr-objektet ser till att en pekare blir delete:ad när dess destruktor körs. #include <memory> class A f A ( int v ) : value ( v ) f int value ; ; // without auto_ptr void foo () f A Λ ap = new A (4); delete ap ; // with auto_ptr void bar () f auto_ptr<a> ap ( new A (4)); auto ptr: Överförin av äande Varje auto ptr-objektpekarantinen på ettobjekt eller null. Prorammeraren måste även se till att varje objekt pekas på avhöst ett auto ptr-objekt. Vid tilldelnin eller kopierin överförs äandet av en pekare. Använd const-deklarerin för att förhindra tilldelninar och körnin av kopierinskonstruktorn. #include <memory> #include <strin> #include <cstddef> usin namespace std ; class Person f strin Λ name ; strin Λ persnr ; Person ( char Λ na, char Λ no ) ; : name ( new strin ( na )), persnr ( new strin ( no )) f cerr << "Person(char *) for " << Λname << std ::endl ; Person () f cerr << " Person() for " << Λname << std ::endl ; delete name, delete persnr ; const strin prnt ( const auto_ptr<person> &ap ) f if ( ap. et () == NULL ) f return "NULL" ; else f return Λ ( ap >name ); auto_ptr<person> ap1 (

new Person ( "Lars", "801109" )); auto_ptr<person> ap2 ( new Person ( "Olle", "811012" )); cout << "ap1: " << prnt ( ap1 ) << ", ap2: " << prnt ( ap2) << std ::end ap2 = ap1 ; cout << "ap1: " << prnt ( ap1 ) << ", ap2: " << prnt ( ap2) << std ::end auto_ptr<person> ap3 ( ap2 ); cout << "ap2: " << prnt ( ap2 ) << ", ap3: " << prnt ( ap3) << std ::end auto ptr: Medlemsvariabler Ett viktit användninsområde för auto ptr är för att förhindra minnesläckor. I föreående exempel örs en farli konstruktion i detta hänseende. Vilken? Nedan illustrerar vi hur sådana farliheter kan undvikas enkelt med auto ptr. #include <memory> #include <strin> #include <cstddef> usin namespace std ; >./example8 A(char *) for Lars A(char *) for Olle ap1: Lars, ap2: Olle A() for Olle ap1: NULL, ap2: Lars ap2: NULL, ap3: Lars A() for Lars // with auto_ptr members class APPerson f private : const auto_ptr<strin> name ; const auto_ptr<strin> persnr ; APPerson ( char Λ na, char Λ no ) auto ptr: Varninar : name ( new strin ( na )), persnr ( new strin ( no )) f cerr << "APPerson(char *) for " << Λname << std ::endl ; APPerson () f cerr << " APPerson() for " << Λname << std ::endl ; ; APPerson x ( "Stefan", "790506" ); ffl Tyvärr funkar auto ptr ej för arrays. Varför? // What is the semantics of this? void foo () f auto_ptr<char> vec ( new char [ 10]); ffl Flera auto ptr-objekt får inte initieras med samma pekare. Om man ör det så kommer det först destruerade auto ptr-objektet delete:a det emensamt äda objektet. ffl Det finns andra sätt att tillverka smarta pekare som räknar antalet referenser till objekt. Detta kan ses som en beränsad form av skräphanterin. auto ptr skall ej förväxlas med detta.

Standard Template Library (STL) Funktionaliteten i STL är iven som mallar. Detta har fördelen att biblioteket blir extremt flexibelt. Mallarna kan sammanfattas enlit följande: ffl Containers Seqence containers Λ vector - Dynamisk array. Snabb tilldelnin med index, lånsam raderin och insättnin på odtyckli plats. Växer automatiskt på slutändan. Λ deque - dubbelriktad kö. Liknar vector fast växer i båda ändarna. Λ list - dubbellänkad lista. Snabb insättnin och raderin på odtyckli plats, lånsam åtkomst med index, men lätt att traversera. Λ strin - Dynamiska stränar med extra fluff (tänk på Java-klassen Strin). Är eentlien inte en container, men kan ses som en sådan. Associative containers Λ set/multiset - balanserat binärt träd av elementen. Inen direkt förändrin av elementen (inen direkttillån) och iteratorer returnerar const referenser. Varför? Λ map/multimap - balanserat binärt träd av par sorterat påförsta elementet i varje par. I övrit unefär som set/multiset. Container adapters and special classes Λ queue - klassisk FIFO. Stoppa in element och plocka ut dem i omvänd ordnin. Λ stack - klassisk LIFO. Stoppa in element och plocka ut dem i samma ordnin. Λ priority queue - ordnad kö. Stoppa in element och plocka ut dem i prioritetsordnin. Λ bitset - kompakt hanterin av stora mänder bitflaor. ffl Iterators Bidirectional iterator kan flyttas både framåt med ++ och bakåt med --. Finns hos list,set/multiset och map/multimap. Random access iterator har en sorts pekararitmetik förutom ++ och --. Finns hos vector, deque och strin. Iterator adapters tillför specialfunktionalitet, som reverse iterators, insert iterators, stream iterators. ffl Alorithms Modifyin alorithms (funkar ej med associativa containers) tex transform förändrar varje element på nåot sätt. Removin alorithms (funkar ej med associativa containers) tex unique tar bort identiska element när de lier efter varandra. Mutatin alorithms (funkar ej med associativa containers) tex reverse byter ordnin på elementen. Sortin alorithms tex sort sorterar elementen med quicksort. Förutom detta finns det en del hjälpklasser av olika sla. Nonmodifyin alorithms tex find hittar första förekomsten av ett värde.

Exempel: deque #include <deque> #include <alorithm> usin namespace std ; deque<int> c ; c. assin (2, 0); c. erase ( b ); b += 2; c. insert ( b, 111); b += 2; c. erase ( b ); for ( int i = 1; i < 5; i++) f c. push_back ( i ); c. push_front ( i Λ 10); copy ( c. bein (), c. end (), ostream_iterator<int>(cout, ", " )); cout << std ::endl ; deque<int >::iterator b = c. bein (); c. pop_back (); c. pop_front (); copy ( c. bein (), c. end (), ostream_iterator<int>(cout, ", " )); cout << std ::endl ; b += 3; Exempel: list, reverse, transform #include <list> #include <alorithm> #include <strin> #include <cctype> #include <functional> usin namespace std ; void pl ( list<strin> &l ) f copy ( l. bein (), l. end (), ostream_iterator<strin>(cout, " ")); cout << std ::endl ; class strintoupper : public unary_function<strin, strin> f strin operator () (strin s ) const f transform ( s. bein (), s. end (), s. bein (), toupper ); ; return s ; list<strin> l ; l. push_back ( "small" ); l. push_back ( "letters" ); l. push_back ( "is" ); l. push_back ( "nice" ); pl ( l ); reverse ( l. bein (), l. end ()); pl ( l ); transform ( l. bein (), l. end (), l. bein (), strintoupper ()); l. pop_back (); l. push_back ( "LARGE" ); l. pop_front (); l. push_front ( "NICER" ); reverse ( l. bein (), l. end ()); pl ( l );

Exempel: map, iterator och for-loopar #include <map> #include <strin> usin namespace std ; typedef map<strin, strin> ssmap ; ssmap l ; l [ "lasse" ] = "Lars Johnsson" ; l [ "eva" ] = "Eva Carlsson" ; l [ "steffo" ] = "Stefan Persson" ; l [ "soffan" ] = "Sofie Nilsson" ; // note that we use!= and ++b for ( ssmap :: const_iterator b = l. bein (); b!= l. end (); ++b ) f cout << b >first << ", " << b >second << std ::endl ;