Rvalue vector

vector<int&&> v = {0,0,0};// Это не скомпилируется (Вектор, якобы, хранит rvalue)
vector<int> &&rval_vec = v; //Это не скомпилируется (Вектор, якобы, rvalue)

template <typename T, typename T2>
decltype(auto) foo(T& container, T2 index)
{
 
    return container[index]; 
}

foo(vector<int>{1,1,1,1,1,1,1,1,1,1}, 4) ; //rvalue отдаётся

template <typename T, typename T2>
decltype(auto) foo(T& container, T2 index)
{
 
    return container[index]; 
}
 
int main(){
   foo(vector<int>{1,1,1,1,1,1,1,1,1,1}, 4) = 25 ; //rvalue отдаётся, не компилируюсь. так и надо, 
                                                               //меняю на rvalue параметры функции,
                                                               //компилируется. ОК
   /*
Здесь нужно обратиться к элементу временного вектора и словить
   эффект висячей ссылки
*/
}

template <typename T, typename T2>
decltype(auto) foo(T&& container, T2 index)
{
    static_assert(std::is_lvalue_reference<T>::value, "T must be not rvalue");
    return container[index];
}

class MyContainer
{
    int data;
public:
    MyContainer() : data(0)
    {
        std::cout << "MyContainer() " << &data << std::endl;
    }
    MyContainer(MyContainer& r) : data(r.data)
    {
        std::cout << "MyContainer(MyContainer&)" << std::endl;
    }
    MyContainer(MyContainer&& r) : data(r.data)
    {
        std::cout << "MyContainer(MyContainer&&)" << std::endl;
    }
    ~MyContainer()
    {
        std::cout << "~MyContainer()" << std::endl;
    }
 
    int& getData() { return data; }
};
 
template<class T>
decltype(auto) foo(T& cont)
{
    std::cout << "In foo() " << &cont.getData() << std::endl;
    return cont.getData();
}
 
int main()
{
    int& ref = foo(MyContainer());
    std::cout << "Will modify " << &ref << std::endl;
    ref = 42;
}

class MyContainer : public std::vector<int>
{
public:
    MyContainer() : std::vector<int>(1, 1)
    {
        std::cout << "MyContainer() " << &(*this)[0] << std::endl;
    }
    MyContainer(const MyContainer& r) : std::vector<int>(r)
    {
        std::cout << "MyContainer(MyContainer&)" << std::endl;
    }
    MyContainer(MyContainer&& r) : std::vector<int>(r)
    {
        std::cout << "MyContainer(MyContainer&&)" << std::endl;
    }
    ~MyContainer()
    {
        std::cout << "~MyContainer()" << std::endl;
    }
};
 
template<class T>
decltype(auto) foo(T& cont)
{
    std::cout << "In foo() " << &cont[0] << " " << cont[0] << std::endl;
    return cont[0];
}
 
int main()
{
    int& ref = foo(MyContainer());
    std::cout << "Will modify " << &ref << " " << ref << std::endl;
    ref = 42;
    std::cout << "Now " << &ref << " " << ref << std::endl;
}

int& get_dangling_ref()
{
    int a = 10;
    return a;
}

template <typename T, typename T2>
decltype(auto) foo(T&& container, T2 index)
{
    return container[index];
}
 
int main()
{
    std::vector<int> v{1,2,3,4};
    foo(v, 0) = 42;
    std::cout << v.front();
    auto& good_ref = foo(v, 1);
    good_ref = 84;
    std::cout << v[1];
 
    auto& bad_ref = foo(std::vector<int>{1,2,3,4}, 0);
    bad_ref = 42;
}

#include <iostream>
#include <vector>
using namespace std;
 
template <typename T, typename T2>
decltype(auto) foo(T&& container, T2 index)
{
    return container[index];
}
 
int main()
{
    std::vector<int> v{1,2,3,4};
 
    int &ref = foo(vector<int>{1,2,3},2); //Ссылаюсь на элемент временного объекта, проблем нет. Должны же быть.
    cout << ref << '\n';
}