особенности передачи по "&&"

#include <iostream>
void foo(const int&)
{    std::cout << "Hello! I'm foo(const int&)" << std::endl;  }
 
void foo(int&&)
{  std::cout << "Hello! I'm foo(int&&)" << std::endl; }
 
template <class T>
void bar(T&& t)
{     foo(t);  }
 
int main()
{   bar(42);
    return 0;
}

#include <iostream>
void foo(const int&)
{    std::cout << "Hello! I'm foo(const int&)" << std::endl;  }
 
void foo(int&&)
{  std::cout << "Hello! I'm foo(int&&)" << std::endl; }
 
void bar(int&& t) // убираем template
{    foo(t); }
int main()
{    int a = 42;
    bar(a); // cannot bind 'int' lvalue to 'int&&'
    return 0;
}

bar(42);

bar(std::move(a));

#include <iostream>
void foo(const int&)
{    std::cout << "Hello! I'm foo(const int&)" << std::endl;  }
void foo(int&&)
{  std::cout << "Hello! I'm foo(int&&)" << std::endl; }
template <class T>
void bar(T&& t)
{   foo(std::move(t));
    foo(std::forward<T>(t));
    foo(t);
}
int main()
{    int i=45;
    bar(42);  bar(i);
/*результат запуска:
Hello! I'm foo(int&&)    // std::move возвращает &&
 
Hello! I'm foo(int&&)      //forward возвратит && только если не сможет возвратить &
                           // в даннном случае(bar(42)) не смог => int&&
Hello! I'm foo(const int&) // ПОЧЕМУ!!!!!!!
 
Hello! I'm foo(int&&)      // std::move возвращает &&
 
Hello! I'm foo(const int&) //forward возвратит && только если не сможет возвратить &
                           // в даннном случае(bar(i)) смог => const int&
 
Hello! I'm foo(const int&) // изначально на этапе создания ф-ции из шаблона T&& превратилось в T&
                           // т.к. int i обладает адресом и является lvalue
*/
    return 0;
}

void foo(const int&){   } 
void foo(int&&){   }

#include <iostream>
 
class C
{
public:
   C() {}
   C(const C&)
   {
      std::cout << "copy" << std::endl;
   }
   C(C&&)
   {
      std::cout << "move" << std::endl;
   }
};
 
class Copyable
{
public:
   Copyable(C&& c) : obj(c)
   {
   }
private:
   C obj;
};
 
class Moveable
{
public:
   Moveable(C&& c) : obj(std::move(c))
   {
   }
private:
   C obj;
};
 
int main()
{
   Copyable copy{C()};
   Moveable move{C()};
}

#include <iostream>
#include <type_traits>
 
template <class T>
void bar(T&& t)
{   
    std::cout << std::boolalpha 
    << "is rvalue: " << std::is_rvalue_reference<decltype(t)>::value << std::endl
    << "is lvalue: " << std::is_lvalue_reference<decltype(t)>::value << std::endl;
}
int main()
{
    int i=45;
    
    bar(42);
    bar(i);
 
    return 0;
}