Template list with indexing

#include <bits/stdc++.h>
using namespace std;
template<typename T>
class List;
template<typename T>

class reall{
    reall* next= nullptr;

    reall* priv = nullptr;

    T inf;

public:
    friend class  List<T>;

    explicit reall(const T& a);

};

template<typename T>
class List{
    int size=0;

    reall<T>* r= nullptr;

public:
    List ()= default;
    void addfirst(const T& u);

    void addlast(const T& u);

    void addin(const int& p,const T& u);

    void erazeL(const int& p);

    int& operator [](const int& a) {
        if (a < 0 || a >= size)
            throw;
        auto *w = r;
        if(a>size/2){
            w=w->priv;
            for(int i=size-1;i>=a;--i){
                if(i==a)
                    return w->inf;
                w=w->priv;
            }
        }
        for(int i=0;i<=a;++i){
            if(i==a)
                return w->inf;
            w=w->next;
        }
    }
    void show();

    int getsize();

    ~List();

};
int main(){
    List<int> l;
    l.addfirst(1);
    cout<<l[0]<<'\n';
    l[0]=5;
    l.addlast(3);
    l.show();
    l.addin(1,2);
    l.show();
    l.erazeL(1);
    l.show();
    l[0] = 0;
    l[1]=1;
    l.show();
    cout<<l.getsize();
}
template<typename T>
reall<T> ::reall(const T& a){
    this->inf=a;
}
template<typename T>
void List<T>:: addfirst(const T& u) {
    auto *w = new reall<T>(u);
    ++size;
    if (size == 1)
        r = w;
    else {
        w->priv = r;
        w->next = r->next;
        if(!w->next){
            w->next=r;
            r->priv = w;
        }
        if(r->next)
            r->next->priv=w;
        r->next = w;
        swap(r->inf,w->inf);
    }
}
template<typename T>
void List<T>::addlast(const T& u){
    auto *w = new reall<T>(u);
    ++size;
    if(size==1)
        r=w;
    else{
        w->priv=r->priv;
        if(!w->priv)
            w->priv=r;
        w->next=r;
        if(r->priv)
            r->priv->next=w;
        else
            r->next=w;
        r->priv=w;
    }
}
template<typename T>
void List<T>::addin(const int& p,const T& u){
    if(p<0 || p>size)return;
    if(p==0 || size==0) {
        addfirst(u);
        return;
    }
    if(p==size ) {
        addlast(u);
        return;
    }
    ++size;
    auto*q=r;
    auto *w = new reall<T>(u);
    for(int i=0;i<p;++i){
        if(i==p-1) {
            w->priv = q;
            w->next = q->next;
            q->next->priv = w;
            q->next = w;
        }
        q=q->next;
    }
}
template<typename T>
void List<T>::erazeL(const int& p){
    if(p>=size || p<0)return;
    --size;
    if(p==0){
        if(size==0){
            delete r;
            return;
        }
        auto* w=r->next;
        swap(r->inf,w->inf);
        if(size==1){
            r->next= nullptr;
            r->priv= nullptr;
            delete w;
            return;
        }
        w->next->priv=r;
        r->next=w->next;
        delete w;
    }
    else{
        auto* w=r;
        for(int i=0;i<=p;++i){
            if(i==p) {
                if(w->next)
                    w->priv->next=w->next;
                w->next->priv=w->priv;
                if(size==1){
                    r->next= nullptr;
                    r->priv= nullptr;
                }
                delete w;
            }
            w=w->next;
        }
    }
}
template<typename T>
List<T>::~List(){
    auto* w=r;
    for(int i=0;i<size;++i){
        w=w->next;
        delete r;
        r=w;
    }
}
template<typename T>
void List<T>::show(){
    auto* w=r;
    for(int i=0;i<size;++i){
        cout<<w->inf<<' ';
        w=w->next;
    }
    cout<<'\n';
}
template<typename T>
int List<T>::getsize(){
    return size;
}