Разработать шаблонный класс Deque c разными методами

#include <iostream>
#include <string>
 
template<class T>
class Deque {
    struct node {
        node* prev, *next;
        T     val;
        node(void) noexcept : prev(nullptr), next(nullptr){}
        node(const T& v): prev(nullptr), next(nullptr), val(v){}
    };
private:
    node* hd, *tl;
public:
    Deque(void) noexcept : hd(nullptr), tl(nullptr){}
    ~Deque(){ Clear(); }
 
    Deque(const Deque&) = delete;
    Deque& operator = (const Deque&) = delete;
public:
    //вставка в начало
    void addBegin(const T& v){ add_beg(new node(v)); }
 
    void addBegin(T&& v){
        node* p = new node();
        p->val  = std::forward<T>(v);
        add_beg(p);
    }
 
    //вставка в конец
    void addEnd(const T& v){ add_end(new node(v)); }
 
    void addEnd(T&& v){
        node* p = new node();
        p->val  = std::forward<T>(v);
        add_end(p);
    }
 
    //удалить первый
    T outBegin(void){
        T v = hd->val;
        pop_beg();
        return v;
    }
 
    void popBegin(void){ pop_beg(); }
 
    //удалить последний
    T outEnd(void){
        T v = tl->val;
        pop_end();
        return v;
    }
 
    void popEnd(void){ pop_end(); }
 
    //удаление всех
    void Clear(void){
        node* p;
        while(hd != nullptr){
            p  = hd;
            hd = hd->next;
            delete p;
        }
        tl = nullptr;
    }
 
    //кол-во
    size_t getCount(void) const noexcept {
        size_t i = 0;
        for(const node* p = hd; p != nullptr; p = p->next)
            ++i;
        return i;
    }
 
    T& Begin(void){ return hd->val; }
    const T& Begin(void) const { return hd->val; }
 
    T& End(void) { return tl->val; }
    const T& End(void) const { return tl->val; }
 
    bool isEmpty(void) const noexcept { return (hd == nullptr); }
private:
    void add_beg(node* p) noexcept {
        if(hd == nullptr)
            hd = tl = p;
        else {
            hd->prev = p;
            p->next  = hd;
            hd = p;
        }
    }
 
    void add_end(node* p) noexcept {
        if(hd == nullptr)
            hd = tl = p;
        else {
            p->prev  = tl;
            tl->next = p;
            tl = p;
        }
    }
 
    void pop_beg(void){
        node* p = hd;
        if((hd = hd->next) != nullptr)
            hd->prev = nullptr;
        else
            tl = nullptr;
        delete p;
    }
 
    void pop_end(void){
        node* p = tl;
        if((tl = tl->prev) != nullptr)
            tl->next = nullptr;
        else
            hd = nullptr;
        delete p;
    }
};
 
int main(void){
    Deque<int> di;
    for(int i = 0; i < 10; ++i){
        di.addBegin(i);
        di.addEnd(i);
    }
 
    while(!di.isEmpty())
        std::cout << di.outBegin() << ' ';
    std::cout << std::endl;
 
    //...
 
    Deque<std::string> ds;
    ds.addBegin("ALGOL");
    ds.addBegin("PASCAL");
 
    std::string s1("JAVA2");
    ds.addBegin(std::move(s1));
 
    std::string s2 = "FORTRAN";
    ds.addEnd(std::move(s2));
    ds.addEnd("PYTHON");
 
    while(!ds.isEmpty()){
        std::cout << ds.End() << std::endl;
        ds.popEnd();
    }
    std::cin.get();
    return 0;
}