Организовать двухсторонний список, в котором хранится текст

#include <stdio.h>
#include <iostream>
#include <string>
 
using namespace std;
 
void keep_window_open()
{
    cin.clear();
    cout << "Please enter a character to exit\n";
    char ch;
    cin >> ch;
    return;
}
 
class Node
{
    static Node *Head ;
    static Node *last ;
    Node *next;
    Node *prev;
    string info;
public:
    Node();
    Node(char *prt);
    void addinfo(char *prt);
    void addNode();
    void displayAll();
};
void Node::addNode()
{
    if (Head==NULL)
    {
        Head=this;
        last=this;
        next=NULL;
        prev=NULL;
    }
    else 
    {
        prev=last;
        last=this;
        prev->next=this;
        next=NULL;
    }
}
void Node::addinfo(char *prt)
{
    info=string(prt);
}
 
void Node::displayAll()
{
}
 
Node::Node()
{
    next=NULL;
    prev=NULL;
}
 
Node::Node(char *prt)
{
    next=NULL;
    prev=NULL;
    addinfo(prt);
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    Node a("1"), b("2"), c("3"), d("4");
    a.addNode();
    b.addNode();
    c.addNode();
    d.addNode();
    keep_window_open();
    return 0;
}

#include <iostream>
 
class CharList
{
public:
    typedef size_t size_type;
    typedef char value_type;
    
public:
    CharList():
    m_head(new Node()),
    m_tail(m_head),
    m_size()
    {
    }
    
    CharList(const CharList& source):
    m_head(new Node()),
    m_tail(m_head),
    m_size()
    {
        Node *i = source.m_head;
        
        while (i != source.m_tail)
        {
            push_back(i->value);
            
            i = i->next;
        }
    }
    
    ~CharList()
    {
        clear();
        
        delete m_tail;
    }
    
    size_type size() const
    {
        return m_size;
    }
    
    bool empty() const
    {
        return size() == 0;
    }
    
    value_type& front()
    {
        return m_head->value;
    }
    
    value_type& back()
    {
        return m_tail->prev->value;
    }
    
    const value_type& front() const
    {
        return m_head->value;
    }
    
    const value_type& back() const
    {
        return m_tail->prev->value;
    }
    
    void push_front(const value_type& value)
    {
        Node *new_elem = new Node(value);
        
        new_elem->next = m_head;
        m_head->prev = new_elem;
        m_head = new_elem;
        
        ++m_size;
    }
    
    void pop_front()
    {
        if (empty())
            return;
        
        Node *del_elem = m_head;
        
        m_head = m_head->next;
        m_head->prev = 0;
        
        delete del_elem;
        
        --m_size;
    }
    
    void push_back(const value_type& value)
    {
        Node *new_elem = new Node(value);
        
        if (empty())
        {
            m_head = new_elem;
        }
        else
        {
            m_tail->prev->next = new_elem;
            new_elem->prev = m_tail->prev;
        }
        
        m_tail->prev = new_elem;
        new_elem->next = m_tail;
        
        ++m_size;
    }
    
    void pop_back()
    {
        if (empty())
            return;
        
        Node *del_elem = m_tail->prev;
        
        m_tail->prev = del_elem->prev;
        
        if (del_elem != m_head)
            del_elem->prev->next = m_tail;
        
        delete del_elem;
        
        --m_size;
    }
    
    void clear()
    {
        while (!empty())
            pop_front();
    }
    
private:
    struct Node
    {
        value_type value;
        Node *prev;
        Node *next;
        
        Node(value_type val = value_type()):
        value(val),
        prev(),
        next()
        {
        }
    };
    
private:
    Node *m_head;
    Node *m_tail;
    size_type m_size;
};
 
std::ostream& operator<<(std::ostream& stream, CharList lst)
{
    while (!lst.empty())
    {
        stream << lst.front();
        
        lst.pop_front();
    }
    
    return stream;
}
 
int main()
{
    CharList chlst;
    
    chlst.push_back('i');
    chlst.push_front('l');
    chlst.push_back('s');
    chlst.push_back('t');
    
    std::cout << chlst << std::endl;
    
    return 0;
}