std::basic_string En oversikt over C++ Standard bibliotekets streng-klasse

Oversikt Definisjonen av strengen er en del av C++ standarden, og altså endel sproget C++. wstring, string, og tstring er alle bare instansieringer av templaten basic_string, som finnes i C++ headeren basic_string er designet for å kunne støtte strengmanipulering templates gjør strengen veldig utvidbar.

C++ og std::basic:string Standarden bestemmer hvilke funksjoner strengen skal ha, og også hvor effektive disse skal være.

Header som inkluderer basic_string basic_string har ca. 40 funksjoner (klassen er egentlig definert i headeren ) Før å kunne se nærmere på strengen, må vi finne en oppdeling av funksjoner Mange funksjoner er overloadede varianter. Disse benytter seg av konseptet operand sequence.

Operand Sequence En operand sequence er funksjons- argumenter som representerer en streng Noen eksempler på en operand sequence for basic_string : –’c’ -- en streng med lengde en og innhold ”c” –4, ’c’ -- ”cccc” –”string” -- som forventet: en streng ”string” –”string”, 4 -- strengen ”stri” –string(”string”) -- strengen ”string” –string(”string”), 2, 1 -- strengen ”r” –to pekere -- strengen mellom dem (iterator-range)

Operand Sequence - Eksempel Funksjonen ”append” er et eksempel på en funksjon som er overloaded med (nesten) alle variantene av en operand sequence: basic_string& append(size_type n, E c); basic_string& append(const E *s, size_type n); basic_string& append(const E *s); basic_string& append(const basic_string& str); basic_string& append(const basic_string& str, size_type pos, size_type n); basic_string& append(const_iterator first, const_iterator last);

npos - ”ingenting” For funksjoner som angir lengde eller posisjon i en streng, brukes den ”magiske verdien” npos til å angi en posisjon utenfor strengen. For VC++ implementasjonen av C++ standarden brukes verdien -1.

Funksjonsoversikt triviell manipulering : append, assign, insert, erase triviell informasjon : at/[], compare, size, capacity, c_str search/replace: find*, replace STL funksjoner: (r)begin, (r)end, insert (STL variant), erase (STL variant)

Triviell Manipulering basic_string& assign(operand sequence) basic_string& append(operand sequence) basic_string& insert(size_type p0, operand sequence) basic_string& erase(size_type p0 = 0, size_type n = npos) operator += er definert vha. append, og operator= er definer vha. assign.

Eksempelprogram int main(int argc, char* argv[]) { using namespace std; string str("Hello world"); cout << ":" << str << ":" << endl; str.append(5, '+'); cout << ":" << str << ":" << endl; str.assign("goodbye world"); cout << ":" << str << ":" << endl; str.insert(8, "hello "); cout << ":" << str << ":" << endl; str.erase(0, 8); cout << ":" << str << ":" << endl; return 0; } Resultat: :Hello world: :Hello world+++++: :goodbye world: :goodbye hello world: :hello world:

Informasjonsfunksjoner [const_]reference at(size_type pos) (const]; [const_]reference operator[](size_type pos) [const]; size_type length() const; size_type size() const; size_type capacity() const; bool empty() const; int compare(operand sequence) const; int compare(size_type p0, size_type n0, operand sequence);

Length, size og capacity size og length er to navn for samme funksjon capacity angir hvor mange characters som kan legges til på en streng før man må reallokere minnet.

Find og replace - find size_type find(operand sequence, size_type pos = 0) const size_type rfind(operand sequence,size_type pos = npos) const size_type find_first_of(operand sequence, size_type pos = 0) const size_type find_last_of(operand sequence, size_type pos = npos) const size_type find_first_not_of(operand sequence, size_type pos = 0) const size_type find_last_not_of(operand sequence, size_type pos = npos) const

Find - litt mer om find Det er totalt 6 familier av søkefunksjoner Søkeretning: Forover/bakover Søk etter: Hele argumentet/en character som eksisterer i argumentet/en character som ikke eksisterer i argumentet. Argumentet pos brukes til å angi hvor søket skal starte. Dette brukes for å forsette på et søk. Find bruker npos til å bety slutten av strengen.

Find og replace - replace basic_string& replace(size_type p0, size_type n0, operand sequence) Denne funksjonen fungerer godt sammen med find. basic_string& replace(iterator first0, iterator last0, operand sequence) Denne funksjonen er designet for å virke sammen med STL.

