В чем отличие ссылочных переменных от указателей?

int a=5;
int &p=a;

int a=5;
int *p=&a;

#include <iostream>
 
int main()
{
    std::cout << "Hello, world!\n";
    
    std::cout <<"чем является результат разыменовывания указателя?\n";
    
    int* p;
    
    if(  std::is_reference<decltype(*p)>::value )
        std::cout <<"о боже! ссылка!\n";
    
}

#include <iostream>
 
struct X
{
    X(int& x):obj(x){}
    int& obj ;
};
 
 
 
struct Y
{
    Y(int& x):obj(x){}
    int obj ;
};
 
 
int main()
{
    int var ;
    X x(var) ;
    Y y(var) ;
    std::cout << sizeof(x) << std::endl ;
    std::cout << sizeof(y) << std::endl ;
}

void f(MyType &ob) {}
 
f(myObj);

#include <iostream>
 
template<class T>
void trololo(const T& ref)
{
    std::cout <<" is const? " 
        << std::is_const< decltype(ref)>::value 
            << std::endl;
}
 
int main()
{
    std::cout << "Hello, world!\n";
    const int v =10;
    trololo(v);
}

#include <memory>
#include <utility>
#include <functional>
 
template <typename T> 
struct Callable;
 
template <typename R, typename... Args> 
struct Callable <R(Args...)>
{
    virtual R operator()(const Args&...)const = 0;
};
 
template <typename T> 
class Function;
 
template <typename R, typename... Args> 
class Function<R(Args...)>
{
    typedef std::unique_ptr <Callable<R(Args...)>> 
        Ptr;
    
    Ptr ptr;
 
    template <typename T> struct Realisation : Callable<R(Args...)>
    {
        T t;
    public :
 
        // принимает по константной ссылке, хе хе
        R operator()(const Args&... args)const   
       // о обоже! константные данные передаются 
       // по неконстантной ссылке!!!!! КАРАУЛ!!!!!! 
            { return t(args...); }    
 
        Realisation () {}
        Realisation(T&& at) : t(std::move(at)) {}
    };
 
public :
    template <typename... Args1> 
    R operator()(Args1&&... args)const
        { return ptr->operator () (std::forward<Args1>(args)...); }
 
    Function(){}
    template <typename T>Function (T&& t): 
        ptr(std::make_unique<Realisation<T>>(std::move(t)))
    {}
};
 
int main()
{    
    Function<void(const char*)> f1 
        = [] (const char* a) { printf("%s\n", a); };
    
    f1("Hello, world!");
    
   // принимает мутабельную ссылку
    Function<void(int&)> f2 
        = [] (int& i) { ++i; };   
    
    int i = 5;
    f2(i);
    
    printf("int %d", i);
}

#include <iostream>
 
struct example
{
    
    example(  int (&src)[256]  )
        :arr(src)
    {
        if(  sizeof(*this)< sizeof(arr) )
            std::cout<<"о боже! но как же так!\n"
                "размер всего класса меньше,\n"
                "чем размер отдельного его члена\n";
    }
    
    int (&arr)[256];
};
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    
    int a[256];
    
    example ex(a);
}