#include <iostream>
#include <string>

bool startsWith(const std::string& s, const std::string& prefix)
{
    return s.substr(0, prefix.length()) == prefix;
}

int main()
{
    std::cout << std::boolalpha;
    std::cout << startsWith("Hello, World!", "Hello") << "\n";

    return 0;
}

#include <iostream>
#include <string>

// Ця функція лише читає рядок — вона нічого не змінює.
// Але через const std::string& вона все одно змушує компілятор
// створювати тимчасовий об'єкт при передачі C-рядка.
bool isEmail(const std::string& s)
{
    size_t at  = s.find('@');
    size_t dot = s.rfind('.');

    return at != std::string::npos
        && dot != std::string::npos
        && at < dot
        && at > 0
        && dot < s.length() - 1;
}

int main()
{
    // Варіант 1: передаємо C-рядковий літерал
    // → компілятор створює тимчасовий std::string("user@example.com")
    // → виділення пам'яті на купі (17 символів > SSO 15)
    std::cout << isEmail("user@example.com") << "\n";  // true

    // Варіант 2: передаємо std::string — копіювання через & не відбувається, але
    // якщо б параметр був не посиланням, а значенням (std::string s) — копія неминуча
    std::string addr = "admin@company.org";
    std::cout << isEmail(addr) << "\n"; // true

    // Варіант 3: у нас є char* з зовнішнього API
    char buf[] = "noreply@mail.ua";
    std::cout << isEmail(buf) << "\n"; // true — ще одна тимчасова копія

    return 0;
}

#include <iostream>
#include <string>
#include <string_view>

int main()
{
    std::string_view sv1 = "Hello, World!"; // з рядкового літерала
    std::string       s  = "Hello, World!";
    std::string_view sv2 = s;              // з std::string

    // Базові запити — ті самі, що й у std::string
    std::cout << "length:  " << sv1.length()  << "\n"; // 13
    std::cout << "empty:   " << std::boolalpha << sv1.empty() << "\n"; // false
    std::cout << "front:   " << sv1.front()   << "\n"; // H
    std::cout << "back:    " << sv1.back()    << "\n"; // !
    std::cout << "sv1[4]:  " << sv1[4]        << "\n"; // o

    // Розмір самого об'єкта — лише ptr + length
    std::cout << "sizeof(sv1): " << sizeof(sv1) << "\n"; // 16 (на 64-bit)
    std::cout << "sizeof(s):   " << sizeof(s)   << "\n"; // 32

    return 0;
}

#include <iostream>
#include <string>
#include <string_view>

int main()
{
    // 1. З рядкового літерала (найпоширеніше)
    std::string_view sv1 = "Hello";
    std::cout << sv1 << "\n"; // Hello

    // 2. З об'єкта std::string (неявна конвертація — дозволена)
    std::string str = "World";
    std::string_view sv2 = str;
    std::cout << sv2 << "\n"; // World

    // 3. З char* та явної довжини — для не-нуль-термінованих буферів
    char vowels[] = {'a', 'e', 'i', 'o', 'u'}; // немає '\0'!
    std::string_view sv3(vowels, 5);
    std::cout << sv3 << "\n"; // aeiou

    // 4. З char[] — вся довжина автоматично
    char buf[] = "C++ is great";
    std::string_view sv4 = buf;
    std::cout << sv4 << "\n"; // C++ is great

    // 5. Копіювання string_view — не копіює дані, лише ptr+length
    std::string_view sv5 = sv1; // sv5 вказує на той самий літерал "Hello"
    std::cout << sv5 << "\n"; // Hello

    return 0;
}

#include <iostream>
#include <string_view>

int main()
{
    std::string_view sv = "Hello, World! 12345";

    // Доступ до символів
    std::cout << sv[0]     << "\n"; // H
    std::cout << sv.at(1)  << "\n"; // e
    std::cout << sv.front()<< "\n"; // H
    std::cout << sv.back() << "\n"; // 5

    // Метрики
    std::cout << sv.length() << "\n"; // 19
    std::cout << sv.empty()  << "\n"; // 0 (false)

    // Пошук — ті самі методи, що у std::string
    size_t comma = sv.find(',');
    std::cout << "Кома на позиції: " << comma << "\n"; // 5

    size_t firstDigit = sv.find_first_of("0123456789");
    std::cout << "Перша цифра на: " << firstDigit << "\n"; // 14

    // substr — повертає string_view (не std::string!), без копіювання
    std::string_view word = sv.substr(7, 5);
    std::cout << "Слово: " << word << "\n"; // World

    // Порівняння
    std::cout << std::boolalpha;
    std::cout << (sv == "Hello, World! 12345") << "\n"; // true
    std::cout << sv.starts_with("Hello")       << "\n"; // true (C++20)
    std::cout << sv.ends_with("12345")         << "\n"; // true (C++20)

    return 0;
}

