Beginner's Guide
    First Steps
    Input & Output
    Custom Types – Part 1
    Standard Library – Part 1
    Function Objects
    Standard Library – Part 2
    Code Organization
    Custom Types – Part 2
    Generic Programming
    Memory Management
    Software Design Basics

    Strings (Basics) Strings (Basics) Strings

    std::string std::string

    • dynamic array of char (similar to vector<char>)
    • concatenation with + or +=
    • single character access with [index]
    • modifiable ("mutable") unlike in e.g., Python or Java
    • regular: deeply copyable, deeply comparable
    #include <string>
    std::string hw = "Hello";
    std::string s = hw;     // copy of hw
    hw += " World!";
    cout << hw << '\n';     // Hello World!
    cout << hw[4] << '\n';  // o
    cout << s << '\n';      // Hello

    char = std::string's Element Type char char

    • one char can hold a single character
    • smallest integer type (usually 1 byte)
    • char literals must be enclosed in single quotes: 'a', 'b', 'c', …
    char c1 = 'A';   
    char c2 = 65;  // ASCII code of 'A'
    cout << c1 << '\n';          // A
    cout << c2 << '\n';          // A
    cout << (c1 == c2) << '\n';  // 1
    std::string s = "xyz"; s[1] = c1; cout << s << '\n'; // xAz s += c2; cout << s << '\n'; // xAzA

    Special Characters

    backslash \ acts as escape character
    \n new line "Line1\nLine1\nLine3"
    \t tab "Column1\tColumn1\tColumn3"
    \' single quote "he said \'quote\' to me"
    \" double quote "he said \"quote\" to me"
    \\ backslash itself "C:\\Users\\me\\hello.cpp"

    std::string Manipulation Manipulation


    "C string Literal" "..."

    auto a = "seven of";  // type of a is char const[]
    auto b = a;           // b refers to same object as a// refers to same object
    a += " nine"; // COMPILER ERROR: can't be modified auto c = "al" + "cove"; // COMPILER ERROR
    std::string s = a; // a is copied into s s += " nine"; // (s is std::string)

    "std::string Literal"s C++14 "..."s

    #include <string>
    using namespace std::string_literals;
    auto s1 = "seven of"s; // type of s1 is std::string auto s2 = s1; // s2 is a copy of s1
    s1 += " nine"; // cout << s1 << '\n'; // seven of nine cout << s2 << '\n'; // seven of
    auto s3 = "uni"s + "matrix"s; // cout << s3 << '\n'; // unimatrix

    Joining  "first" "second"  ⇒  "first second"

    Raw String Literals R"(...)" Raw

    Advantage: special characters can be used without escaping

    R"(raw "C"-string c:\users\joe)" char const[] C++11
    R"(raw "std"-string c:\users\moe)"s std::string C++14


    where DELIMITER can be a sequence of 0 to 16 characters except spaces, (, ) and \

    String-Like Function Parameters String-Like Parameters Parameters

    • lightweight  (= cheap to copy, can be passed by value)
    • non-owning  (= not responsible for allocating or deleting memory)
    • read-only view  (= does not allow modification of target string)
    • of a string(-like) object  (std::string / "literal" / …)
    • primary use case: read-only function parameters
    #include <string>
    #include <string_view>
    int edit_distance (std::string_view s1,              std::string_view s2) {  }
    std::string input = "abx";
    int dist = edit_distance("abc", input);
    • avoids expensive temporary strings when string literals are passed to functions
    • can speed up accesses by avoiding a level of indirection:

      shows that string_view can have one fewer indirection than a const reference to the actual string storage

    We will learn more about string_view and other view types later.

    If You…

    Use Parameter Type

    always need a copy of the input string inside the function std::string
    pass by value
    want read-only access
    • don't (always) need a copy
    • are using C++17 / 20
    #include <string_view> std::string_view
    want read-only access
    • don't (always) need a copy
    • are stuck with C++98 / 11 / 14
    std::string const&
    pass by const reference
    want the function to modify the input string in-place (you should try to avoid such output parameters) std::string &
    pass by (non-const) reference

    std::getline getline

    • read entire lines / chunks of text at once
    • target string can be re-used (saving memory)
    std::string s;
    getline(std::cin, s);        // read entire line
    getline(std::cin, s, '\t');  // read until next tab
    getline(std::cin, s, 'a');   // read until next 'a'