#include <concepts>
#include <iostream>

int main()
{
    int a[2] {10, 20};
    
    auto [x, y] = a;
    auto& [xr, yr] = a;
    auto& r = a[0]; // Заведем рядом обычную ссылку, для сравнения
    
    static_assert(std::same_as<int&, decltype(r)>);   // int& - Вопросов нет.
    static_assert(std::same_as<int, decltype(x)>);    // int - Тоже понятно.
    static_assert(std::same_as<int, decltype(xr)>);   // Тоже int! А вот тут удивляюсь :-)

    // При этом xr и уr ведут себя как ссылки, как и ожидается:
    xr *= 10;
    yr *= 10;
    std::cout << a[0] << ", " << a[1] << std::endl; // -> 100, 200
}

an lvalue that refers to the element i of the array

R>#include <concepts>
R>#include <iostream>

R>int main()
R>{
R>    int a[2] {10, 20};
    
R>    auto [x, y] = a;
R>    auto& [xr, yr] = a;
R>    auto& r = a[0]; // Заведем рядом обычную ссылку, для сравнения
    
R>    static_assert(std::same_as<int&, decltype(r)>);   // int& - Вопросов нет.
R>    static_assert(std::same_as<int, decltype(x)>);    // int - Тоже понятно.
R>    static_assert(std::same_as<int, decltype(xr)>);   // Тоже int! А вот тут удивляюсь :-)

R>    // При этом xr и уr ведут себя как ссылки, как и ожидается:
R>    xr *= 10;
R>    yr *= 10;
R>    std::cout << a[0] << ", " << a[1] << std::endl; // -> 100, 200
R>}
R>

int b[2] {10, 20};

std::pair<int, int&> GetB()
{
    return std::pair<int, int&>{b[0], b[1]};
}

int main()
{
    //-----------------------------------------------------------
    {
    auto [b0, b1] = GetB();
    
    static_assert(std::same_as<int, decltype(b0)>); 
    static_assert(std::same_as<int&, decltype(b1)>);
    
    b0 *= 10;
    b1 *= 10;
    std::cout << b[0] << ", " << b[1] << std::endl; // -> 10, 200
    }
    //-----------------------------------------------------------
    {
    const auto& [rb0, rb1] = GetB(); // const - чтобы продлить время жизни возвращённого объекта
    
    static_assert(std::same_as<const int, decltype(rb0)>); 
    static_assert(std::same_as<int&, decltype(rb1)>);
    
    //rb0 *= 10; // константа
    rb1 *= 10;
    std::cout << b[0] << ", " << b[1] << std::endl; // -> 10, 2000
    }
    //-----------------------------------------------------------
    {
    const auto [cb0, cb1] = GetB();
    
    static_assert(std::same_as<const int, decltype(cb0)>); 
    static_assert(std::same_as<int&, decltype(cb1)>); // сюрприз !
    
    //cb0 *= 10;// константа
    cb1 *= 10;
    std::cout << b[0] << ", " << b[1] << std::endl; // -> 10, 20000
    } 
}

    int x;
    static_assert(std::is_same_v<decltype( x          ), int  >);  // тип объявления x - это int
    static_assert(std::is_same_v<decltype( (x)        ), int& >);  // хотя в любых выражениях, включая тривиальные, x доступен по ссылке

    struct S { int y; int& z; } s {.z = x};

    static_assert(std::is_same_v<decltype( s.y        ), int  >);  // поле объявлено как int
    static_assert(std::is_same_v<decltype( s.z        ), int& >);  // поле объявлено как int&

    static_assert(std::is_same_v<decltype( (s.y)      ), int& >);  // выражение (в скобках)
    static_assert(std::is_same_v<decltype( (s).y      ), int  >);  // поле результата выражения - это всё ещё поле
    static_assert(std::is_same_v<decltype( (&s)->y    ), int  >);  // поле результата выражения (разыменования по стрелке) - опять поле
    static_assert(std::is_same_v<decltype( s.*(&S::y) ), int& >);  // а вот разыменование указателя на член - это выражение

int value = 42;

static_assert(std::same_as<int, decltype(value)>);
static_assert(std::same_as<int&, decltype((value))>);