#include <iostream>
#include <string_view>

int main()
{
    std::string_view sv = ">>>Hello<<<";
    std::cout << sv << "\n"; // >>>Hello<<<

    sv.remove_prefix(3); // відсунути початок на 3
    std::cout << sv << "\n"; // Hello<<<

    sv.remove_suffix(3); // скоротити кінець на 3
    std::cout << sv << "\n"; // Hello

    // Практичний приклад: trim без виділення пам'яті
    std::string_view padded = "   Hello, World!   ";

    size_t start = padded.find_first_not_of(" \t");
    size_t end   = padded.find_last_not_of(" \t");

    // Замість substr + копіювання — звужуємо вікно
    padded.remove_prefix(start);
    padded.remove_suffix(padded.length() - end - 1);

    std::cout << "'" << padded << "'\n"; // 'Hello, World!'

    return 0;
}

#include <iostream>
#include <string_view>
#include <cstring> // strlen

int main()
{
    // Безпечний випадок: sv вказує на літерал, який має '\0'
    std::string_view sv1 = "Hello";
    std::cout << std::strlen(sv1.data()) << "\n"; // 5 — ОК, бо '\0' є

    // Небезпечний випадок: після remove_prefix '\0' вже не на правильному місці
    std::string_view sv2 = "Hello, World!";
    sv2.remove_prefix(7); // sv2 = "World!" — але data() вказує на 'W', '\0' є в кінці
    std::cout << std::strlen(sv2.data()) << "\n"; // 6 — ОК в цьому конкретному випадку

    // СПРАВДІ небезпечний випадок: substr з масиву без '\0'
    char buf[] = {'H', 'e', 'l', 'l', 'o', 'X', 'Y', 'Z'};
    std::string_view sv3(buf, 5); // "Hello" — length=5, але НЕМАЄ '\0' після 'o'!
    // НЕБЕЗПЕЧНО: strlen читатиме 'X', 'Y', 'Z' і далі, поки не знайде '\0'
    // std::cout << std::strlen(sv3.data()); // UB — читання за межами

    std::cout << "sv3 через cout: " << sv3 << "\n"; // OK — cout знає length
    std::cout << "sv3 length:     " << sv3.length() << "\n"; // 5

    return 0;
}

#include <iostream>
#include <string>
#include <string_view>

std::string_view dangerousFunction()
{
    std::string local = "I am local"; // об'єкт на стеку функції
    return local; // ПОМИЛКА: повертаємо string_view на локальний std::string,
                  // який буде знищений при виході з функції!
}

int main()
{
    std::string_view sv = dangerousFunction();
    // sv тепер вказує на звільнену пам'ять!
    // Будь-яке звернення до sv — невизначена поведінка (UB)
    std::cout << sv << "\n"; // UB: може вивести сміття, завершитись із помилкою, "спрацювати"
    return 0;
}

#include <iostream>
#include <string>
#include <string_view>

int main()
{
    // ПОМИЛКА: std::string("temporary") — тимчасовий об'єкт
    // Він буде знищений в кінці цього оператора присвоювання.
    // sv продовжить вказувати на звільнену пам'ять.
    std::string_view sv = std::string("temporary"); // UB!

    std::cout << sv << "\n"; // UB

    return 0;
}

#include <iostream>
#include <string>
#include <string_view>

int main()
{
    std::string s = "Hello";
    std::string_view sv = s; // sv вказує на внутрішній буфер s

    std::cout << sv << "\n"; // Hello — ОК

    // Модифікуємо рядок: якщо відбудеться перевиділення пам'яті,
    // sv стане dangling view!
    s += " World, this is a long string that exceeds SSO boundary!";
    // s перевиділила буфер — старий буфер звільнено.
    // sv.data() тепер вказує на звільнену пам'ять.

    std::cout << sv << "\n"; // UB: dangling view
    return 0;
}