Laboratory Exercises, C++ Programming

24 Strings and Streams
char type is the type of the characters in the string. size type is a type used for indexing in the
string. npos (“no position”) indicates a position beyond the end of the string; it may be returned
by functions that search for characters in a string. Since size type is unsigned, npos represents
positive infinity.
1.2 Operations on Strings
We now show some of the most important operations on strings (actually basic string’s). The
operations are both member functions and global helper functions. We start with the member
functions (for formatting reasons, some parameters of type size type have been specified as
int):
class string {
public:
/*** construction ***/
string(); // create an empty string
string(const string& s); // create a copy of s
string(const char* cs); // create a string with the characters from cs
string(const string& s, int start, int n); // create a string with n
// characters from s, starting at position start
string(int n, char ch); // create a string with n copies of ch
}
/*** information ***/
int size(); // number of characters in the string
int capacity(); // the string can hold this many characters
// before resizing is necessary
void reserve(int n); // set the capacity to n, resize if necessary
/*** character access ***/
const char& operator[](size_type pos) const;
char& operator[](size_type pos);
/*** substrings */
string substr(size_type start, int n); // the substring starting at
// position start, containing n characters
/*** finding things ***/
// see below
/*** inserting, replacing, and removing ***/
void insert(size_type pos, const string& s); // insert s at position pos
void append(const string& s); // append s at the end
void replace(size_type start, int n, const string& s); // replace n
// characters starting at pos with s
void erase(size_type start = 0, int n = npos); // remove n characters
// starting at pos
/*** assignment and concatenation ***/
string& operator=(const string& s);
string& operator=(const char* cs);
string& operator=(char ch);
string& operator+=(const string& s); // also for const char* and char
/*** access to C-string representation ***/
const char* c_str();
• Note that there is no constructor string(char). Use string(1, char) instead.