Как реализовать работу со списком строк и списком цифр в классе List?

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
class Node
{
    friend class List; //разрешение списку обращаться к своим закрытым частям
public:
    int value;
 
private:
    Node* p_next;
    Node* p_prev;
};
 
class List
{
private:
    Node* p_first;
    Node* p_last;
 
private:
    void copy(const List& list)
    {
        Node* p = NULL;
        while (p = list.get_next(p))
        {
            add(p->value);
        }
    }
public:
    List() : p_first(NULL), p_last(NULL)
    {
        //p_first = NULL;
        //p_last = NULL;
    }
    List(const List& list):  p_first(NULL), p_last(NULL)
    {
        copy(list);
    }
 
    List& operator= (const List& list)
    {
        if(this != &list)
        {
            clear();
            copy(list);
        }
 
        return *this;
    }
 
    ~List()
    {
        clear();
    }
 
    void clear()
    {
        while (p_first)
        {
            Node* p = p_first;
            p_first = p->p_next;
            delete p;
        }
        p_last = NULL;
    }
 
 
    void add(int k)
    {
        Node* p = new Node;
        p->p_prev = p_last;
        p->p_next = NULL;
        p->value = k;
 
        if (p_first == NULL)
        {
            p_last = p;
            p_first = p;
        }
        else
        {
            p_last->p_next = p;
            p_last = p;
        }
    }
    Node* get_next(Node* p) const
    {
        return p != NULL ? p->p_next /*правильное условие*/ : p_first /*неправильное условие*/;
    }
    void print()
    {
        cout << "forward:" << endl;
        for (Node* node = p_first; node != NULL; node = node->p_next)//for (Node* node = p_first; node; node = node->p_next)
        {
            cout << node->value <<" ";
        }
    }
 
 
};
 
void user_print(List& list)
{
    Node* p = NULL;
    while (p = list.get_next(p))
    {
        cout << p->value <<" ";
    }
    cout << endl;
}
/*class Iterator
{
private:
List* list;
 
public:
int get_next()
{
 
return 0;
}
};*/
//
 
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    List L1;
    for( int i=0; i<11; i++)
    {
        L1.add(i+1);
    }
    //L1.print();
    //функция принт:
    user_print(L1);
 
    List L2 = L1; //то же самое, что List L2(L1)
    user_print(L2);
    L2.add(100);
    user_print(L1);
    user_print(L2);
    
    L1 = L2;
    cout << "L1 = L2" <<endl;
    user_print(L1);
    user_print(L2);
 
    L2.add(255);
    cout << "L1 = L2 (255)" <<endl;
    user_print(L1);
    user_print(L2);
 
    cout << "L1 = L1 " <<endl;
    L1 = L1;
    user_print(L1);
 
    getchar ();
    return 0;
}

#include <iostream>
#include <list>
#include <string>
 
using namespace std;
 
int main()
{
  list<int> lint;
  list<string> lstr; 
  int n;
  string s;
 
  for (int i=1; i<=5; ++i) 
    {cin>>n; lint.push_back(n);}
  for (int i=1; i<=5; ++i) 
    {cin>>s; lstr.push_back(s);}
 
  cout<<"Enter 1 or 2 as a num of list"<<endl;
  cin>>n;
  switch(n)
  {
    case 1: 
      for (list<int>::iterator iter =lint.begin(); iter!=lint.end(); ++iter )
        {cout<<*iter;} break;
    case 2:
      for (list<string>::iterator iter =lstr.begin(); iter!=lstr.end(); ++iter )
        {cout<<*iter;} break;
    default: 
      cerr<<"Error!"<<endl;
      return -1;
  }
  getchar();
  return 0;
}

#include <iostream>
#include <cstdlib>
#include <string>
 
// Пример шаблонного класса
template<class T>
class foo
{
 
public:
 
    foo(const T& value)
        : m_tValue(value)
    {}
    friend std::ostream& operator << (std::ostream& os, const foo& rhs)
    {
        os << rhs.m_tValue;
        return os;
    }
 
private:
 
    T   m_tValue;
};
 
//Пример шаблонной функции
template<class T>
T sum(const T& add1, const T& add2)
{
    return add1 + add2;
}
 
int main()
{
    foo<int> ivar(5);
    std::cout << ivar << std::endl;
    foo<std::string> svar("Hello, world!");
    std::cout << svar << std::endl;
    std::cout << sum(3.3, .7) << std::endl;
    std::cout << sum(1, 8) << std::endl;
    return EXIT_SUCCESS;
}

#ifndef MY_STACK_HPP
#define MY_STACK_HPP
 
#include <stdexcept>
 
namespace my
{
    template<class T>
    class stack
    {
        struct node
        {
            T       value;
            node*   next;
 
            node(const T& val)
                : value(val), next(NULL) {}
        };
        node*       top;
 
    public:
 
        stack();
        ~stack();
        void push(const T& val);
        T pop();
        bool empty() const;
    };
 
    template<class T>
    stack<T>::stack()
        : top(NULL) {}
 
    template<class T>
    stack<T>::~stack()
    {
        while(top)
        {
            node* temp = top;
            top = top->next;
            delete temp;
        }
    }
 
    template<class T>
    void stack<T>::push(const T &val)
    {
        if(top)
        {
            node* newNode = new node(val);
            newNode->next = top;
            top = newNode;
        }
        else
            top = new node(val);
    }
 
    template<class T>
    T stack<T>::pop()
    {
        if(!top)
            throw(std::runtime_error("Can't pop from the empty stack"));
        T retVal = top->value;
        node* delNode = top;
        top = top->next;
        delete delNode;
        return retVal;
    }
 
    template<class T>
    bool stack<T>::empty() const
    {
        return (top == NULL);
    }
}
 
#endif // MY_STACK_HPP

#include <iostream>
#include <cstdlib>
 
#include "my_stack.hpp"
 
int main()
{
    try
    {
        my::stack<int> stk;
        std::cout << "Pushing to the stack..." << std::endl;
        for(size_t i= 0; i < 10; ++i, std::cout << i << " ")
            stk.push(i + 1);
        std::cout << std::endl << "Popping from the stack..." << std::endl;
        while(!stk.empty())
            std::cout << stk.pop() << " ";
        std::cout << std::endl;
    }
    catch(std::exception& e)
    {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
 
    return EXIT_SUCCESS;
}

// Объявление шаблонного класса
template<class T>
class List
{
    
public:
    
    List(); // Конструктор по умолчанию, создает пустой список
    List(const List<T>& rhs); // Копирующий конструктор, создает новый список на основе данного
    ~List(); // Деструктор
    // ... остальные методы
    
private:
    
    struct node // Объявление структуры-узла
    {
        T value; // Заменили тип элемента списка на шаблонный параметр T
        node* next;
        node* previous;
    };
    node* first; // Указатель на первый узел
    node* last; // Указатель на второй узел
};
 
//Реализация шаблонного класса
template<class T>
List<T>::List()
{
    // ... реализация конструктора по умолчанию
}
 
template<class T>
List<T>::List(const List<T> &rhs)
{
    // ... реализация копирующего конструктора
}
 
// ... и так далее

std::list<int> iList; // Вот здесь
iList.push_back(5);
// ...