Find og replace - eksempel int main(int argc, char* argv[]) { using namespace std; string const strOriginal( "the rain in spain falls " "mainly on the plain"); string str(strOriginal); cout << ":" << str << ":" << endl; string::size_type n = str.find("ain"); cout << n << ":" << str.substr(n) << ":" << endl; str.replace(n, 3, "+"); cout << ":" << str << ":" << endl; str.assign(strOriginal); n = 0; do { n = str.find("ain”, n); if ( n == str.npos ) break; str.replace(n, 3, "+"); } while ( true ); cout << ":" << str << ":" << endl; return 0; } Resultat: :the rain in spain falls mainly on the plain: 5:ain in spain falls mainly on the plain: :the r+ in spain falls mainly on the plain: :the r+ in sp+ falls m+ly on the pl+:

Find og replace - muligheter Find og replace funksjonene i strengklassen gir ganske mye fleksibilitet i å manipulere strenger. Basert på dette eksempelet, kan det tenkes å lage en substring klasse, som kunne manipulerer deler av en streng (se Stroustrup). Det er imidlertid lett å glemme at dersom man bruker replace til å endre størrelsen på en funksjon, vil hele resten av strengen flyttet, og muligens reallokert (det er ikke en ”rope”).

Mer effektiv variant av find/replace int main(int argc, char* argv[]) { using namespace std; string str( "the rain in spain falls " "mainly on the plain"); string newstring; newstring.reserve(str.length()); string::size_type nOld = 0; string::size_type n = 0; do { n = str.find("ain", n); newstring.append(str, nOld, n-nOld); if ( n == str.npos ) break; newstring.append("+"); n += 3; nOld = n; } while ( true ); cout << ":" << newstring << ":" << endl; return 0; }

STL Kompatibilitet Funksjonene begin, end, rbegin og rend er standard funksjoner for ”random access containers”. Insert, erase, og replace har varianter som tar iteratorer. Ved å bruke disse funksjonene kan en basic_string behandles som f.eks. en vector.

Videre Temaer: Character traits: En måte å styre oppførselen til strengen på. Strenger og formattering: Formattering er utenfor scopet til en streng. Derfor har C++ standarden valgt å la basic_stringstream ta seg av dette. Strenger og C: basic_string har ikke en operator char const* som noen andre strenger. Dette er et bevisst valg. Istedet må funksjonen c_str brukes. Strenger og C 2: Hvordan bruke en streng som buffer for lesing?

Videre Temaer 2: Basic_string og ytelse Store strenger og ytelse Allocator: En måte å bestemme hvor strengen henter minne fra.

Character traits struct char_traits { typedef E char_type; typedef T1 int_type; typedef T2 pos_type; typedef T3 off_type; typedef T4 state_type; static void assign(E& x, const E& y); static E *assign(E *x, size_t n, const E& y); static bool eq(const E& x, const E& y); static bool lt(const E& x, const E& y); static int compare(const E *x, const E *y, size_t n); static size_t length(const E *x); static E *copy(E *x, const E *y, size_t n); static E *move(E *x, const E *y, size_t n); static const E *find(const E *x, size_t n, const E& y); static E to_char_type(const int_type& ch); static int_type to_int_type(const E& c); static bool eq_int_type(const int_type& ch1, const int_type& ch2); static int_type eof(); static int_type not_eof(const int_type& ch); };

Case Insensitive String Et fint eksempel på character traits er designet av en case-insensitive streng (fra H. Sutter’s GotW). struct ci_char_traits : public char_traits { static bool eq( char c1, char c2 ) { return toupper(c1) == toupper(c2); } static bool ne( char c1, char c2 ) { return toupper(c1) != toupper(c2); } static bool lt( char c1, char c2 ) { return toupper(c1) < toupper(c2); } static int compare( const char* s1, const char* s2, size_t n ) { return memicmp( s1, s2, n ); } static const char* find( const char* s, int n, char a ) { while( n-- > 0 && toupper(*s) != toupper(a) ) ++s; return s; } }; typedef std::basic_string ci_string;

Eksempel på problem med cast- operatorer Denne koden kompilerer uten advarsel i VC++ Det er et litt søkt eksempel, men det viser hvor feil cast- overloading kan ta. class X { public: X() : m_pString(0) {} X(char* string) : m_pString(0) { if ( string == 0 ) return; m_pString = new char[strlen(string)+1]; strcpy(m_pString, string); } operator char*() { static char* empty = ""; if ( m_pString == 0 ) return empty; else return m_pString; } private: char* m_pString; }; int main() { X x("Hello world"); delete x; }