let a = "объект с данными в куче".to_string();
// объект передан переменной b
// переменная a становится неинициализированной
let b = a;
// ошибка!
let c = a;

template<typename T, typename Pred>
std::optional<T&> find(std::vector<T> const& vec, Pred&& pred);

BFE>let a = "объект с данными в куче".to_string();
BFE>// объект передан переменной b
BFE>// переменная a становится неинициализированной
BFE>let b = a;
BFE>// ошибка!
BFE>let c = a;
BFE>

auto a = std::string {"abc"};
auto b = std::move(a);
auto c = std::move(a);

SP>template<typename T, typename Pred>
SP>std::optional<T&> find(std::vector<T> const& vec, Pred&& pred);
SP>

template<typename T, typename Pred>
std::optional<std::reference_wrapper<T>> find(std::vector<T> const& vec, Pred&& pred);

SP>template<typename T, typename Pred>
SP>std::optional<T&> find(std::vector<T> const& vec, Pred&& pred);
SP>

template<typename T, typename Pred>
T* find(std::vector<T> const & vec, Pred&& pred);

BFE>template<typename T, typename Pred>
BFE>std::optional<std::reference_wrapper<T>> find(std::vector<T> const& vec, Pred&& pred);
BFE>

using Map = std::vector<std::string_view>;
using Opt = std::optional<std::reference_wrapper<Map::value_type>>;
 
Opt find(Map& m, std::string_view s)
{
    auto it = std::find(m.begin(), m.end(), s);
    return it == m.end() ? Opt{} : Opt{*it};
}

int main(int argc, char* argv[]) {
    Map vec = {"123", "234"};

    auto tmp = std::string_view{"123"};
    std::cout << find(vec, tmp).value_or(std::ref(tmp)).get();
}

std::optional<T> r = try_get_object();
if(r) r->do_something();

alignas(T) std::byte storage[sizeof(T)];
T * obj = new(storage) T{...};
...
obj->~T();

template<typename T, typename Pred>
optional<std::vector<T>::size_type> find(std::vector<T> const & vec, Pred&& pred);

BFE>>template<typename T, typename Pred>
BFE>>std::optional<std::reference_wrapper<T>> find(std::vector<T> const& vec, Pred&& pred);
BFE>>

SP>я уже ел этот кактус, повторно не предлагать

SP>using Map = std::vector<std::string_view>;
SP>using Opt = std::optional<std::reference_wrapper<Map::value_type>>;
 
SP>Opt find(Map& m, std::string_view s)
SP>{
SP>    auto it = std::find(m.begin(), m.end(), s);
SP>    return it == m.end() ? Opt{} : Opt{*it};
SP>}

SP>int main(int argc, char* argv[]) {
SP>    Map vec = {"123", "234"};

SP>    auto tmp = std::string_view{"123"};
SP>    std::cout << find(vec, tmp).value_or(std::ref(tmp)).get();
SP>}
SP>

    const std::vector<std::string_view> vec = {"123", "234", "4", "567", "321"};
    unsigned int nCount = 0; // счётчик найденных
    auto fnOut = [&nCount](const auto& x){ std::cout << '\n' << x; ++nCount;}; // вывод и подсчёт
    std::ranges::find_if(
                          vec, // никаких begin/end
                          [
                            n = 2, // искать не больше двух
                            &fn = fnOut // операция над найденным
                          ]
                          (const auto& x) mutable 
                          { 
                             if (x.contains('3')) // только элементы содержащие '3'
                             {
                                --n;  // изменили счётчик
                                fn(x);// применили операцию 
                             }
                             return 0 == n; // условие останова
                           }
                         );
    std::cout << '\n' << "Total: " << nCount << " element(s)";

auto tmp = std::string_view{"123"};
std::cout << find(vec, tmp).value_or(std::ref(tmp)).get();

нельзя использовать временный объект. std::ref не конструируется от временного
приходится заводить бессмысленную переменную tmp
нужно дополнительно вызывать get()

find(vec, "123").transform(handle).value_or(def_val);

SP>find(vec, "123").transform(handle).value_or(def_val);
SP>

#include <utility>
#include <iostream>
#include <string>
#include <optional>
#include <vector>
#include <algorithm>

using Map = std::vector<std::string_view>;
using Opt = std::optional<std::reference_wrapper<Map::value_type>>;
 
const std::string_view& find(Map& m, std::string_view s, const std::string_view& sDefault)
{
    auto it = std::find(m.begin(), m.end(), s);
    return it == m.end() ? sDefault : *it;
}

int main(int argc, char* argv[]) {
    Map vec = {"123", "234"};

    auto tmp = std::string_view{"123"};
    std::cout << find(vec, tmp, "not found");

    return 0;
}

int& ref = some.complicated[lvalue->expression];

if(ref==-1) ref = current_iteration;

int a = 10;
int b = 20;
int* ref1 = a;
int* ref2 = b;

// как то сделать, чтобы ref1 и ref2 ссылались на одну область памяти

ref1 = ref2;