Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 14
  1. #1

    Problema con i template e gli header

    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 */

  2. #2
    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 ...]

  3. #3
    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.....

  4. #4
    Utente di HTML.it L'avatar di Scara95
    Registrato dal
    Jul 2009
    residenza
    Zimella (VR)
    Messaggi
    2,590
    Non puoi separare le dichiarazioni, devi mettere tutto nello stesso file.
    "Quid enim est, quod contra vim sine vi fieri possit?" - Cicerone, Ad Familiares

  5. #5
    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

  6. #6
    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;}

  7. #7
    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

  8. #8
    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

  9. #9
    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..

  10. #10
    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

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.