Lecture Notes for Advanced Programming II

23 September 2003 - Strings

Strings

• Some Terminology

• Character Arrays Are Bad

• The String Data Type is Good

• String Declarations and Initialization

• String Assignment and Access

• Other String Operations

• Stream IO Operations

• Strings and Character Arrays

Some Terminology

• 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.

Character Arrays Are Bad

• 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.

The String Class is Good

• 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.

String Declarations and Initialization

• 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.

String Assignment and Access

• 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] == '?'
    

  ---

  Other String Operations

  • + 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.

  ---

  Stream IO Operations

  • >> 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.

  ---

  Strings and Character Arrays

  • 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('!');

  ---

  Points to Remember

  • 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 31 January 2003.