const std::string& getName() {
    std::string name = "John";
    return name;  // 💥 Возвращаем ссылку на локальный объект
}

std::cout << getName() << "\n";  // UB: может напечатать мусор, может упасть

std::string getName() {
    std::string name = "John";
    return name;  // ок, RVO устранит копирование
}

void getName(std::string& out) {
    out = "John";
}

#include <iostream>
#include <string>

struct FunctionLogger {
    std::string func_name;
    FunctionLogger(const std::string& name) : func_name(name) {
        std::cout << ">> Entering: " << func_name << '\n';
    }
    ~FunctionLogger() {
        std::cout << "<< Exiting: " << func_name << '\n';
    }
};

#define LOG_FUNCTION() FunctionLogger logger(__FUNCTION__)

void do_work() {
    LOG_FUNCTION();
    // Работаем...
}

void assert_or_throw(bool cond, const std::string& msg) {
    if (!cond) throw std::runtime_error(msg);
}

template<typename T>
std::string to_string_precise(const T& val, int precision = 6) {
    std::ostringstream out;
    out << std::fixed << std::setprecision(precision) << val;
    return out.str();
}

template<typename F>
class ScopeExit {
    F func;
    bool active = true;
public:
    ScopeExit(F&& f) : func(std::forward<F>(f)) {}
    ~ScopeExit() { if (active) func(); }
    void dismiss() { active = false; }
};

template<typename F>
ScopeExit<F> scope_exit(F&& f) {
    return ScopeExit<F>(std::forward<F>(f));
}

template<typename T>
constexpr bool is_power_of_two(T x) {
    return x > 0 && (x & (x - 1)) == 0;
}

template<typename T>
void hash_combine(std::size_t& seed, const T& val) {
    seed ^= std::hash<T>()(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

std::vector<std::string> split(const std::string& str, char delimiter) {
    std::vector<std::string> out;
    std::istringstream ss(str);
    std::string token;
    while (std::getline(ss, token, delimiter)) {
        out.push_back(token);
    }
    return out;
}

template<typename T>
T clamp(T val, T min_val, T max_val) {
    return std::max(min_val, std::min(val, max_val));
}

template<typename Container, typename Predicate>
bool any_of(const Container& c, Predicate pred) {
    return std::any_of(c.begin(), c.end(), pred);
}

template<typename... Args>
std::string format(const std::string& fmt, Args&&... args) {
    return std::vformat(fmt, std::make_format_args(args...));
}

template<typename T>
std::string type_name() {
#ifdef __clang__
    std::string name = __PRETTY_FUNCTION__;
    return name.substr(31, name.length() - 32);
#elif defined(__GNUC__)
    std::string name = __PRETTY_FUNCTION__;
    return name.substr(49, name.length() - 50);
#elif defined(_MSC_VER)
    std::string name = __FUNCSIG__;
    return name.substr(38, name.length() - 45);
#else
    return "unknown";
#endif
}

void take(std::string s) {
    // s — копия, даже если передавали std::move
}

std::string str = "hello";
take(std::move(str)); // ❌ копирование, не перемещение

void take(std::string&& s) {
    // теперь s — это rvalue-ссылка
}

void take(std::string&& s) {
    process(s); // ❌ снова копия!
}

void process(std::string); // по значению

void take(std::string&& s) {
    process(std::move(s)); // ✅ перемещение
}

namespace math {
    struct Vec {};

    void print(const Vec&) {
        std::cout << "Vec\n";
    }
}

void foo() {
    math::Vec v;
    print(v); // компилятор найдёт math::print через ADL!
}

namespace lib {
    struct Widget {};
    void process(const Widget&) {
        std::cout << "lib::process\n";
    }
}

void process(int) {
    std::cout << "global::process\n";
}

void bar() {
    lib::Widget w;
    process(w); // вызовет lib::process, а не global::process!
}

std::vector<std::string> vec;
std::string str = "hello";

vec.emplace_back(str);             // копия
vec.emplace_back(std::move(str));  // перемещение

#include <string>

std::string make_string() {
    std::string s = "Hello";
    return s; // RVO или move
}

std::string make_string(bool flag) {
    std::string a = "foo", b = "bar";
    return flag ? a : b; // тут будет move
}

return std::move(flag ? a : b);

#include <memory>
#include <iostream>

struct Foo {
    Foo() { std::cout << "Init\n"; }
    ~Foo() { std::cout << "Destroy\n"; }
};

void bar() {
    std::unique_ptr<Foo> p = std::make_unique<Foo>(); // RAII
    // делаем что-то
} // тут автоматически вызовется ~Foo()

std::vector<bool> v{true, false, true};
bool* p = &v[0]; // Ошибка! Тут нет обычного bool*

std::vector<bool> v{true, false};
auto p = &v[0]; // ❌ Ошибка! Нет bool*

[[nodiscard]] int compute() {
    return 42;
}

int main() {
    compute(); // warning: ignoring return value
}

struct [[nodiscard]] Result {
    bool ok;
};

Result foo();
foo(); // warning!

auto old = value;
value = new_value;
return old;

#include <utility>
#include <string>
#include <iostream>

int main() {
    std::string s = "Hello";
    auto old = std::exchange(s, "World");

    std::cout << "old = " << old << ", s = " << s << '\n';
}

old = Hello, s = World

  MyType(MyType&& other)
      : data_(std::exchange(other.data_, nullptr)) {}
  

#include <utility>
#include <string>
#include <iostream>

template <typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg)); // сохраняет rvalue/lvalue-семантику
}

void process(const std::string& s) { std::cout << "Lvalue: " << s << '\n'; }
void process(std::string&& s) { std::cout << "Rvalue: " << s << '\n'; }

int main() {
    std::string str = "Hello";
    wrapper(str);               // Lvalue
    wrapper(std::move(str));    // Rvalue
}

#include <iostream>

#define LOG(var) std::cout << #var << " = " << (var) << std::endl;

int main() {
    int x = 42;
    double pi = 3.1415;

    LOG(x);   // x = 42
    LOG(pi);  // pi = 3.1415
}