159.

234 LECTURE 17
18

C++ Strings

1
 C ++ Strings
– Formatted Input: Stream extraction operator
• cin >> stringObject;
• the extraction operator >> formats the data that it receives
through its input stream; it skips over whitespace

– Unformatted Input: getline function for a string

• getline( cin, s)
– does not skip over whitespace
– delimited by newline
– reads an entire line of characters into s

string s = “ABCDEFG”;
getline(cin, s); //reads entire line of characters into s
char c = s[2]; //assigns ‘C’ to c
S[4] = ‘*’; //changes s to “ABCD*FG” 3
 C ++ Strings

– Not necessarily null terminated

– string is not a pointer, but a class
– Many member functions take start position and
length
• If length argument too large, max chosen

4
 C ++ Strings 18

Creating String Objects

#include <string> string type in the

//string initialization <string> header file.

string s; //s contains 0 characters

string s1( "Hello" ); //s1 contains 5 characters
string s2 = “Hello”; //s2 contains 5 characters
//implicitly calls the constructor

string s3( 8, 'x' ); //s3 contains 8 'x' characters

string s4 = s3; //s4 contains 8 'x' characters

string s5(s2, 3, 2); //s5 copies a substring of s2; it contains ”lo”

5
string_characteristics.cpp
 C ++ Strings 18

String Objects

C++ strings can be converted to C-strings:

string s = “ABCDEFG”;
const char* cs = s.c_str();

Converts s into the C-string cs.

The c_str() function has a return type const char*

6
 C ++ Strings 18

String Objects

The C++ string class also defines a length() function for extracting
how many characters are stored in a string.

cout << s.length() << endl;

Prints 4 for the string s == “Leon”

You can also use the subscript operator [ ] to access

individual characters:
e.g. s[0] = ‘N’ ; //where index: 0 to length-
1 7
 C ++ Strings 18

String Objects

C++ strings can be compared using relational operators just like

fundamental types:

If(s2 < s5)

cout << “s2 lexicographically precedes s5 \n”;

while(s4==s3) //…

'B' is lexicographically greater than 'A'

Sample order: ‘A’,”Apple”, “Banana”, “Zest”, ‘a’, “apricot”,
“leon”

8
compare.cpp
 C ++ Strings 18

String Objects

You can also concatenate C++ strings using the + and += operators:

string s = “ABCD*FG”;
string s2 = “Robot”;
string s5 = “Soccer”;
string s6 = s + “HIJK”; //changes s6 to “ABCD*FGHIJK

s2 += s5; //changes s2 to “RobotSoccer”

9
 C ++ Strings 18

String Objects

Substring function: substr()

s6 = “ABCD*FGHIJK”;
s4 = s6.substr(5, 3); //changes s4 to “FGH”

s4 gets a substring of s6, starting at index 5 and taking 3

characters

10
 C ++ Strings 18

String Objects

erase() and replace() functions:

s6 = “ABCD*FGHIJK”;
s6.erase(4, 2); //changes s6 to “ABCDGHIJK”;

s6.replace(5, 2, “xyz”); //changes s6 to “ABCDGxyzJK”;

replace 2 characters from s6, starting at

index 5, with “xyz”

11
 C ++ Strings 18

String Objects

find() function
returns the index of the first occurrence of a given substring:

string s7 = “Mississippi River basin”; //23 characters

cout << s7.find(“si”) << endl; //prints 3
cout << s7.find(“so”) << endl; //prints 23, the length of the string

If the find() function fails, it returns the

length of the string it was searching.

i.e. find() returns 4,294,967,295 12

 Assignment

• Assignment
– s2 = s1;
• Makes a separate copy
– s2.assign(s1);
• Same as s2 = s1;
– myString.assign(s, start, N);
• Copies N characters from s, beginning at index start
– Individual character assignment
• s2[0] = s3[2];

13
 Range-checking
• Range-checking
– s3.at( index );
• Returns character at index
• Can throw an out_of_range exception
– [] has no range checking
#include <exception>
...

string s = "leon";
try{
char letter = s.at( 50 );
cout <<"letter is = " << letter << endl;
}

catch(exception& e){
cout << "out_of_range exception: " << e.what() << endl;
}
14
string_characteristics.cpp
 Concatenation
• Concatenation
– s3.append( "pet" );
– s3 += "pet";
• Both add "pet" to end of s3
– s3.append( s1, start, N );
• Appends N characters from s1,
s1 beginning at index start

15
 Comparing strings
