Standard Template biblioteket, eller STL, är ett C++ bibliotek innehållande: STL tillhandahåller många grundläggande algoritmer och datastrukturer:

Transkript

1 2 B CD D D D D L / Begreppen koncept modeller av koncept Hur iteratorer fungerar Vad man ska tänka på vid lagring av pekare till objekt i SL Vilka olika sätt finns det att lagra subklasser i SL Standard emplate biblioteket eller SL ett C bibliotek innehållande SL tillhandahåller många grundläggande algoritmer datastrukturer ( ( klasser byggblock för att skapa underlätta konstruktionen av OOprogram klasser har som uppgift att lagra andra objekt SL innehåller bla klasserna lla klasser template kan instansieras för att lagra alla typer av objekt lla containrar expanderar självständigt ( Biblioteket består nästan helt av parameteriserade komponenter > < = 89 > < = 89 B H B int main( v( //vektor med tre element B 9@ v[] = 7 v[] = v[] v[2] = v[] v[] //v[]=7 v[]= v[2]=7 s spush(8 spush(7 assert(ssize( == 2 assert(stop( == 7 spop( assert(stop( == 8 spop( assert(sempty( B 9@ H B G I J SL innehåller en stor samling som kan manipulera datan som lagras i containrarna x med algoritmen av elementen i en vektor vector<int> v( (vbegin( vend( //v[]=7 v[]= v[2]=7 kan man byta om ordningen Det finns två viktiga punkter gällande anropet till L Q O S ( liksom andra SLalgoritmer ej beroende av SLcontainerklasserna öljden blir att kan användas inte uteslutande på vektorer utan även för att byta ordningen på element i en lista eller i en vanlig C array double [] = 2 7 ( for(int i = i < i cout << [ << i << ] = << [i] xemplet använder ett omfång första argumentet en pekare till början av arrayen det andra arg pekar på ett element efter slutet i arrayen [

2 L L L P Implementationen för SL s operation rgumentet till Vad argumentet till n den anropas med avseende på vektorklassen Vad tar returnerar L ( Svaret att argumenten till i grunden utgörs av för typ av argument vad ( som lassen deklarerar bla den nästlade typen (inre klass ypen som returneras från funktionerna ( L ( Iteratorer mekanism som leder till ett oberoende mellan algoritmerna containrarna lgoritmerna templates instansieras utifrån typen på iteratorerna template <class InputIterator class > InputIterator (InputIterator first InputIterator last const value while(first = last first = value first return first tar tre argument två iteratorer som definerar mängden ett vde att finna inom denna mängd Operationen undersöker varje iterator i spannet [first last stannar antingen då den hittar en iterator som pekar på eller om den når slutet i mängden Om ett anrop till sker med argument av typen skapas en mall enligt nedan int find(int first int last const int value while(first = last first = value first return first n viktig del n det gäller templateoperationer rent generellt vilka typer som den kan hantera helt korrekt x klart att formella parameter Lika klart det att använder sig av uttrycket definierat för ett objekt av typen kan substituera s inte kan det vilket inte Operationen ställer ett antal på typerna att den kan instansieras av typer som uppfyller dessa krav Varje typ som substituerar tillhandahålla specifika operationer måste J inte den enda SLalgoritmen som har sådana krav Dessa samlingar av krav så pass vitala att de fått ett namn Ovanstående koncept kallas ypen sägs anpassas till ett koncept eller att den en om den uppfyller dessa krav en modell av dför att tillhandahåller alla operationer som finns specificerade i krav oncept en del av språket C det finns inget sätt att deklarera ett koncept i ett program eller att en typ en modell av ett koncept Dock koncept en viktig del av SL nvändning av koncept gör det möjligt att skriva program som separerar interfacet från implementationen örfattaren till behöver endast betrakta interfacet specificerat av konceptet istället för implementationen för varje typ som anpassat efter konceptet man använder sig av behöver man endast säkerställa att argumenten som används en modell av ett vagt koncept innebande att det implicerar ett fåtal krav odeller av behöver endast stödja en submängd av pekararitmetiken (möjligheten att öka en genom prefix postfixoperatorn Detta tillräckligt för men många andra algoritmer kräver att argumenten uppfyller ytterligare krav kräver förutom finns överlagrad ( onceptet som kräver kallas likt men alltså belagt med ytterligare krav även att yperna som modeller av en delmängd av typerna som modeller av modell av båda koncepten konceptet

3 ( ( 2 ( 2 örhållandet mellan beskrivs som att av en örfining av koncept mycket likt arv i C men uttrycker inte samma sak då förfining appliceras på koncept inte på typer otalt finns sex iteratorkoncept de flesta utgör förfiningar av varandra (d relaterad till de andra men inte del av förfiningshierarkin J SL inkluderar flera koncept onceptet beskriver typer som har definierat = operatorn copykonstruktorn I stort sett alla klasser i SL modeller av nästan alla algoritmer kräver att deras argument en modell av klasserna liksom iteratorerna också organiserade enligt en hierarki av koncept lla containrar modeller av konceptet d mer förfinade koncept som existerar SL inkluderar även lågnivå mekanismer för att allokera avallokera minne kallas detta koncept Plus mycket mer J Det finns ett antal elementa containers i SL som beter sig på liknande sätt Dessa tre modeller av har bla en funktion sätta in element i sekvensen 7 L 7 har ytterligare funktioner (modeller av => som används för att ör att accessa kan man även använda indexoperatorn [] på objekten (modeller av orts krav ex void f( // < ( // klass to be saved class X // create new list list<x> xlist // < (2 // now populate the list with lots of X s X x( xlistpush_back(x // < ( // now replace the st element with something else X x2 xlistfront( = x2 // < ( // remove the element with value x X x xlistremove(x // < ( // now sort the list xlistsort( // < ( // < (7 ytt scope funktion f utomatiska objekt destrueras n de lämnar scopet vid (7 2 Skapar ny list<x> från parameteriserad typ list<> Vid denna punkt skapar konstruktorn för list en ny list_node som har en medlem som håller en kopia av list_node utseende template <class > struct list_node void_pointer next void_pointer prev data ör att skapa list_node måste datamedlemmen ha en H lagras ett objekt x av typen X i slutet av list etoden push_back anropar följande operation / 2 2 insert(begin( x insert kräver en lagras i noden 7/ 2 8 ( 2 ( ( för att skapa en kopia som ska H byts första elementet i list ut mot ett nytt objekt x2 front metoden returnerar en referens (lvalue till datamedlemmen till första elementet i listan tilldelas ett nytt vde x2 Denna operation kräver tilldelningsoperator (operator= 9/ 2 / ( < H tas element bort om det finns något i listan som lika med x oden för listans operation template <class > void list<>remove(const value iterator first = begin( iterator last = end( while (first = last iterator next = first next if (first == value // < (a erase(first first = next I steg (a krävs det att jämförelseoperatorn (operator== definierad för att detta ska < < 2 C B / ( D u sorteras listan unktionen sort använder sig av en funktion merge som implementerar en algorithm som kräver att mindreänoperatorn finns definierad steg (a nedan template <class > void list<>merge(list<> x iterator first = begin( iterator last = end( iterator first2 = xbegin( iterator last2 = xend( while (first = last first2 = last2 if (first2 < first // < (a iterator next = first2 transfer(first first2 next first2 = next else first if (first2 = last2 transfer(last first2 last2 length = xlength xlength=

4 P 8 8 B 2 / C 2 template <class > void list<>sort( if (size( < 2 return list<> carry list<> counter[] int fill = while (empty( carrysplice(carrybegin( this begin( int i = while(i < fill counter[i]empty( counter[i]merge(carry carryswap(counter[i] carryswap(counter[i] if (i == fill fill while(fill merge(counter[fill] / 2 / ( D 7 H går list objekt utanför scopet automatiskt destruerat av C runtimesystem Destruktorn för list anropar i sin tur destruktorn för alla elementen som finns i listan vilket kräver att destruktorn defineras / 2 ( ( ( xisterar iteratorer som inte associerade med containrar men som kan användas för att skriva ut dem (modeller av list<int> L Lpush_back( Lpush_front( Linsert(Lbegin( 2 copy(lbegin(lend( ostream_iterator<int>(cout // ger 2 unktionen tar tre argument template <class InputIterator class OutputIterator> OutputIterator (InputIterator first InputIterator last OutputIterator result kopierar element från [first last till [result result (last first Den utför tilldelning av result = first (result = (first osv ör varje heltal n från till last first utför copy tilldelningen (result n = (first n J SLs containrar anpassade för att lagra objekt inte pekare Bör ej använda SLcontainrar i ett program som lagrar pekare nledningen destruktorn kommer inte att anropas för dessa objekt Detta görs i normala fall då containern håller objekten via vde tt lagra pekare i containrar kan således leda till minnesläckor pekare ptr all d man faktiskt vill spara pekare till objekt då objekten utgör subklasser på olika nivåer

5 n lösning för att slippa minnesläckor att lagra sk klasser i sin container klassen får i sin tur innehålla en pekare till objektet man vill lagra Det uppstår problem då flera containrar lagrar samma objekt genom att de pekar på objektet örhindra minnesläckor containern skapas på stacken programmet hoppar utanför ett scope programmeraren måste tillhandahålla en egen avallokeringsfunktion klassen måste då förses med en referensräknare n alternativ lösning att skapa en kopia av objektet SLcontainrar kopierar avallokerar i detta fall endast minnesutrymmet som krävs för att lagra pekarna inte objekten öljande funktioner kan dock skapas för att råda bot på detta ett element tas bort eller om hela containern destrueras ansvarar containern för avallokeringen av klassen Sker i copykonstruktorn i klassen klassen i sin tur avallokerar objektet (genom pekaren på ett korrekt sätt x Vector template <class orwarditerator> void (orwarditerator first orwarditerator last while (first = last delete first x ap template <class orwarditerator> void (orwarditerator first orwarditerator last while (first = last delete (firstsecond ap<int Someype> mymap_ // // populate my map with new d Someype s // map_delete(mymap_begin( mymap_end( x include <vector> include <iostream> include <conio> using namespace std class Shape virtual void draw( = virtual ~Shape( class Circle public Shape void draw( cout << Circledraw\n ~Circle( cout << ~Circle\n class riangle public Shape void draw( cout << riangledraw\n ~riangle( cout << ~riangle\n class Square public Shape void draw( cout << Squaredraw\n ~Square( cout << ~Square\n typedef vector<shape> typedef iterator Iter void main( shapes shapespush_back(new Circle shapespush_back(new Square shapespush_back(new riangle for(iter i = shapesbegin(i = shapesend( i (i>draw( // Sometime later sequence_delete(shapesbegin(shapesend(