class std::string_view in C++17

// C++ program to demonstrate the
// problem occurred in string
#include <iostream>
#include <string>
using namespace std;

// Driver Code
int main()
{
    char str_1[]{ "Hello !!, GeeksforGeeks" };

    string str_2{ str_1 };
    string str_3{ str_2 };

    // Print the string
    cout << str_1 << '\n'
         << str_2 << '\n'
         << str_3 << '\n';

    return 0;
}

// C++ program to implement
// the above approach
#include <iostream>
using namespace std;
#include <string_view>

// Driver code
int main()
{
    // View the text "hello", which is
    // stored in the binary
    string_view str_1{ "Hello !!, GeeksforGeeks" };

    // View of the same "hello"
    string_view str_2{ str_1 };

    // View of the same "hello"
    string_view str_3{ str_2 };

    std::cout << str_1 << '\n' << str_2 << '\n' << str_3 << '\n';
    return 0;
}

// C++ program for the above approach
#include <iostream>
#include <string>
#include <string_view>
using namespace std;

string_view sur_name(wstring_view x)
{
    return x.substr(6);
}

// Driver Code
int main()
{
    // Basic_string_view<wchar_t> wstr
    // (L"Madhav_Mohan"); both are equivalent
    const wchar_t* str1{ L"Madhav_Mohan" };

    cout << your_name(str1);

    return 0;
}

// C++ program to implement
// the above approach
#include <iostream>
#include <string_view>
using namespace std;

string to_alpha(int r)
{
    if (r < 0)
        return " less than ";
    else if (r == 0)
        return " equal to ";
    else
        return " greater than ";
}

// Driver code
int main()
{
    char str{ "Muddy" };
    char str_1{ "Maddy" };

    string_view str_2{ str_1 };

    // This line prints Maddy
    cout << str_2 << '\n';

    // Change 'M' to 'D' in arr
    str_1[0] = 'D';

    // This line prints Daddy
    cout << str_2 << '\n';

    cout << str_2.at(2);
    cout << str_2.back();
    cout << " is last char of str_2 is y " << (str_2.back() == 's');
    cout << " is last char of str_2 is y " << boolalpha << (str_2.back() == 's');

    // In above statement boolalpha is
    // used to  give the boolean result
    // in True or False

    int cmp{ str_1.compare(str_2) };

  cout << to_alpha(cmp
};
int cmp_1 = str.compare(1, 4, str_2);
cout << "last three characters of str are" << to_alpha(cmp_1) << "str_2.\n";
return 0;
}

// C++ program to implement
// the above approach
#include <iostream>
#include <iterator>
#include <string_view>
using namespace std;

// Driver code
int main()
{
    string_view str_1{ "Maddy" };
    cout << str_1 << '\n';

    string_view str_2{ "Daddy" };
    cout << str_2 << '\n';

    string_view var{ "Hello !!, GeeksforGeeks" };
    cout << var << '\n';

    cout << var.starts_with("Hi !!") << '\n';
    cout << var.ends_with("GeeksforGeeks !!") << '\n';

    // Remove the first characters.
    str_1.remove_prefix(1);
    cout << str_1 << '\n';

    // Remove the last 2 characters.
    str_1.remove_suffix(2);
    std::cout << str_1 << '\n';

    return 0;
}

// C++ program to implement the
// above approach
#include <array>
#include <cstddef>
#include <iostream>
#include <stdexcept>
#include <string>
#include <string_view>
using namespace std;

// Driver code
int main()
{
    constexpr string_view str{ "Daddy" };
    constexpr string_view str1{ "Maddy" };
    string str2{};

    // Copy data of str1 into str2
    str1.copy(str2.data(), 4);

    // This line prints Madddy
    cout << str2.data() << '\n';

    if ((str.compare(str2)) != 0)
        cout << str << " "
             << "doesn't = to"
             << " " << str1 << '\n';
    cout << str1.starts_with("Mad");
    cout << '\n'
         << str.starts_with("Pad") << '\n';
    cout << str1.ends_with("ddt");
    cout << '\n'
         << str.ends_with("ddy") << '\n';

    // Checks whether the given string contains
    // the given substring or character
    constexpr string_view s1{ "Hello! Madhav" };

    // Position of the first character that
    // match first
    constexpr string_view str3{ "Hi! Maddy" };

    size_t found = str3.find(str1);
    cout << found << '\n';

    // Find the last occurrence of a substring
    cout << '\n'
         << str3.rfind('d');

    // Gives the first time occurred char's position
    cout << '\n'
         << str3.find_first_of("d");

    // Gives the last time occurred char's position
    cout << '\n'
         << str3.find_last_of("d");

    // Finds the first char that's not equal to
    // any of the char(s) in the given string
    cout << '\n'
         << str3.find_last_not_of(str, 6);

    // It givesIndex of first unmatched character
    // when successful or string::npos if no such
    // character found. It searches for the first
    // char that doesn't match any of the char(s)
    // that has given in the argument
    cout << '\n'
         << str3.find_last_not_of(str, 4);

    return 0;
}

// C++ program to implement
// the above approach
#include <iostream>

// For std::size
#include <iterator>
#include <string_view>
using namespace std;

// Driver code
int main()
{
    // No null-terminator.
    char name[]{ 'M', 'a', 'd',
                 'h', 'a', 'v' };

    // Here name isn't null-terminated.
    // We need to pass the length manually.
    // Because name is an array, we can
    // use std::size to get its length.
    string_view str_1{ \name, size(name) };

    // This is safe and cout knows how to
    // print std::string_views.
    cout << str_1 << '\n';

    return 0;
}

// C++ program to implement
// the above approach
#include <iostream>
#include <string>
#include <string_view>
using namespace std;

void print(string s)
{
    cout << s << '\n';
}

// Driver code
int main()
{
    string_view str_1{ "Madhav" };
    str_1.remove_suffix(3);

    // compile error: won't implicitly
    // convert
    // print(str_1);

    // explicit conversion
    string str_2{ str_1 };

    print(str_2);

    // It'll work
    print(static_cast<string>(str_1));

    return 0;
}

// C++ program to implement
// the above approach
#include <cstring>
#include <iostream>
#include <string>
#include <string_view>

// Driver code
int main()
{
    string_view str_1{ "Madhav" };
    str_1.remove_suffix(3);

    // Create a std::string from
    // the std::string_view
    string str_2{ str_1 };

    // A Null_terminated C-style string.
    auto Null_Terminated{ str_2.c_str() };

    // Pass the null-terminated string
    // to the function that we want to use.
    cout << str_2 << " has " << strlen(Null_Terminated) << " letter's\n";

    return 0;
}

// C++ program to implement
// the above approach
#include <iostream>
#include <string>
#include <string_view>
using namespace std;

string_view ask_name()
{
    cout << "Write your surname?\n";

    // A std::string is needed, because
    // std::cin needs to modify it.
    string str_1{};
    cin >> str_1;

    // Pass str_1 to std::string_view
    string_view str_2{ str_1 };

    cout << str_2 << '\n';

    // str_1 dies, and so does the
    // string that str created.
    return str_2;
}

// Driver code
int main()
{
    std::string_view str_2{ ask_name() };

    // str_2 is observing a string that
    // already died.

    // Undefined behavior you'll observe
    cout << your surname is << str_2 << '\n';

    return 0;
}

// C++ program to implement
// the above approach
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
#include <string_view>

// Driver code
int main()
{
    string str{ "Madhav_Mohan" };
    string_view str1{ str.data() };
    cout << str1 << endl;
    string_view str2{ str1.substr(6) };
    string_view str3{ str2 };
    cout << str3;
    return 0;
}