The Standard String Class

• Is actually a template: – typedef basic_string<char> string

• This means you can have strings of things other than chars

Accessing Elements

• You can access the elements via the subscript operator

std::string fred = "hello";

std::cout << fred[0];

• Or through the at methodstd::string fred = "hello";

std::cout << fred.at(0);

• at() throws an out_of_range on bad access

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

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)

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

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

Insertion Similar to appending, but a position is required The characters are inserted before the positionstring& 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);

Concatenation

• Performed via an overloaded + operator

• Works for strings

• And C-style strings

• And chars

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

Searching

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

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

Substring

• Returns a new string object representing the substring

string substr(size_type i,

size_type n) const• Combines well with find and replace

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

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

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

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

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

}

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

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

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

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

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>

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)

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.

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");}

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

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