CS 509 Class Notes

Lecture Notes for Advanced Programming II

The string class and the array of characters (or character array).
- std::string s; vs. char s[10];
The string class is part of the C++ standard libraries.
The character array is an basic data type.
- "jacaranda" is a character array literal.
- Also called a string literal, but it's not an instance of the string class.

Arrays in general are bad - fixed size, no bounds checking
- Strings are dynamic. How big's a string?
  - Arrays have some size and that's it.
- No warning if a string doesn't fit, and it destroys data.
Character arrays are bad - the null byte, clumsy operations, relations, errors are subtle.
- The size is one more than you think.
```
char prompt[5] = "hello";
```
- The string.h utilities.
- What does this print?
```
char s1[4] = "red";
char s2[4] = "red";
if (s1 == s2) std::cout << "yes\n";
```
- Clobber data with no warning.

Strings are defined in the header file <string>.
Strings don't have a null byte - nothing to forget, nothing to remember.
Strings manage space themselves - no overflows, no leaking memory.
- To use character arrays correctly, you re-implement strings.
Comparisons work as expected.
- == compares contents, not addresses.
Of course, they're slower and bigger, but so what.
- String class overhead is marginal - no more than 20 bytes.
- String assignment and reallocation is expensive.

Use #include <string> to define strings.
Part of the standard C++ library; needs the std:: prefix.
- Use using std::string; to forego the std:: prefix.
Strings can be initialized in the usual way.
- std::string name = "jacaranda";
- A string with no initialization is the empty string.
  - The string with no characters.

Strings are accessed with [ ] subscripts, just like arrays.
- The index range is the same, 0 to n - 1.
- The .length() member function returns the number of characters in a string.
- [ ] subscript access to strings is not checked.
- .at() subscript access is checked.

Assignment behaves like normal.

Assignment makes copies, it doesn't share.

std::string word1 = "what?"
std::string word2

word2 = word1
word1[4] = '!'

// word2[4] == '?'

+ does string catenation.
- += does appending.
```
filename += ".h";
```
String comparison == works as expected.
- It compares contents, not addresses.
String relations < define a lexicographic (dictionary) order.
- We'll see this again in the STL.
There are many other string member functions defined.
- Search, substring, replacement functions.
- See Dietel and Dietel Chapter 19.

>> and << work as expected.
- >> eats white space; stops at white space.
The getline() function doesn't eat white space.
- Stops at caller-specified characters (newline by default).
Beware the dreaded buffer overflow error.
```
char line[1024];
std::cin >> line;
```
- If I see this in your code, you will pay dearly.
getline() is defined in <string>.
- Don't confuse it with the .getline() istream member function.
EOF and error conditions are as usual for io streams.

Automatic (mostly) conversion from character arrays to strings.
Conversion from strings to character arrays is not automatic.
- The c_str() member function.
- The pointer returned is temporary.
  - If s changes, so might s.c_str().
Characters are not character arrays.
- Conversions between a character and a string requires work.
- String member functions help here.
  - str.push_back('!');

The string class is part of the C++ standard.
- Include <string>.
Strings are better than character arrays.
- Strings are dynamic, self managing, convenient.
- Character arrays are fast and efficient.
Unfortunately, strings are like arrays in some ways.
- Unchecked [ ] subscript access.
The string class has many member functions.
- Learn them, use them.

This page last modified on 2 October 2003.