Working with Strings Lecture 2 Hartmut Kaiser hkaiser@cct.lsu.edu http://www.cct.lsu.edu/˜hkaiser/fall_2011/csc1254.html

CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 Abstract This lecture will look at strings. What are strings? How can we input/output strings? How can we manipulate strings? What functionality is provided by the std::string type?

C++ Libraries Groups related operations C++ Standard Libraries CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 C++ Libraries Groups related operations Header file provides function prototypes and usage comments Compiled library contains implementation C++ Standard Libraries E.g. string, iostream, fstream #include <foo> Terse lowercase names: cout, getline, substr

String Input Given the following interaction: We would like to print: CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 String Input Given the following interaction: Please enter your name: John We would like to print: Hello John!

CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 String Input // Ask a persons name, greet the person #include <iostream> #include <string> int main() { // ask for the persons name std::cout << "Please enter your first name: "; // read the name std::string first_name; // define 'first_name' std::cin >> first_name; // read into 'first_name' // write a greating std::cout << "Hello, " << first_name << std::endl; return 0; }

String Input Place to put input into: variable CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 String Input Place to put input into: variable Variables are objects which have a name (first_name) Objects are part of the computer memory with an associated type (std::string) std::string Part of namespace std #include <string>

String Input Variable definition: std::string name; CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 String Input Variable definition: std::string name; Local variable, is destroyed at end of block Type defines the available operations and interface exposed by the object Initialization, here: empty (or null) string String input using operator >> from std::cin Discards leading whitespace Stops at whitespace Input/output buffering occurs flushing is performed: buffer full, input, explicit request

Names A name in a C++ program CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 Names A name in a C++ program Starts with a letter, contains letters, digits, and underscores (only) x, number_of_elements, Fourier_transform, z2 Not names: 12x time$to$market main line Do not start names with underscores: _foo those are reserved for implementation and system entities Users can't define names that are taken as keywords E.g.: int return while double

Names Choose meaningful names CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 Names Choose meaningful names Abbreviations and acronyms can confuse people mtbf, TLA, myw, nbv, wtf Short names can be meaningful when used conventionally: x is a local variable i is a loop index Don't use overly long names Ok: partial_sum element_count staple_partition Too long: the_number_of_elements remaining_free_slots_in_the_symbol_table

Framing a Name Given the following interaction: CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 Framing a Name Given the following interaction: Please enter your name: John We would like to print: ******************* * * * Hello John! *

CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 Framing a Name // Ask a persons name, greet the person #include <iostream> #include <string> int main() { std::cout << "Please enter your first name: "; // ask for the persons name std::string first_name; // define 'first_name' std::cin >> first_name; // read into 'first_name' std::string const greeting = "Hello, " + first_name + "!"; // build the message we intend to write std::string const spaces(greeting.size(), ' '); // build the second and fourth string std::string const second = "* " + spaces + " *"; std::string const first(second.size(), '*'); // build the first and fifth lines std::cout << first << std::endl; // write all std::cout << second << std::endl; std::cout << "* " + greeting + " *" << std::endl; std::cout << first << std::endl; return 0; }

Framing a Name Variable definition Initialization CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 Framing a Name Variable definition Initialization Important! Use operator + for concatenation Custom operators do not change precedence, associativity, or number of arguments Constness Variable will not be changed Requires initialization

Framing a Name Initializing using special constructor CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 Framing a Name Initializing using special constructor std::string spaces(greeting.size(), ' '); Number of characters and character literal (' ') Quoting similar to string literals ('\t', etc.)

C++ std::string Models a sequence of characters CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 C++ std::string Models a sequence of characters std::string is defined as class (user defined) type Simple operations Member function size() returns number of chars operator[] to access individual characters C++ strings are mutable Operators on strings operator= assigns, makes new copy Compare with relational operators: <, <=, ==, >=, > Lexicographical ordering operator+ concatenates

CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 C++ std::string #include <iostream> // std::cout, std::endl #include <string> // std::string int main() { std::string s, t = "hello"; s = t; // s == "hello" std::cout << "Length: " << s.size() << std::endl; t[0] = 'j'; // t == "jello" s = s + ' '; // s == "hello " s += t; std::cout << s << std::endl; // prints: 'hello jello' return 0; }

CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 C++ std::string #include <iostream> // std::cout, std::endl #include <string> // std::string #include <cctype> // std::toupper #include <algorithm> // std::transform int main() { std::string s; s = "csc1254/1"; std::transform(s.begin(), s.end(), std::toupper); // converts to upper case std::cout << s << std::endl; // prints: CSC1254/1 return 0; }

CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 C++ std::string #include <iostream> // std::cout, std::endl #include <string> // std::string #include <algorithm> // std::sort int main() { std::string s; s = "hello John"; std::sort(s.begin(), s.end()); // sort all characters of the string std::cout << s << std::endl; // prints: ' ehhllooJ' return 0; }

C++ std::string member functions CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 C++ std::string member functions Invoke member functions as: str.function(args) Sample member functions: Return index of first occurrence or std::string::npos int find(char c, int pos) int find(std::string pattern, int pos) Return new string, copies len characters starting at pos std::string substr(int pos, int len) Changes string, inserts txt at pos void insert(int pos, std::string txt) Changes string, removes len characters starting at pos void erase(int pos, int len) Changes string, removes len characters starting at pos, inserts txt void replace(int pos, int len, std::string txt)

More String Details IO is using operator>> and operator<< CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 More String Details IO is using operator>> and operator<< os << s: output s to stream os without formatting changes evaluates to os is >> s: input s from stream is with whitespace handling evaluates to is Ways to initialize: std::string hello = "hello"; std::string stars(10, '*'); std::string name;

C++ strings vs. C strings CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 C++ strings vs. C strings C++ inherits legacy of old-style C string String literals are actually C strings (pointer to array of null terminated characters) Converting C string to C++ string Happens automatically in most cases Can be forced: std::string("abc") Converting C++ string to C string Using member function s.c_str() Why do we care Some older functionality requires use of C strings C strings are not compatible with concatenation

C++ strings vs. C strings CSC1254, Fall 2011, Strings 8/25/2011, Lecture 2 C++ strings vs. C strings Concatenation pitfalls If one operand is a C++ string, all is good std::string str = "Hello "; str = str + "John"; str = str + '!'; If both operands are C strings/characters, bad times "abc" + "def"; // won't compile "abc" + 'd'; // will compile, but do wrong // thing Can force conversion if needed std::string("abc") + 'd';