1. The Standard String Class Is actually a template: –typedef basic_string 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 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

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 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 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