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

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

ref1 = ref2 // присваивает значение b в a, а не присваиваем ref1 адрес ref2, как хотелось бы. А что мешает?

std::cout << std::max(42, 43) << std::endl;

auto ptr = std::make_unique<int>(42);
std::cout << *ptr << std::endl;

template < class T > const T& max ( const T& a, const T& b );

The return type shall be a non-array object type, a reference type, or cv void.

If the postfix-expression names a destructor or pseudo-destructor, the type of the function call expression is void; otherwise, the type of the function call expression is the return type of the statically chosen function (i.e., ignoring the virtual keyword), even if the type of the function actually called is different...

auto p = std::unique_ptr<int>(42);
*p = 43;

__>auto p = std::unique_ptr<int>(42);
__>*p = 43;
__>

int n = 0;
n + 1;

let i = 0;
let k = 1;
let mut ref_i = &i;
ref_i = &k;

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;