Home | Projects | Notes > C++ Programming > Characters & Strings

Characters & Strings

Overview

• Character functions (#include <cctype>)

• C-style strings

• Working with C-style strings

• C++ strings (Should be using these in modern C++)

  • C++ strings are objects and used in OOPs.

• Working with C++ strings

Character Functions

• The <cctype> library includes very simple and very useful functions that allow

  xxxxxxxxxx
  3
  1
  #include <cctype>
  2
  
  3
  function_name(char)
  

• Testing of characters for various properties (Returns true or false)

  xxxxxxxxxx
  9
  1
  isalpha(c)          True if c is a letter
  2
  isalnum(c)          True if c is a letter or digit
  3
  isdigit(c)          True if c is a digit
  4
  islower(c)          True if c is lowercase letter
  5
  isprint(c)          True if c is a printable character 
  6
  ispunct(c)          True if c is a punctuation character 
  7
  isupper(c)          True if c is an uppercase letter 
  8
  isupper(c)          True if c is an uppercase letter 
  9
  isspace(c)          True if c is whitespace 
  

• Conversion of characters (Returns the converted characters)

  xxxxxxxxxx
  2
  1
  tolower(c)          Returns lowercase of c
  2
  toupper(c)          Returns uppercase of c
  

C-style Strings (Null Terminated Strings!)

Overview

• Sequence of characters (String variable)

  • Contiguous in memory

  • Implemented as an array of characters

  • Terminated by a null character (\0; character with a value of 0)

  • Referred to as null (or zero) terminated strings

• String literal

  • Sequence of characters in double quotes (e.g., "Jack")

  • Constant

  • Terminated with a null character (\0)

    Even though a null character is not provided to the end of the string literal, C++ inserts one for us.

Declaration

• Declaration and initialization

  xxxxxxxxxx
  2
  1
  char my_name[] {"Jack"};    // Jack\0 (C++ compiler will allocate 5 char for this array)
  2
  char my_name[10] {};        // Null initialized string
  

  xxxxxxxxxx
  2
  1
  char my_name[] {"Jack"};    
  2
  my_name[4] = 'y';   // Problem
  

  You won't be able to do to add a y to make it Jacky because the string size is fixed and adding a y to the end will not make the string end with a null character. But, the following is okay.

  xxxxxxxxxx
  2
  1
  char my_name[8] {"Jack"};   // Jack\0\0\0\0
  2
  my_name[4] = 'y';           // OK (Still null terminated)
  

  xxxxxxxxxx
  3
  1
  char my_name[8];            // Uninitialized string (Contains garbage)
  2
  my_name = "Jack";           // Error (Both 'my_name' and '"Jack"' evaluates to an address)
  3
  strcpy(my_name, "Jack");    // OK
  

Libraries

• <cstring> library contains many functions that work with C-style strings

  • Copying

  • Concatenation

  • Comparison

  • Searching

  • and many more

  Examples:

  xxxxxxxxxx
  7
  1
  #include <cstring>
  2
  
  3
  char str[80];
  4
  strcpy(str, "Hello ");  // Copy
  5
  strcat(str, "there");   // Concatenate
  6
  cout << strlen(str);    // 11
  7
  strcmp(str, "Another"); // > 0
  

• <cstdlib> library contains general purpose functions including functions to convert C-style strings to integer, float, long, etc.

C++ Strings (std::string)

Overview

• std::string is a class in the Standard Template Library (STL) which provides a rich set of methods or functions that allows to manipulate strings easily.

  • #include <string>

  • In the std namespace

  • Contiguous in memory

  • Dynamic size

  • Work with input and output streams

  • Lots of useful member functions

  • Operators such as +, =, <, <=, >, >=, +=, ==, !=, [], ...

  • Can be easily converted to C-style string if needed

    Even though C++ strings are preferred in most cases, sometimes you need to use C-style strings (e.g., interfacing with a library that's been optimized for C-style strings). In this case, you can still use C++ strings and take advantage of them, and when you need to, you can easily convert the C++ string into a C-style string and back again.

  • Safer (Provides bounce check and allows to find errors in the code so they can be fixed before they go into production)

Declaration

• Declaration and initialization (Unlike C-style strings, C++ strings are always initialized.)

  xxxxxxxxxx
  9
  1
  #include <string>
  2
  using namespace std;
  3
  
  4
  string s1;              // Empty (Initialized to an empty string; Does not contain garbage)
  5
  string s2 {"Jack"};     // Jack (C-style string will be converted into a C++ string)
  6
  string s3 {s2};         // Jack
  7
  string s4 {"Jack", 3};  // Jac
  8
  string s5 {s3, 0, 2};   // Ja (Starting at index '0', 2 characters)
  9
  string s6 (3, 'x');     // xxx (Note that these are not curly braces)
  

Operations

• Assignment

  xxxxxxxxxx
  5
  1
  string s1;
  2
  s1 = "Jack";
  3
  
  4
  string s2 {"Hello"};
  5
  s2 = s1;    // s2 will contain "Jack"
  

• Concatenation

  xxxxxxxxxx
  7
  1
  string s1 = "Hello";
  2
  string s2 = "world";
  3
  
  4
  string s3;
  5
  
  6
  s3 = s1 + " " + s2 + " Jack";   // Hello world Jack 
  7
  s3 = "New" + "sentence";        // Illegal ('+' only works with C++ strings!)
  

  L7: A combination of C++ strings and C-style strings is okay though!

• Accessing characters using [] and at() function

  xxxxxxxxxx
  8
  1
  string s1;
  2
  string s2 {"Jack"};
  3
  
  4
  cout << s2[0] << endl;      // J
  5
  cout << s2.at(0) << endl;   // J
  6
  
  7
  s2[0] = 'j';    // s2 will contain "jack"
  8
  s2.at(0) = 'p'; // s2 will contain "pack"
  

  [] does not provide bounce check, whereas at() does.

  xxxxxxxxxx
  5
  1
  // Reading characters
  2
  
  3
  string s1 {"Jack"};
  4
  for (char c : s1)
  5
      cout << c << " ";
  

  xxxxxxxxxx
  1
  1
  J a c k
  

  xxxxxxxxxx
  5
  1
  // Reading characters as integer values
  2
  
  3
  string s1 {"Jack"};
  4
  for (int c : s1)
  5
      cout << c << " ";
  

  xxxxxxxxxx
  1
  1
  74 97 99 107 0  // Last character being the ascii value for '\0'
  

• Comparison (==, !=, >, >=, <, <=)

  The objects are compared character-by-character lexically.

  Can compare:

  • Two std::string objects

  • std::string object and C-style string literal

  • std::string object and C-style string variable

  Examples:

  xxxxxxxxxx
  13
  1
  string s1 {"Apple"};
  2
  string s2 {"Banana"};
  3
  string s3 {"Kiwi"};
  4
  string s4 {"apple"};
  5
  string s5 {s1};     // Apple
  6
  
  7
  s1 == s5        // True
  8
  s1 == s2        // False
  9
  s1 != s2        // True
  10
  s1 < s2         // True
  11
  s2 > s1         // True
  12
  s4 < s5         // False
  13
  s1 == "Apple"   // True (Here "Apple" is a C-style literal)
  

• Substrings (substr())

  Extracts a substring from std::string.

  xxxxxxxxxx
  1
  1
  object.substr(start_index, length)
  

  Examples:

  xxxxxxxxxx
  5
  1
  string s1 {"This is test"};
  2
  
  3
  cout << s1.substr(0, 4);    // This
  4
  cout << s1.substr(5, 2);    // is
  5
  cout << s1.substr(10, 4);   // test
  

• Search (find())

  Returns the index of a substring in a std::string.

  xxxxxxxxxx
  1
  1
  object.find(search_string)
  

  Check out rfind() which performs the search backwards as well!

  Examples:

  xxxxxxxxxx
  8
  1
  string s1 {"This is a test"};
  2
  
  3
  cout << s1.find("This");    // 0
  4
  cout << s1.find("is");      // 2
  5
  cout << s1.find("test");    // 10
  6
  cout << s1.find('e');       // 11
  7
  cout << s1.find("is", 4);   // 5
  8
  cout << s1.find("xx");      // string::npos (no position information available)
  

  L8: Can check for string::npos in an if statement. If true, the string you are searching for wasn't there.

• Removing characters (erase() and clear())

  Removes a substring of a character from a std::string.

  xxxxxxxxxx
  1
  1
  object.erase(start_index, length)
  

  Examples:

  xxxxxxxxxx
  5
  1
  string s1 {"This is a test"};
  2
  
  3
  cout << s1.erase(0, 5);     // is a test
  4
  cout << s1.erase(5, 4);     // is a
  5
  s1.clear()                  // Empties string s1
  

• Other useful functions

  xxxxxxxxxx
  6
  1
  string s1 {"Jack"};
  2
  
  3
  cout << s1.length() << endl;    // 4 (Returns the number of chars currently in the string obj)
  4
  
  5
  s1 += " Lee";
  6
  cout << s1 << endl;     // Jack Lee
  

• Input >> and getline()

  Reading std::string from cin.

  xxxxxxxxxx
  2
  1
  getline(input_stream, dest_string)  // Reads the entire line until '\n'
  2
  getline(input_stream, dest_string, delimiter)   // Delmiter: The char you want to stop reading at
  

  getline() does not include the new-line character \n (or delimiter), and discards it.

  Examples:

  xxxxxxxxxx
  10
  1
  string s1;
  2
  cin >> s1;              // Hello there (Only accepts up to the first space)
  3
  
  4
  cout << s1 << endl;     // Hello
  5
  
  6
  getline(cin, s1);       // Read entire line until \n
  7
  cout << s1 << endl;     // Hello there
  8
  
  9
  getline(cin, s1, 'x');  // this isx
  10
  cout << s1 << endl;     // this is