• Overloaded operators
– ==, !=, <, >, <= and >=
– returns bool
• s1.compare(s2)
– returns positive if s1 is lexicographically greater
• compares letter by letter
• 'B' lexicographically greater than 'A‘
• ‘a’ lexicographically greater than ‘A‘
• ‘a’ lexicographically greater than ‘Z‘
– returns negative if less; zero if equal
• Sample order: ‘A’,”Apple”, “Banana”, “Zest”, ‘a’, “apricot”, “leon”

– s1.compare(start, length, s2, start, length)

• Compare portions of s1 and s2
– s1.compare(start, length, s2)
• Compare portion of s1 with all of s2
16
Compare.cpp
 Substrings

• Function substr gets a substring

– s1.substr( start, N );
– gets N characters, beginning with index start
– returns substring

17
 Swapping strings

• s1.swap(s2);
– Switch contents of two strings

18
 string Characteristics
• Member functions
– s1.size() and s1.length()
• Number of characters in a string
– s1.capacity()
• Number of elements that can be stored without reallocation
– s1.max_size()
• Maximum possible string size
– s1.empty()
• Returns true if empty
– s1.resize(newlength)
• Resizes string to newlength
19
string_characteristics.cpp
 Finding Strings and Characters in a string
• Find functions
– If found, index returned
– If not found, string::npos returned
• Public static constant in class string
– s1.find( s2 )
– s1.rfind( s2 )
• Searches right-to-left
– s1.find_first_of( s2 )
• Returns first occurrence of any character in s2

• Example: s1.find_first_of( "abcd" )

– Returns index of first 'a', 'b', 'c' or 'd'
20
others.cpp
Finding Strings and Characters in a string

• Find functions
– s1.find_last_of( s2 )
• Finds last occurrence of any character in s2
– s1.find_first_not_of( s2 )
• Finds first character NOT in s2
– s1.find_last_not_of( s2 )
• Finds last character NOT in s2

21
others.cpp
 Replacing Characters in a string
• s1.erase( start )
– Erase from index start to end of string, including
start
• Replace
– s1.replace( begin, N, s2)
• begin: index in s1 to start replacing
• N: number of characters to replace
• s2: replacement string
– s1.replace( begin, N, s2, index, num )
• index: element in s2 where replacement comes from
• num: number of elements to use when replacing
– Replace can overwrite characters
22
others.cpp
 Example
s1.replace( begin, N, s2, index, num )

• begin: index in s1 to start replacing

• N: number of characters to replace
• s2: replacement string
• index: element in s2 where replacement comes from
• num: number of elements to use when replacing

string str = "this is an example string.";

string str3="sample phrase";

str.replace(19,6, str3, 7, 6); // "this is an example phrase."

23
 Inserting Characters into a string
• s1.insert( index, s2 )
– Inserts s2 before position index
• s1.insert( index, s2, index2, N );
– Inserts substring of s2 before position index
– Substring is N characters, starting at index2

24
others.cpp
 Conversion to C-Style char*
• Conversion functions
– Strings are not necessarily null-terminated
– s1.copy( ptr, N, index )
• Copies N characters into the array ptr
• Starts at location index
• Need to null terminate

char str[8];

string s2 = "cathode";
Output:
s2.copy(str, 5, 2); //copy 5 characters into str
//starting at index 2
str = thode
//strcat(str,"\0"); //does not work s2 = cathode
str[5] = '\0'; //this is required

cout << "str = " << str << endl; 25

cout << "s2 = " << s2 << endl;
 Conversion to C-Style char * Strings
• Conversion functions

– s1.c_str()
• Returns const char *
• Null terminated
• e.g. Useful for filenames:
ifstream in( s1.c_str() );

– s1.data()
• Returns const char *
• NOT null-terminated

26
 Warning!
• No conversion from int or char

– The following definitions could return errors, or

warnings only, but then would cause the program to
crash afterwards

• string error1 = 'c';

• string error2( 'u' );
• string error3 = 22;
• string error4( 8 );

– However, it can be assigned one char after its

declaration:
• s = 'n'; 27
 String Stream Processing
• allows a string to be used as an internal file
• useful for buffering input and output

• I/O of strings to and from memory

– Called in-memory I/O or string stream processing
– Classes
• istringstream // input from string
• ostringstream // output to a string
• stringstream( string ) // most useful
• Requires <sstream> and <iostream> headers
– Use string formatting to save data to memory

28
 Output String Stream

ostringstream oss;

int n = 44;
float x = 3.14;

oss << "Hello!\t" << n << '\t' << x;

string s = oss.str();

cout << endl << s << endl;

Serves as a conduit to an anonymous string which can be read

with the built-in oss.str() function that is bound to the oss object

Remember sprintf()?, how does it compare to this one? 29

output_string_stream.cpp
 Input String Stream
