[C++] Uso di template e header

**Darèios89** · 01-08-2012, 12:28

Ho un problema con header e template, devo realizzare un distributore di videonoleggio, e ho pensato di utilizzare una lista linkata, dove ogni nodo contiene un oggetto di tipo Film. Ho errori che non capisco a cosa siano dovuti, intanto posto solamente gli header di LinkedList e Node.

Node.hpp

codice:

ifndef NODE_HPP
#define	NODE_HPP


//#include <stdio.h>
#include "Film.hpp"      //error In file included from
#include <string>

template <class Film> 

class Node
{                                     //error changes meaning of 'Node' from class Node<Film>
        protected:
            string film;
            string copieDisp;
            string copieTot;
            Node* next;
            
        public:
            Node(Film element);
            ~Node();
    
    
           
           void setFilm(Film film);
           void setNext(Node * next);
           void setcopieDisp(string number);
           void setcopieTot(string number);
           Node* getNext();
           Film getFilm();
           string getcopieDisp();
           string getcopieTot();
};




#endif	/* NODE_HPP */

E LinkedList.hpp

codice:

#ifndef LINKEDLIST_HPP
#define	LINKEDLIST_HPP

#include"Node.hpp"                   //errore o meglio triangolo giallo

//template <class Film> 

class LinkedList 
{
        protected:
             typedef Node <Film>* Node;  // declaration of 'typedef class Node<Film>   LinkedList:: Node 
                                                                                                         

            Node<Film>* head;
            Node<Film>* tail;
            int size;
     
            
        public:
            LinkedList();
           ~LinkedList();
           
           
           void setHead(Node<Film>* n);
           Node<Film>* getHead();
           void setTail(Node<Film>* n);
           Node<Film>* getTail();
           int getSize();
           void addNode(Node<Film>* newNode, int copie);
           void deleteNode(Node<Film>* toRemove);
           int isPresent(Node<Film>* element);
           Film getNode(Film f);
           void giveNode(Film f);
           string copieNode(Film f);
           vector<Film> listAnno(unsigned int a);
           vector<Film> listRemake();
           Film searchFilm(string titolo, string attori, string regista);
          
           
};


#endif	/* LINKEDLIST_HPP */

Riporto anche l' header di Film che non ha errori:

codice:

#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;
            string attori;
            string remake;
     
            
        public:
            Film(string titolo, string regista, bool isRemake);
            Film(string titolo);
           ~Film();
           
           void setAttori(string name);
           void setOriginale(string originale);
           void setTitolo(string valore);
           void setRegista(string valore);
           void setAnnouscita(int valore);
           void setRemake(bool valore);
           string getAttori();
           string getTitolo();
           string getRegista();
           int getAnnouscita();
           bool isRemake();
           string getOriginale();
           string getRemake();
           void FissaOriginale(Node<Film> film, Node<Film> remake);
};



#endif	/* FILM_HPP */

**MegaAlchimista** · 02-08-2012, 11:37

Sei al corrente che in molti compilatori, per le classi template, devi dichiarare tutti i metodi nell'header e non puoi fare la dichiarazione separatamente in un altro file (di norma .cpp) come invece è solito fare?

EDIT:
Per esempio avevo creato una volta una classe template per i vettori matematici! Che non solo potessse prendere i tipi numerici, ma anche i numeri complessi, e l'header alla fine è venuto così.

(usavo Qt, se leggi QVector non spaventarti, è una struttura del tutto simile ad std::vector)

codice:

#include "complex.h"

