operator T*() const throw(); // Konvertering till vanlig pekare Jozef Swiatycki DSV Implementering av vissa medlemmar i Ptr-mallen

Transkript

1 Mall för pekarklass för polymorfa objekt class null_pointer; // Undantagsklass, visas senare, en liten förbättring template <class T> class Ptr{ T *ptr; int *count; template<class U> friend class Ptr; Ptr(T *p, int *c); // Privat konstruktor, används vid konvertering public: Ptr(T *p=0) throw(std::bad_alloc); Ptr(const Ptr& other) throw(); ~Ptr() throw(); const Ptr& operator=(const Ptr& other) throw(); T& operator*() throw(null_pointer); T* operator->() throw(null_pointer); bool operator==(const Ptr& other) const throw(); bool operator!=(const Ptr& other) const throw(); operator T*() const throw(); // Konvertering till vanlig pekare ; template <class OTHERTYPE> // Konvertering till Ptr för annan operator Ptr<OTHERTYPE>(); // typ (basklasstyp) Bild 210 Implementering av vissa medlemmar i Ptr-mallen template <class TYP> template <class OTHERTYPE> Ptr<TYP>::operator Ptr<OTHERTYPE>(){ return Ptr<OTHERTYPE>(ptr, count); template <class T> Ptr<T>::operator T*() const throw(){ return ptr; template <class T> Ptr<T>::Ptr(T *p) throw(std::bad_alloc): ptr(p), count(ptr?new int(1):0){ Se OH för implementering av andra medlemmar Bild 211 1