const string buffer = oss.str();
istringstream iss(buffer);
iss
iss is defined and bound to buffer
string word;
int m;
float y; Contents of buffer can be accessed
as elements of a string, or by
iss >> word >> m >> y; formatted input through the iss
object.
s = iss.str();
iss
cout << endl << s << endl;
Remember sscanf()?,
cout << "word = " << word << endl; how does it compare to
cout << "m = " << m << endl; this one?
cout << "y = " << y << endl; input_string_stream.cpp

All extractions from iss will come from the contents of buffer, as
30
if
it were an external file.
file
#include <iostream>
#include <fstream> Using string example
#include <iomanip>
#include <string> • Input file:
#include <sstream> 1.0 2.0
using namespace std; 1.1 2.4
int main(){ 1.8 2.8
#1.34 2.99
string s1("mydata.txt"); 1.4 8.99
ifstream in( s1.c_str() );
• Example Output:
char buffer[1024]; Line is:1.0 2.0
while( in.getline( buffer, 1024 ) ){ 1,2

string stemp( buffer ); Line is:1.1 2.4

cout << "Line is:" << stemp << endl; 1.1,2.4

if( stemp[0] != '#' ){ Line is:1.8 2.8

stringstream stris( stemp ); 1.8,2.8
double d1, d2;
stris >> d1 >> d2; Line is:#1.34 2.99
cout << d1 << "," << d2 << endl;
} Line is:1.4 8.99
cout << endl; 1.4,8.99
}
in.close();
return 0; (or could use strtok, C String tokenizers)
31
}
#include <iostream>
#include <fstream>
Alternatively: (no C-style char*)
#include <iomanip>
#include <string> File_stringstream2.cpp
#include <sstream>
using namespace std;
int main(){ int main(){

string s1("mydata.txt"); string s1("mydata.txt");

ifstream in( s1.c_str() ); ifstream in( s1.c_str() );

char buffer[1024]; string buffer;

while( in.getline( buffer, 1024 ) ){ while(getline( in, buffer ) ){

string stemp( buffer );

cout << "Line is:" << stemp << endl; cout << "Line is:" << buffer << endl;

if( stemp[0] != '#' ){ if( buffer[0] != '#' ){

stringstream stris( stemp ); istringstream stris( buffer );
double d1, d2; double d1, d2;
stris >> d1 >> d2; stris >> d1 >> d2;
cout << d1 << "," << d2 << endl; cout << "data: " << d1 << "," << d2 << endl;
}
cout << endl; }
} cout << endl;
in.close(); }
return 0; in.close(); 32
} return 0;
Summary

C++ strings are safer and easier to use than C string.

Next Templates

33
Method Use
append(char *pt);
append(char *pt, size_t count);
append(string &str, size_t
offset,size_t count);
Appends characters to a string from C-style strings, char's or other string objects.
append(string &str);
append(size_t count, char ch);
append(InputIterator Start,
InputIterator End);
Returns a reference to the character at the specified position. Differs from the
at(size_t offset);
subscript operator, [], in that bounds are checked.
begin(); Returns an iterator to the start of the string.
*c_str(); Returns a pointer to C-style string version of the contents of the string.
clear(); Erases the entire string.
copy(char *cstring, size_t count,
Copies "count" characters into a C-style string starting at offset.
size_t offset);
empty(); Test whether a string is empty.
end(); Returns an iterator to one past the end of the string.
erase(iterator first, iterator last);
erase(iterator it); Erases characters from the specified positions.
erase(size_t pos, size_t count);

34
Method Use

find(char ch,size_t offset = 0);

find(char *pt,size_t offset = 0); Returns the index of the first character of the substring when found. Otherwise,
find(string &str,size_t offset = the special value "npos" is returned.
0);

Same sets of arguments as find. Finds the index of the first character that is not
find_first_not_of();
in the search string.

Same sets of arguments as find. Finds the index of the first character that is in
find_first_of();
the search string.

Same sets of arguments as find. Finds the index of the last character that is not in
find_last_not_of();
the search string.

Same sets of arguments as find. Finds the index of the last character that is in the
find_last_of();
search string.

insert(size_t pos, char *ptr);

insert(size_t pos, string &str);
insert(size_t pos, size_t count,
Inserts characters at the specified position.
char ch);
insert(iterator it, InputIterator
start, InputIterator end);

push_back(char ch); Inserts a character at the end of the string.

replace(size_t pos, size_t count,

char *pt);
replace(size_t pos, size_t count,
Replaces elements in a string with the specified characters. The range can be
string &str);
specified by a start position and a number of elements to replace, or by using
replace(iterator first, iterator
iterators.
last, char *pt);
replace(iterator first, iterator
last, string &str);

size(); Returns the number of elements in a string.

swap(string &str); Swaps two strings. 35