Llevo unos meses intentando aprender a programar, he comprado unos tres libros y he visto un montón de videos en YouTube, lo que ha sido genial hasta ahora. ¡Pero la semana pasada me quedé perplejo gracias a las listas enlazadas! Recibo todo el concepto pero la sintaxis me está matando! He escrito algunos programas de listas enlazadas muy simples para hacer ejercicio, pero ahora estoy tratando de escribir un programa en el que cargue información de un archivo (información de personas que han solicitado una visa) en una lista enlazada, solo mostrar todo el lote de nuevo (una vez hecho esto, planeo expandirlo a donde solo muestro ciertos nodos y eliminar ciertos nodos, pero no entraré en detalles). ¡Ojalá el código que se muestra a continuación no sea demasiado largo y si pudiera obtener algunos consejos (sin juego de palabras) o algunos fragmentos para ayudarme a entender esto, sería increíble!

p.s parte de este código es de un ejemplo similar en un libro.

Aquí está el principal (la mayor parte) con el bucle para cargar la información (no funciona)

 List myList;
 visa_application *visa;

 Node * pNode;

 string visa_type;//these are all the variables that i want to load from the file
 int invoice_no;
 string surname;
 string firstname;
 double contact;
 string status;
 string result; 

ifstream in;
in.open("applications.txt",ios::in);



      while (!in.eof()){     
         pNode = new Node;
         visa = new visa_application;    //allocate memory for nodes

         in >> visa-> visa_type >> visa->invoice_no >>  visa-> surname;
         in >> visa-> firstname >> visa-> contact >> visa-> status >>  visa-> result ; 

         pNode->nData = &visa;   //put some data in the node
         myList.appendNode(pNode); //add node to list

         }

Aquí está mi archivo de encabezado de nodo de clase

 class Node
{
      friend class List;
      private:
              node_data * nData;
              Node *pNext;
              Node *pPrev;
      public:
              Node  (node_data * data){nData = data;
                                    pNext = NULL;
                                   pPrev = NULL;}
             node_data * getData(){return nData;}
};

Aquí está el archivo de encabezado de la lista de clases

class List
{
    private:
        Node *pHead;
        Node *pTail;
        Node  *createNode(node_data * data);
    public:
        List ();
        ~List();
        Node  *getpHead (){ return pHead;}
        Node  *getpTail (){return pTail;}
        Node  *previousNode(Node  *pNode){return pNode->pPrev;}
        Node  *nextNode (Node  *pNode){return pNode->pNext;}
        void appendNode(node_data * value);
        void insertNode(node_data * value, Node  *pAfter);
        void removeNode(Node  *pNode);
        bool isEmpty();
        void printList(); 
};

List ::List() {
    pHead=NULL;
    pTail=NULL;
}

List ::~List(){
    while (!isEmpty())   //keep on removing until the
                               //head points to NULL
        removeNode(pHead);
    cout << "List deleted\n";
}

   Node * List::createNode(node_data * data){
   Node * pNode = new Node (data); //allocate memory for new node and
                                 //intialize value to data
   return pNode;  
}

   bool List ::isEmpty(){
   return pHead == NULL;
}

void List ::appendNode(node_data * value)
{
   Node * pNode = createNode(value);

   if (isEmpty()) {     //if list is empty
        pHead = pNode;        //make head point to pNode
        pNode->pPrev = NULL;
   }
   else {                    //otherwise
        pTail->pNext = pNode;  //make tail point to pNode
        pNode->pPrev = pTail;
   }
   pTail = pNode;        //tail is now pNode
   pNode->pNext = NULL;  //pNode next now points to NULL
}


void List ::insertNode(node_data * value, Node  *pAfter)
{
   Node *pNode =  createNode(value);
   pNode->pNext = pAfter->pNext;
   pNode->pPrev = pAfter;

   if (pAfter->pNext != NULL)
        pAfter->pNext->pPrev = pNode;
   else
        pTail = pNode;
   pAfter->pNext = pNode;
}

void List ::removeNode(Node  *pNode)
{
   if (pNode->pPrev == NULL)  //if removing the head
        pHead = pNode->pNext;

   else
        pNode->pPrev->pNext = pNode->pNext;  //if removing a middle node

   if (pNode->pNext == NULL)  //if removing the tail
        pTail = pNode->pPrev;

   else
        pNode->pNext->pPrev = pNode->pPrev;
   pNode = NULL;
   delete pNode;  //*free the memory
}

void List ::printList()
{
   Node  *pNode=pHead;
   if (isEmpty())
        cout << "The list is empty\n";
   else
        for (pNode = pHead; pNode != NULL; pNode = pNode->pNext)
            pNode->nData->print();
}

Mi archivo de cabecera de solicitud de visa de clase

class visa_application
{
public:
    // class constructor
    visa_application();
    // class destructor
    ~visa_application();



private:
     string visa_type;
     int invoice_no;
     string surname;
     string firstname;
     double contact;
     string status;
     string result;     
};

y finalmente la solicitud de visa.cpp

     visa_application::visa_application()
{
     string visa_type = none;
         int invoice_no = 0;
         string surname = none;
         string firstname = none;
         double contact = 00;
         string status = none;
         string result = none; 
 }

 class destructor
 visa_application::~visa_application()
{
// insert your code here
}  

Recibo el error "no hay una función coincidente para llamar a` List :: appendNode (Node * &) '"entre otras cosas. De todos modos, sé que esto es largo, pero sería fantástico si pudiera obtener ayuda. ¡No tengo un tutor o profesor o alguien así para que me ayude, por lo que cualquier comentario sería muy apreciado! ¡Gracias!

** EDITAR los mensajes de error son:

 no matching function for call to `Node::Node()' 
 candidates are: Node::Node(const Node&) 
 Node::Node(node_data*)     
 no matching function for call to `List::appendNode(Node*&)' 
 candidates are: void List::appendNode(node_data*)