2 Implementering av vissa medlemmar i Ptr-mallen, forts. template <class T> T& Ptr<T>::operator*() throw(null_pointer){ if (ptr == 0) throw null_pointer(); return *ptr; template <class T> T* Ptr<T>::operator->() throw(null_pointer){ if (ptr == 0) throw null_pointer(); return ptr; Kräver #include <stdexcept> class null_pointer : public std::runtime_error{ public: null_pointer() : runtime_error("null_pointer"){ null_pointer(std::string msg): runtime_error("null_pointer" + msg){ ; Bild 212 Kommentarer till Ptr-mallen En bra och generell mall för referensräknande pekarklasser är svår att utforma (vilket är anledningen till att någon sådan inte finns i standardbiblioteket). Som någon har sagt: smarta pekare kan vara riktigt smarta med de kan inte vara riktiga pekare. Det kan uppkomma problem med användning av den föreslagna Ptr-mallen som jag inte inser nu, jag kommer i så fall att meddela problemen i FC (och förhoppningsvis en lösning). Ett problem som jag ser nu är att dynamic_cast inte fungerar på dessa pekarklasser, dynamic_cast vill ju ha en vanlig pekare att testa det utpekade objektet med. Detta kan lösas på många sätt men inget som är transparent för användaren. Jag återkommer i FC med tips om en lösning. Bild 213 2

3 En polymorfisk klass för användning med Ptr class Bird : public Animal{ public: static Ptr<Bird> create(string name, double ws); double get_wingspan() const; protected: Bird(string name, double ws); private: double wingspan; Bird(const Bird& other); void operator=(const Bird& other); Skall inte implementeras! void operator&(); void operator&() const; ; Ptr<Bird> Bird::create(string name, double ws){ return Ptr<Bird>(new Bird(name, ws)); Bird::Bird(string name, double ws): Animal(name), wingspan(ws) { double Bird::get_wingspan() const { return wingspan; Bild 214 Introduktion till standardbiblioteket Standardbiblioteket består av följande delar: behållarklasser med stödbibliotek algoritmbiblioteket med stödbibliotek strängbiblioteket I/O-biblioteket stöd för undantagshantering och standardundantag stöd för lokal anpassning (sorteringsordning för tecken mm) matematiska och numeriska faciliteter andra stödfunktioner (numeriska gränser, dynamisk minneshantering, Run-Time-Type-Information-stöd mm) Tillgång till dessa bibliotek fås genom #include på motsvarande headerfil. Till dessa tillkommer C:s headerfiler, som också tillhör C++-standardbibliotek. C:s headerfiler skall finnas under två namn på formen cx resp. X.h, t.ex. #include <cstring> deklarerar C:s str- och mem-funktioner i namnrymden std medan #include <string.h> definierar dessa namn i den globala namnrymden. Bild 215 3

4 string-klassen Typen string är egentligen en instansiering av mallen basic_string<> vars parametrar är teckentypen, dess egenskaper ( traits ) och minneshantering: namespace std{ template <class chart = char, // Teckentypen class traits = char_traits<chart>, // Hur tecken jämförs class allocator = allocator<chart> > // Hur man allokerar class basic_string{... ; typedef basic_string<char> string; Se OH för egendefinierad strängtyp. Jag förenklar framställningen i fortsättningen genom att använda string som om den var en klass. Bild 216 string string har samma typer och medlemsfunktioner som vector<>, detta för att man skall kunna använda string som argument till de generiska algoritmerna, t.ex. void funk(char c){ cout << c; int main(){ string str("jozef"); for_each(str.begin(), str.end(), funk); Vid normal stränghantering anger man positioner inom en sträng med index och längd: string namn = Jozef Swiatycki ; string enamn = namn.substr(6, 9); // startposition, längd Vid sådana operationer måste index-värdet falla inom strängen (annars genereras undantaget std::out_of_range), längdangivelsen kan dock vara större än det återstående antalet tecken i strängen och har då betydelsen resten av strängen. Det finns en statisk medlemskonstant med namnet npos som har ett värde som är större än vad en stränglängd kan vara och som kan användas för att ange resten av strängen. Den returneras också av sökfunktioner när dessa inte hittar det sökta värdet: string resten = namn.substr(6, string::npos); string::size_type pos = namn.find( ); if (pos == string::npos) cout << Inget mellanslag! ; Obs att string::size_type är en unsigned typ, hade pos deklarerats som en int skulle kompilatorn varna för jämförelse av signed med unsigned. Bild 217 4

5 Varianter av medlemsfunktioner i string De flesta medlemsfunktioner i string finns i många överlagrade varianter för olika typer av argument: ett andra strängargument skall kunna vara string, char * eller char positioner skall kunna anges med index och längd eller med iteratorer om man vill operera på hela strängar skall man inte behöva ange positioner Exempel: void insert(iterator p, size_type n, char c); template<class InputIterator> void insert(iterator p, InputIterator beg, Inputiterator end); string& insert(size_type pos1, const string& str); string& insert(size_type pos1, const string& str, size_type pos2, size_type n); string& insert(size_type pos, const char* s, size_type n); string& insert(size_type pos, const char* s); string& insert(size_type pos, size_type n, char c); iterator insert(iterator p, char c = char()); Exempel på användning: string knamn= Karl Gustav ; string nr= XIV XV XVI XVII ; knamn.insert(5, nr, 7, 4); //pos i egen sträng, från-sträng, pos i från-sträng, antal Bild 218 Operationer på string insert - stoppar in annan sträng eller tecken på angiven position namn.insert(6, Zbigniew ); str.insert(eve.wherex-getx(), 1, char(eve.what)); erase - tar bort tecken från angiven position (angivet antal tecken): namn.erase(6, 9); str.erase(eve.wherex-getx()); replace - ersätter angiven del av strängen med en annan sträng: namn.replace(6, 9, Bo ); append - lägger till den andra strängen eller tecknet eller ett antal tecken: str.append(char(eve.what)); namn.append( den Trötte ); operator+= push_back operator+ andra sätt att uttrycka append på - konkatenerar två strängar och returnerar resultatsträngen substr - returnerar en kopia av en delsträng: string mellan = namn.substr(6, 8); Bild 219 5

6 Sökning i strängar Det finns många varianter av sökfunktioner: det sökta mönstret kan uttryckas som string, char * eller char; sökningen kan göras framlänges eller baklänges och kan göras i hela strängen eller begränsas till en del av den. Index för den hittade förekomsten returneras (eller string::npos om det sökta inte hittades) find - letar efter första förekomsten av angivet tecken eller sträng i angiven portion av strängen: string::size_type wstart = line.find( ); string::size_type wend = line.find(, wstart+1); string word = line.substr(wstart+1, wend-wstart); rfind - som find men letar efter sista förekomster (söker baklänges) find_first_of find_last_of find_first_not_of find_last_not_of strängargumentet till dessa betraktas som en mängd av teckenvärden där man letar efter den första (sista) förekomsten const string letters= abcd...zåäöabcd...zåäö ; string::size_type wstart=line.find_first_of(letters); string::size_type wend=line.find_first_not_of(letters, wstart); string word = line.substr(wstart, wend-wstart); Bild 220 Gränssnitt mot C-strängar I vissa fall kan man vilja använda C:s stränghantering på string-värden. T.ex. kan sscanf() vara bekvämt att använda i vissa situationer (C++ har motsvarande men mer begränsad funktionalitet i strängströmmar). För detta finns följande medlemsfunktioner i klassen string: c_str()- returnerar en pekare till en C-sträng som är allokerad lokalt i stringobjektet - man kan inte räkna med att den finns kvar och har korrekt värde efter nästa operation på string-objektet data() - som c_str() men utan det extra null-tecknet på slutet copy() - tar en char * som argument (skall peka ut ett allokerat och tillräckligt stort utrymme) och kopierar tecken till detta utrymme (utan null-tecken) Exempel: string line = Klockan är 14:15 ; int tim, min; sscanf(line.c_str(), Klockan är %d:%d, &tim, &min); Bild 221 6

7 Orientering om ström-biblioteket Ström-biblioteket utgör ett utbyggbart ramverk för att lätt kunna omfatta hantering av olika teckenkodningar, nya externa medier, regionala anpassningar o.s.v. Strömbiblioteket kan sägas bestå av två nivåer: strömklasser för formattering och parsing strömbuffertklasser för buffring, kodkonvertering och fysisk i/o program formatteringsnivån - IOStream-klasser transportnivån - Streambuffer-klasser externa medier Till detta tillkommer möjlighet att i strömklasser installera egna data och call-back - funktioner. Dessutom är alla dessa klasser mallar som instansieras med typen av tecken de skall hantera och teckentypens egenskaper. Här orienteras endast om grundläggande användning av strömklasserna instansierade för teckentypen char. Strömmar kan även ses som sekvenser av element (tecken) och det finns strömiteratorer i standardbiblioteket, dessa visas senare vid avhandling av iteratorer. Bild 222 stream-klasser basic_streambuf<> streambuf ios_base basic_ios<> ios basic_filebuf<> filebuf basic_stringbuf<> stringbuf basic_ostream<> ostream basic_istream<> istream basic_ofstream<> ofstream basic_ostringstream<> ostringstream ostrstream basic_fstream<> fstream basic_iostream<> iostream basic_ifstream<> ifstream basic_istringstream<> istringstream istrstream basic_stringstream<> stringstream Bild 223 7

8 Strömstatus class ios { public: typedef... iostate; static const iostate goodbit,eofbit,failbit,badbit; bool good() const; // Allt ok bool eof() const; // eof har inträffat bool fail() const; // Icke-fatalt fel har inträffat bool bad() const; // Fatalt fel har inträffat iostate rdstate() const; void clear(iostate f=goodbit); void setstate(iostate f); operator void *() const; // Icke-null om good()==true bool operator!() const; // true om fail()==true class failure; void exceptions(iostate forwhat); typedef... int_type; typedef... streamsize;... Bild 224 Output Medlemmar hos ostream: ostream& put(char c); ostream& write(const char *ptr, streamsize n); Överlagringar av operator<<: ostream& operator<<(ostream& os, int i); ostream& operator<<(ostream& os, double d); osv. Komplettering för en egendefinierad typ: class Rat{ int num, denum; friend ostream& operator<<(ostream& os, const Rat& r);... ; ostream& operator<<(ostream& os, const Rat& r){ return os << r.num << / << r.denum; Bild 225 8

9 Input Medlemmar hos istream: int_type get(); istream& get(char& c); istream& get(char *ptr, streamsize n, char delim= \n ); istream& getline(char *p, streamsize n, char delim= \n ); istream& ignore(streamsize n=1, int_type del=eof); istream& read(char *ptr, streamsize n); istream& putback(char c); istream& unget(); int_type peek(); Överlagringar av operator>>: ostream& operator>>(ostream& os, int& i); ostream& operator>>(ostream& os, double& d); osv. operator>> kan även överlagras för egnendefinierade typer (se nästa bild) I <string> definieras även istream& getline(istream& is, string& str); istream& getline(istream& is, string& str, char delim); Bild 226 Exempel: operator>> för Rational istream& operator>>(istream& is, Rational& r){ int n, d; if (is >> n) { char sep; is >> sep >> d; if (sep!= '/') is.clear(ios_base::badbit); if (is) r=rational(n, d); return is; Exempel på användning: int main(){ Rational r1; cout << "r1 > "; while (!(cin >> r1)){ cin.clear(); cin.ignore(256, '\n'); cout << "Fel\n"; Bild 227 9

10 Manipulatorer T.ex.: cout << setw(3) << setfill( - ) << 5; ger utskriften --5 #include <iomanip> setw(int w) setfill(char c) setprecision(int p) setbase(int b) endl flush // Nästa utskrift med bredden w // Utfyllnad med c // p siffrors noggranhet // Heltal skrivs ut i basen b // Lägg till \n och skriv ut // Skriv ut Bild 228 Filströmmar Filströmmar definieras i headerfilen <fstream> Klasserna heter ifstream, ofstream resp fstream. Medlemsfunktionerna är: void open(const char *, ios_base::opemode=...); bool is_open(), void close(); Exempel: fstream fil; fil.open( prog.cpp ); // Argumentet är en const char * eller fil.open( prog.cpp, ios_base::in ios_base::out); Flaggor för angivande av mode kombineras alltså med och kan vara: ios_base::in öppna för läsning ios_base::out öppna för skrivning ios_base::ate positionera vid filslutet ios_base::app öppna för tillägg på slutet ios_base::trunc ta bort innehållet ios_base::binary binärfil Om mode inte anges öppnas filen i default-mode (ifstream i in-mode o.s.v.) Det finns också konstruktorer som tar samma argument som open och öppnar filen ifstream fil( minfil.txt ); Destruktorer stänger öppna filer. Bild

11 Strängströmmar Strängströmmar definieras i headerfilen <sstream> ostringstream: Man kan skriva till en ostringstream som om den vore en ostream: ostringstream ostr; int i=133; ostr << Summa = << i; Man kan få en kopia av den resulterande strängen genom medlemsfunktionen str(): string s=ostr.str(); istringstream: Man kan läsa från en istringstream som om den vore en istream. Den kan kopplas till en sträng i konstruktorn eller genom att få en ny sträng genom anrop av medlemsfunktionen str(string): string line= 9:41 ; int h, m; char c; istringstream istr(line); istr >> h >> c >> m; istr.str( 10:05 ); istr >> h >> c >> m; stringstream: Kan användas för att både skriva till och läsa från (även omväxlande), givetvis kan man endast läsa vad som redan finns i strängen. Bild