template<typename T> class MathVector
{
public:
_ _ MathVector();
_ _ MathVector(int _size);
_ _ MathVector(int _size, T initializerValue);
_ _ MathVector(T x, T y);
_ _ MathVector(T x, T y, T z);
_ _ MathVector(const QVector<T> &fromQVect);
_ _ MathVector(double norm, const MathVector<T>& parallelTo);
_ _ MathVector(const MathVector<T>& other);
_ _ ~MathVector();

_ _ MathVector<T>& operator=(const MathVector<T>& vect);
_ _ MathVector<T>& operator =(const QVector<T>& vect);
_ _ bool operator ==(const MathVector<T>& vect) const; _ _ _ _ //comparazione di tutti gli elementi
_ _ bool operator !=(const MathVector<T>& vect) const;
_ _ bool operator >(const MathVector<T>& vect) const; _ _ _ _ _//comparazione delle norme
_ _ bool operator <(const MathVector<T>& vect) const;
_ _ bool operator >=(const MathVector<T>& vect) const;
_ _ bool operator <=(const MathVector<T>& vect) const;

_ _ MathVector<T> operator +(const MathVector<T>& vect) const;
_ _ MathVector<T>& operator +=(const MathVector<T>& vect);
_ _ MathVector<T> operator -(const MathVector<T>& vect) const;
_ _ MathVector<T> operator -() const; _ _ _ _ _ _ _ _ _ _ _ _ //sign
_ _ MathVector<T>& operator -=(const MathVector<T>& vect);
_ _ T operator *(const MathVector<T>& vect) const;
_ _ MathVector<T> operator *(T k) const;
_ _ MathVector<T>& operator *=(T k);
_ _ MathVector<T> operator ^(const MathVector<T>& vect) const;
_ _ MathVector<T>& operator ^=(const MathVector<T>& vect);
_ _ T& operator [](int index);
_ _ const T& operator [](int index) const;
_ _ const T& at(int index) const;
_ _ T value(int index) const;
_ _ T& last();
_ _ T& first();

_ _ bool contains(T value) const;
_ _ bool isEmpty() const;
_ _ bool isNull() const;
_ _ bool isParallelTo(const MathVector<T>& vect) const;
_ _ bool isNormalTo(const MathVector<T> &vect) const;
_ _ int size() const;
_ _ MathVector<T> normalized() const;
_ _ QVector<T> toQVector() const;
_ _ std::vector<T> toStdVector() const;
_ _ QList<T> toList() const;
_ _ QString toString(int precision=0) const;

_ _ double norm() const;
_ _ double anglesRadians(int floor) const; _ _ _ _ //ha size-1 angoli
_ _ QVector<double> anglesRadians() const;
_ _ MathVector<T> projectedTo(const MathVector<T>& other) const;

_ _ void clear();
_ _ void resize(int newSize);
_ _ void fill(T newValue, int newSize=-1);

Private:
_ _ void sizeNotValid(QString operation) const;
_ _ QVector<T>* v;
};

#endif // MATHVECTOR_H

template<typename T> MathVector<T> operator *(const T& d, const MathVector<T>& vect);
template<typename T> MathVector<T> pow(const MathVector<T>& vect, T exponent);

template<typename T>
MathVector<T>::MathVector() : v(new QVector<T>()){}

template<typename T>
MathVector<T>::MathVector(int _size) : v (new QVector<T>(_size)){}

template<typename T>
MathVector<T>::MathVector(int _size, T initializerValue): v (new QVector<T>(_size,initializerValue)){}

[e così via ...]

**Darèios89** · 02-08-2012, 11:50

Emh, no non lo sapevo, ho corretto comunque diversamente e ottengo sempre errori: questo è il Node.hpp:

codice:

#ifndef NODE_HPP
#define	NODE_HPP

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

using namespace std;


template <class T> class Node
{
        protected:
            T element;
            T* next;
            
        public:
            Node(T element);
            ~Node();
    
    
           T getElement();
           void setElement(T element);
           void setNext(T* succ);
           T* getNext();
};

#endif	/* NODE_HPP */

E questo il .cpp

codice:

#include "Node.hpp"

Node::Node(T element)
{
    this->element=element;
    next=NULL;
}

Node::~Node()
{
    
}

T Node:: getElement(){return element;}
void Node::setElement(T f){element=f;}
void Node::setNext(T* succ){next=succ;}
T* Node::getNext(){return next;}

Alla fine non è che aggiungo o dichiaro cose che nell' header file non sono presenti, però non va bene, ho errore già nel costruttore del cpp invalid use of template-name ‘Node’ without an argument list.

Non capisco cosa non va.....

**Scara95** · 02-08-2012, 11:57

Non puoi separare le dichiarazioni, devi mettere tutto nello stesso file.

**MegaAlchimista** · 02-08-2012, 11:59

Infatti è lo stesso identico errore che avevo io.
Abbiamo scritto contemporaneamente, ti invito a guardare il mio precedente messaggio, che ho editato inserendo la prima parte dell'header che avevo creato quando mi ero cimentato con i template.
Spero possa aiutarti

**Darèios89** · 02-08-2012, 12:09

Si ho guardato l' esempio però.....riesco a capire ben poco perchè il nostro corso di C è stato un disastro, quindi non posso avere un header e un cpp separati? Ho sempre usato fare così....
Quindi metto tutto in un unico file? E poi il file come verrà salvato? cpp oppure hpp? mi sembra di vedere che quando passi all' implementazione specifichi sempre il template prima di implementare.....

EDIT:

Ho notato che funziona anche separando header e cpp, basta fare precedere la dichiarazione di template, ora farò delle prove dal main....speriamo bene:

codice:

#include "Node.hpp"

