[C++] Problema con classi e tipi nella creazione di una linked list

[Darèios89]

Devo creare una linkedlist con nodi che contengano oggetti di tipo Film, in Java sarebbe ammissibile una cosa come:

public class LinkedList<Node>
{
.
.
}

public class Node<Film>
{
.
.
}

Qui invece ho errori...riporto la classe Film e la lista con la classe Node:

Film.hpp

#ifndef FILM_HPP
#define	FILM_HPP


//#include <stdio.h>
//#include <string.h>

using namespace std;

class Film
{
        protected:
            string Titolo;
            string Regista;
            int annouscita;
            bool isRemake;
            string Originale;
     
            
        public:
            Film(string Titolo, string Regista, bool isRemake);
           ~Film();
           
           void setOriginale(string Originale);
           void setTitolo(string valore);
           void setRegista(string valore);
           void setAnnouscita(int valore);
           void setRemake(bool valore);
           string getTitolo();
           string getRegista();
           int getAnnouscita();
           bool isRemake();
           string getOriginale();
};



#endif	/* FILM_HPP */

LinkedList.hpp:

#ifndef LINKEDLIST_HPP
#define	LINKEDLIST_HPP

#include "Node.hpp"

class LinkedList 
{
        protected:
            Node* head;
            Node* tail;
            int size;
     
            
        public:
            LinkedList();
           ~LinkedList();
           
           
           void setHead(Node* n);
           Node* getHead();
           void setTail(Node* n);
           Node* getTail();
           int getSize();
           void addNode(Node newNode);
           void deleteNode(Node toRemove);
          
           
};



#endif	/* LINKEDLIST_HPP */

Node.hpp dove ci sono problemi:

#ifndef NODE_HPP
#define	NODE_HPP


#include <stdio.h>
#include "Film.hpp"

using namespace std;

class Node  <Film>
{
        protected:
            string film;
            string copie;
            Node* next;
            
        public:
            Node(Film element, string copie);
            ~Node();
    
    
           
           void setFilm(<Film> film);
           void setNext(Node * next);
           void setCopie(string aggiornamento);
           Node* getNext();
           <Film> getFilm();
           string getCopie();
};




#endif	/* NODE_HPP */

I problemi sono tutti nelle istruzioni con Film, errore unable to resolve identifier.

[shodan]

In C++ i template funzionano in maniera diversa.

template <class Ty> 
class Node
{
        protected:
            string film;
            string copie;
            Node* next;
            
        public:
            Node(Ty element, string copie);
            ~Node();
    
    
           
           void setFilm(Ty film);
           void setNext(Node * next);
           void setCopie(string aggiornamento);
           Node* getNext();
           Ty getFilm();
           string getCopie();
};

...

template <class Tx> class LinkedList 
{
        protected:
            typedef Node<Tx> Node;

            Node* head;
            Node* tail;
            int size;
     
            
        public:
            LinkedList();
           ~LinkedList();
           
           
           void setHead(Node* n);
           Node* getHead();
           void setTail(Node* n);
           Node* getTail();
           int getSize();
           void addNode(Node newNode);
           void deleteNode(Node toRemove);
          
           
};

[Darèios89]

Quindi anche se così non ho errori non va bene?

#ifndef NODE_HPP
#define	NODE_HPP


#include <stdio.h>
#include "Film.hpp"

using namespace std;

class Node 
{
        protected:
            Film film;
            string copie;
            Node* next;
            
        public:
            Node(Film element, string copie);
            ~Node();
    
    
           
           void setFilm(Film object);
           void setNext(Node * next);
           void setCopie(string aggiornamento);
           Node* getNext();
           Film getFilm();
           string getCopie();
};




#endif	/* NODE_HPP */

[shodan]

Così si.
E' la sintassi che avevi usato a non andare bene:

class Node  <Film>

Una sintassi del genere puoi averla solo con un template nella forma che ho postato.

[Darèios89]

Quindi anche in questo secondo modo i Node saranno di "tipo" film anche come li ho scritti io?
Ti ringrazio.

[shodan]

Si. Il tipo Node conterrà solo dati di tipo Film, pertanto la LinkedList conterrà dei Node di tipo Film e puoi eliminare il: template <class Ty> dalle dichiarazioni. Ovviamente perderai un po' di flessibilità sul riuso delle classi, ma puoi pensarci in un secondo momento se ti serve.

A prescindere da questo, la sintassi per i template che ho postato è obbligatoria se vuoi rendere il dato generico (non so come funzioni in Java, ma in C++ è così).

[Darèios89]

Ah perfetto, al momento ho deciso di tenere i template, vedrò dopo il da farsi....ho un altro problemino. Praticamente vorrei fare una classe Distributore, implementata come lista linkata, questo è l' header.

using namespace std;
#include <vector>
#include "LinkedList.hpp"
#include "Film.hpp"


class Distributore
{
        protected:
            
                  LinkedList distributore;
            
        public:
                  Distributore();
                 ~Distributore();
                 
                 
        public:
            
            void InserisciFilm(Film f, unsigned int copie);
            void EliminaFilm(Film f);
            Film EsceFilm(Film f);
            void RitornaFilm(Film f);
            string CopieFilm(Film f);
            vector<Film> ListaFilmPerAnno(unsigned int a);
            vector<Film> ListaRemake();
            bool search(string titolo, string attori, string regista);
            
        


};

#endif	/* DISTRIBUTORE_HPP */

Sto cercando di implementarlo, ma nei metodi ho un problemino:

#include "Distributore.hpp"

                  Distributore:: Distributore(){
                    distributore=new LinkedList();
                  }
                  
                  Distributore::~Distributore(){
                      
                  }
                 
                  
            
            void Distributore:: InserisciFilm(Film f, unsigned int copie){distributore.addNode
            void EliminaFilm(Film f);
            Film EsceFilm(Film f);
            void RitornaFilm(Film f);
            string CopieFilm(Film f);
            vector<Film> ListaFilmPerAnno(unsigned int a);
            vector<Film> ListaRemake();
            bool search(string titolo, string attori, string regista);

In questo modo al primo metodo non funziona quello che voglio fare, cioè invocare un metodo di LinkedList che ho scritto in un file a parte sia come header che come .cpp. Solo che non funziona questa istruzione, come faccio a utilizzare una linkedlist che ho dichiarato e costruito nel costruttore di distributore?

[shodan]

Ti serve un puntatore (o meglio uno smart pointer. Che compilatore usi?)

[Darèios89]

Uso cygwin......quindi del tipo: LinkedList distributore*;

[shodan]

Quasi:

LinkedList* distributore;

Ricorda che C++ non ha GC come Java, perciò la cancellazione del puntatore è a tuo carico (per quello avevo suggerito lo smart pointer).