Удалить из списка все элементы с нечётными значениями и вывести указатель p2 на начало преобразованного списка.

#include <iostream>
#include <windows.h>
#include <conio.h>
#include <time.h>
 
 
 
using namespace std;
 
class Node
{
public:
        Node();
        ~Node();
        int number;
        Node* P1;
        Node* P2;
        void printNode(); //печатает
        void delNode();  //удаляет
        
};
 
Node::Node()    //кошмарного вида конструктор      
{
    P1 = NULL;
    P2 = NULL;
    number = 0;
}
 
Node::~Node()  // деструктор
{
   
}
 
int main()
{
   
   srand ( time(NULL) );
   int k,numb=-1;
   cout<<"Vvedite chislo elementov "; //тут вибыраю кол-во элементов
   cin>>k;
   for(int n=0;n<k;n++)
   {
      numb=rand()%10;   //рандом
      Node* ptr = new Node;
      ptr->number = numb;
      ptr->P1 = NULL;
   }
getch();
}
 
 void Node::printNode()  //эта часть вообще под вопросом
{
     Node *ptr = P1;
     
     while (ptr)
     {
         cout<<ptr->number<<"\n";
         ptr = ptr->P1;
     }
}

 void Node::printNode()  //эта часть вообще под вопросом
{
     Node *ptr = P1;
     
     while (ptr)
     {
         cout<<ptr->number<<"\n";
         ptr = ptr->P1;
     }

#include <iostream>
#include <time.h>
using namespace std;
 
template<class T>
class xList {
   struct node {
       T data;
        node*  prev;
        node*  next;
   };
private:
   node*  lst;
   node*  ptr;
public:
  typedef node*  xNode;
  xList(void) : lst(NULL), ptr(NULL) {}
  ~xList() {
       this->clear();
  }
public:
     void  add_front(T data) {
         node*  _new = new node();
         _new->data  = data;
         if(! lst) {
              lst = _new;
              lst->next = lst;
              lst->prev = lst;
         } else {
             _new->next = lst;
             _new->prev = lst->prev;
             lst->prev->next = _new;
             lst = _new;
         }
     }
 
     void  add_back(T data) {
         node*  _new = new node();
         _new->data  = data;
         if(! lst) 
              this->add_front(data);
         else {
              _new->next = lst;
              _new->prev = lst->prev;
              lst->prev->next = _new;
              lst->prev = _new;
         }
     }
 
     void pop_front(void) {
         if(lst == lst->prev) {
              delete lst;
              lst = NULL;
              return;
        }
        node* tmp = lst;
        lst = lst->next;
        lst->prev = tmp->prev;
        lst->prev->next = tmp->next;
        delete tmp;
        tmp = NULL;
     }
 
     void pop_back(void) {
         if(lst == lst->prev) {
              delete lst;
              lst = NULL;
              return;
         }
         node*  tmp = lst->prev;
         lst->prev  = tmp->prev;
         lst->prev->next = tmp->next;
         delete tmp;
         tmp = NULL;
     }
 
     void  remove(xNode  iter) {
          node*  tmp;
          if(iter == lst) {
              this->pop_front();
              return;
          } 
          tmp = iter;
          iter->prev->next = iter->next;
          iter->next->prev = iter->prev;
          delete tmp;
          tmp = NULL;
          ptr = NULL;
     }
 
     void  reset(void) {
            ptr = NULL;
      }
 
      bool  move_next(void) {
            if(ptr == NULL) {
                  ptr = lst;
                  return true;
            }
            if(ptr == lst->prev) {
                  ptr = NULL;
                  return false;
            }
            ptr = ptr->next;
            return true;
      }
 
       bool  move_prev(void) {
            if(ptr == NULL) {
                 ptr = lst->prev;
                 return true;
            }
            if(ptr == lst) {
                 ptr = NULL;
                 return false;
            }
            ptr = ptr->prev;
            return true;
       }
 
    T&  current(void) {
              if(! ptr)
                   return lst->data;
               return ptr->data;
    }
 
    xNode element(void) {
                return ptr;
    }
 
    T&  back(void) {
                return lst->prev->data;
    }
 
    T& front(void) {
                 return lst->data;
    }
 
    bool empty(void) const {
                return (! lst);
    }
 
    void clear(void) {
                 while(! this->empty())
                     this->pop_back();
    }
};
 
 
 
 
int main(void) {
 
  xList<int>  l;
  int n = 0;
  cout<<"Vvedite chislo elementov "; 
  cin >> n;
 
  srand(time(NULL));
  for(int i = 0; i < n; i++)
       l.add_back( rand() % 10 );
 
  // показать исходный список
  while( l.move_next() ) 
       cout << l.current() << ", ";
  cout << endl << endl;
 
  // процесс удаления
  while( l.move_next() ) {
      if(l.current() % 2) {
           l.remove(l.element());
           l.reset();
      }
  }
  
  // показать список после удаления нечётных значений-элементов
  while( ! l.empty()) {
      cout << l.front() << ", ";
      l.pop_front();
  }
 
 // l.clear();
  
  cin.ignore(1, '\n');
  cin.get();
  return 0;
}