The Standard String Class

1. The Standard String Class • Is actually a template: • typedef basic_string<char> string • This means you can have strings of things other than chars

2. Accessing Elements • You can access the elements via the subscript operator std::string fred = "hello"; std::cout << fred[0]; • Or through the at method std::string fred = "hello"; std::cout << fred.at(0); • at() throws an out_of_range on bad access

3. Constructors • C-style string, string, char sequence, and parts there-of • string s1; // default - empty string • string s2 = "hello"; // C-style string • string s3(5,'h'); // ”hhhhh” • string s4 = s3; //copy of s3 • string s5(s2,1,2); // ”el” • const char *cp = "hello"; • string s6(cp+1,2); //"el" again • string s7(cp,1,2); //func. resolution

4. Assignment • Lot's of versions again • string s1 = "family"; • string s2 = "guy"; • s1 = s2; // assign a string • s1 = "fred"; // assign a C-style string • s2 = 'h'; // assign a char • There are also assign() methods for other constructor equivalents (since assignment operators can’t have multiple arguments)

5. Comparisons • Operator overloading provides for string and c-style string compares • There are also compare methods which return ints ala strcmp • The simple <,<=,==,>=,>,!= usually suffice though

6. Appending • += is overloaded for appending strings, c-style strings, and chars • There is also an append method: string& append(const string &str); string& append(const string &str, size_type pos, size_type n); string& append(const char *p, size_type n); string& append(const char *p); string& append(size_type n, char c);

7. Insertion • Similar to appending, but a position is required • The characters are inserted before the position string& insert(size_type pos, const string &str); string& insert(size_type pos, const string &str, size_type pos1, size_type n); string& insert(size_type pos, char *p, size_type n); string& insert(size_type pos, char *p, size_type n); string& insert(size_type pos, size_type n, char c);

8. Concatenation • Performed via an overloaded + operator • Works for strings • And C-style strings • And chars

9. Searching • Can search for strings, C-style strings, and chars • Can find first or last occurance of the item • Or first or last occurance of any of the items elements • Or first or last occurance of any characters not in the item

10. Searching std::string s = "accdcde"; s.find("cd"); //return 2 s.rfind("cd"); //returns 4 s.find_first_of("cd"); //returns 1 s.find_last_of("cd"); // returns 5 s.find_first_not_of("cd");//returns 0 s.find_last_not_of("cd"); //returns 6

11. Replace • Replaces a substring with another string • Has as many forms as the constructors string& replace(size_type i, size_type n, const string &str); string& replace(size_type i, size_type n, const string &str, size_type i2, size_type n2); string& replace(size_type i, size_type n, const char *p, size_type n2); string& replace(size_type i, size_type n, const char *p); string& replace(size_type i, size_type n, size_type n2, char c);

12. Substring • Returns a new string object representing the substring string substr(size_type i, size_type n) const • Combines well with find and replace

13. Misc. Methods • length() and size() give the string length • max_size() gives the maximum size of a string • empty() returns true if the string is empty • erase(size_type i=0, size_type n=npos) empties the string • Notice that erase() can be done with replace()

14. Converting to C-Style Strings • The c_str() method returns a const char* • The data() method is similar but does not add the '\0’ • The array returned is managed by the string • Calling a non-const method invalidates it

15. Input/Output • strings can be output with operator<< • They can be input with operator>> in which case words are read • There is also a getline(istream&,string&) function • getline reads a line from input into the string • Input into strings is better than char arrays • Mainly because the string will expand as necessary

16. The Standard Streams • Yet another template you have been using without knowing • typedef basic_ostream<char> ostream • Same reasons as string for being a template

17. Output Streams • You should know how to use these by now • You should know how to overload << by now • Note that operator<< aren't members and thus aren't virtual • When dealing with inheritance it is common to: class Base { virtual ostream& put(ostream &os) const; }; ostream& operator<<(ostream& os, const Base &b) { return b.put(os); }

18. Input Streams • Again you should have some experience with these by now • Virtual functions don't matter as much • But the same technique can be used • Should always test the result of a read and not just assume it worked

19. Stream State • All istream and ostream’s have the following methods • bool good() const true if all has gone well • bool eof() const true if reached end of input • bool fail() const true if next operation will fail • bool bad() const true if stream may be corrupt

20. Formatting • We can change the format that C++ uses to output values • The setf() and unsetf() methods are used • The flags we can use are defined in ios_base • cout.setf(ios_base::oct,ios_base::basefield) • ouput integers in octal • cout.setf(ios_base::scientific, ios_base::floatfield) • output floating point in scientific format

21. Formatting II • Can also set field widths and fill characters width() and fill() are used • cout.width(4); • cout.fill('*'); • cout << "hi"; //will output '##hi' • We can use left, right, and internal in ios_base to change placement • Changes only apply to the next output operation

22. Manipulators • Manipulators are a simpler way of manipulating streams • They are used in the standard << output notation • std::cout << 12 << ' ' << oct << 12 << endl; • std::cout << setw(4) << setfill('*') << "hi"; • You need to #include <iomanip>

23. File Streams • Reading and writing from files is the same as using cin and cout • Except you have to open them first • ifstreams are for reading files • ofstreams are for writing files • fstreams are for additional options (read and write, append mode, etc)

24. Strstreams • A string in memory can also be used as a stream • Our compiler and the standard disagree on this bit. • strstream has been replaced with stringstream (which acts on string obects insted of char*s) • Our compiler doesn’t support stringstreams.

25. Input String Streams #include <iostream> #include <string> #include <strstream> void word(const char* s) { istrstream istr(s); string w; while (istr >> w) cout << w << endl; } int main() { word("here is a short string"); }

26. Output String Streams #include <iostream> #include <strstream> #include <iomanip> int main() { char a[100] = ""; ostrstream out(a,100); out << setw(50) << setfill('*') << "a string" << endl; cout << a; }

27. Closing Streams • The close() method closes a stream • Usually it is not needed as the destructor performs the close • Sometimes closing a file can be useful, though