In addition to the class tt(std::string) the class tt(std::string_view) can be
used as a wrapper-class of tt(char) arrays.  The class tt(string_view) can
be considered a light-weight tt(string) class.  Before using
tt(std::string_view) objects the tthi(string_view) header file must have been
included.

In addition to the standard constructors (default, copy, move) it offers the
following constructors:
    itemization(
    itt(constexpr string_view(char const *src, size_t nChars)), constructs a
tt(string_view) object from the first tt(nChars) characters of tt(src). The
characters in the range rangett(src, src + nChars) may be 0-valued
characters;

    itt(constexpr string_view(char const *src)), constructs a tt(string_view)
object from the NTBS starting at tt(src). The argument passed to this
constructor may not be a null pointer;

    itt(constexpr string_view(Iterator begin, Iterator end)), constructs a
tt(string_view) object from the characters in the iterator-range
rangett(begin, end).
    )
    A tt(string_view) object does not contain its own copy of the initialized
data. Instead, it refers to the characters that were used when it was
initially constructed. E.g., the following program produces unpredictable
output, but when the tt(hello) array is defined as a static array it shows
em(hello): 
    verb(    #include <string_view>
    #include <iostream>
    using namespace std;
    
    string_view fun()
    {
        char hello[] = "hello";
        return { hello };
    }
    
    int main()
    {
        string_view obj = fun();
        cout << obj << '\n';
    })

The tt(std::string_view) class provides the same members as tt(std::string),
except for members extending the tt(string_view's) characters (neither
appending nor inserting characters is possible). However, tt(string_view)
objects em(can) modify their characters (using the index operator or tt(at)
member).

The tt(string_view) class also offers some extra members:
    itemization(
    ithtq(remove_prefix)(remove_prefix(size_t step))
       (moves the begin of the object's character range forward by tt(step)
        positions.)
    ithtq(remove_suffix)(remove_suffix(size_t step))
       (moves the end of the object's character range backward by tt(step)
        positions.)
    ithtq(operator""sv)(constexpr string_view operator""sv(char const *str,
        size_t len))
       (returns a tt(string_view) object containing tt(len) characters of
        tt(str).)
    )

Like tt(std::string) the tt(std::string_view) class provides hashing
facilities, so tt(string_view) objects can be used as keys in, e.g., tt(map)
containers (cf. chapter ref(CONTAINERS)).

