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.
- It's also known as a plain old data type or POD).
"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 if it doesn't.
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: strcpy(), strcat() and friends.
- 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 than arrays, but so what?
- String class storage overhead is marginal, 12 bytes or so.
- String assignment and reallocation is expensive.
  - It's not pointer manipulation.

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.

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 or Josuttis Chapter 11.

>> and << work as expected.
- >> eats white space; stops at white space.
- This effectively reads a word at a time.
The getline() function doesn't eat white space.
- Stops at caller-specified characters (newline by default).
- getline() is defined in <string>.
- Don't confuse it with the .getline() istream member function.
Beware the dreaded buffer overflow error.
```
char line[1024];
std::cin >> line;
```
- If I see this in your code, you will pay dearly.
EOS 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(), data(), and copy() member function.
  - Know what each of them do.
  - Really understand what you get from c_str().
    - The pointer returned is temporary.
      - If s changes, so might s.c_str().
Characters are mostly like character arrays.
- s = c, s += c, s.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 23 January 2004.