template<typename T>
Node<T>::Node(T film)
{
    element=film;
    next=NULL;
}

template<typename T>
Node<T>::~Node()
{
    
}

template<typename T>
T Node<T>::getElement(){return element;}

template<typename T>
void Node<T>::setElement(T film){element=film;}

template<typename T>
void Node<T>::setNext(T* succ){next=succ;}

template<typename T>
T* Node<T>::getNext(){return next;}

**MegaAlchimista** · 02-08-2012, 12:39

Si guarda è molto semplice: io ci ho sbattuto un po' la testa perchè mi dava troppo fastidio dover mettere tutto sullo stesso file, ma non c'è alternativa.

Comunque tu crei il tuo normale header, definendo la classe come una classe template, poi sotto implementi i metodi, ovvero fai quelli che avresti fatto nel .cpp

codice:

//file nomeclasse.h

#ifndef "NOMECLASSE.H"
#define "NOMECLASSE.H"

#include <stdio.h>

template<typename T> class NomeClasse
{
     Public:
              NomeClasse(T a, T b);
              T somma();
      Private:
      T x, y;
}
#endif

template<typename T>
NomeClasse<T>::NomeClasse(T  a, T b)
{
  x=a;
  y=b;
}
template<typename T>
T NomeClasse<T>::somma()
{
  return x+y;
}

Per esempio per la dichiarazione dell'ultimo metodo: dici che quel metodo è template, quindi definisci T, dici che torna T e non prende niente in input, e poi fra le graffe scrivi esattamente cosa fa

**MegaAlchimista** · 02-08-2012, 12:43

Originariamente inviato da Darèios89
EDIT:
Ho notato che funziona anche separando header e cpp, basta fare precedere la dichiarazione di template, ora farò delle prove dal main....speriamo bene:

Si compila, ma per la mia esperienza poi dava errori di compilazione quando cercavo di instanziarlo (quindi , per esempio, creavo un oggetto di quel tipo nel main)
Se invece ti funziona tutto correttamente buon per te

fammi sapere che compilatore usi

**Darèios89** · 02-08-2012, 15:37

Come compilatore uso cygwin. Comunque ci sono ancora dei problemi, nel main, sempre su questi benedetti template, non va bene come creo i nodi, riporto l' header di Node e il cpp

Node.hpp

codice:

#ifndef NODE_HPP
#define	NODE_HPP

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

using namespace std;


template<typename T> class Node
{
        protected:
            T* element;
            T* next;
            
        public:
            Node(T* element);
            ~Node();
    
    
           T* getElement();
           void setElement(T* element);
           void setNext(T* succ);
           T* getNext();
};

#endif	/* NODE_HPP */

CPP:

codice:

#include "Node.hpp"

template<typename T>
Node<T>::Node(T* film)
{
    element=film;
    next=NULL;
}

template<typename T>
Node<T>::~Node()
{
    
}

template<typename T>
T* Node<T>::getElement(){return element;}

template<typename T>
void Node<T>::setElement(T* film){element=film;}

template<typename T>
void Node<T>::setNext(T* succ){next=succ;}

template<typename T>
T* Node<T>::getNext(){return next;}

E poi nel main:

codice:

int main(int argc, char** argv) {

    
    Film* prova=new Film("I pirati della silicon valley", "mbarooz");
    
    Node<Film> nuovo(prova);
    
    return 0;
}

Ottengo:

codice:

main.cpp:27:28: error: cannot convert ‘Film*’ to ‘Node<Film>*’ in initialization

Potreste dirmi esattamente come gestire il main? E' assurdo che un progetto si blocchi per non sapere la sintassi giusta....

Cercando in giro non riesco a chiarirmi le idee..

**MegaAlchimista** · 02-08-2012, 18:01

Originariamente inviato da Darèios89

E poi nel main:

codice:

int main(int argc, char** argv) {
    Film* prova=new Film("I pirati della silicon valley", "mbarooz");
    
    Node<Film> nuovo(prova);
    
    return 0;
}

Ottengo:

codice:

main.cpp:27:28: error: cannot convert ‘Film*’ to ‘Node<Film>*’ in initialization

Infatti devi fare così

codice:

int main(int argc, char** argv) {
 Film prova("I pirati della silicon valley", "mbarooz");
    
    Node<Film> nuovo(&prova);
}

Ps:
Ricordati il distruttore della classe Node!

codice:

delete element;
delete next;

Sono puntatori, vanno deallocati quando si distrugge il nodo

Discussione: [C++] Uso di template e header

Strumenti discussione

Ricerca discussione

Visualizza

Problema con i template e gli header

Permessi di invio