IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C++ Discussion :

Je ne comprend pas très bien les templates...


Sujet :

C++

  1. #1
    Paulinho
    Invité(e)
    Par défaut Je ne comprend pas très bien les templates...
    Bonjour!

    J'ai du resoudre l'exercice suivant:

    " Créer une class Pile (template) [e.g. Pilha<Pair,10>p;]. La Pile doit être polymorfique, avoir une subclass Point de la class Pair. Les éléments de la class et de la subclass peuvent être insérés dans la Pile pp.

    La class doit contenir seulement les suivants méthodes publiques:

    - void push(C i)
    - C pop()
    - void printpile().

    Je dois faire un programme pour insérer et rétirer d'une manière interactive des objects de la class Pair e de sa subclasse Point d'une pile de taille 10. Pair et Point doivent contenir méthodes print() diférents e printpile() doit utiliser le méthode juste pour des éléments diférents.

    Merci d'avance pour tous!
      0  0

  2. #2
    Membre averti
    Avatar de Strab
    Profil pro
    Inscrit en
    mai 2004
    Messages
    338
    Détails du profil
    Informations personnelles :
    Âge : 37
    Localisation : France

    Informations forums :
    Inscription : mai 2004
    Messages : 338
    Points : 330
    Points
    330
    Par défaut
    Citation Envoyé par Règles du forum
    Nous ne sommes pas là non plus pour faire vos exercices.
      0  0

  3. #3
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 37
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2003
    Messages : 10 651
    Points : 15 920
    Points
    15 920
    Par défaut
    Yep.

    Dis nous donc ce que tu as déjà fait, ce sur quoi tu butes, et on se fera un plaisir de t'aider à avancer.
      0  0

  4. #4
    Paulinho
    Invité(e)
    Par défaut
    J'ai le code pour une pile mais avec seulement une variable. J'ai le problème avec l'integration de la class Pair et Point et la taille qui doit être 10.

    Voici le code avec une variable:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
     
    #include <iostream>
    #include <stack>
     
    using namespace std;
     
    template <class T>
    class Stack
    {
        typedef struct stackitem
        {
            T Item;                 // On utilise le type T comme
            struct stackitem *Next; // si c'était un type normal.
        } StackItem;
     
        StackItem *Tete;
     
    public:         // Les fonctions de la pile :
        Stack(void);
        Stack(const Stack<T> &);
                     // La classe est référencée en indiquant
                     // son type entre < et > ("Stack<T>").
                     // Ici, ce n'est pas une nécessité
                     // cependant.
        ~Stack(void);
        Stack<T> &operator=(const Stack<T> &);
        void push(T);
        T pop(void);
        bool is_empty(void) const;
        void flush(void);
    };
     
    // Pour les fonctions membres définies en dehors de la déclaration
    // de la classe, il faut une déclaration de type générique :
     
    template <class T>
    Stack<T>::Stack(void) // La classe est référencée en indiquant
                          // son type entre < et > ("Stack<T>").
                          // C'est impératif en dehors de la
                          // déclaration de la classe.
    {
        Tete = NULL;
        return;
    }
     
    template <class T>
    Stack<T>::Stack(const Stack<T> &Init)
    {
        Tete = NULL;
        StackItem *tmp1 = Init.Tete, *tmp2 = NULL;
        while (tmp1!=NULL)
        {
            if (tmp2==NULL)
            {
                Tete= new StackItem;
                tmp2 = Tete;
            }
            else
            {
                tmp2->Next = new StackItem;
                tmp2 = tmp2->Next;
            }
            tmp2->Item = tmp1->Item;
            tmp1 = tmp1->Next;
        }
        if (tmp2!=NULL) tmp2->Next = NULL;
        return;
    }
     
    template <class T>
    Stack<T>::~Stack(void)
    {
        flush();
        return;
    }
     
    template <class T>
    Stack<T> &Stack<T>::operator=(const Stack<T> &Init)
    {
        flush();
        StackItem *tmp1 = Init.Tete, *tmp2 = NULL;
     
        while (tmp1!=NULL)
        {
            if (tmp2==NULL)
            {
                Tete = new StackItem;
                tmp2 = Tete;
            }
            else
            {
                tmp2->Next = new StackItem;
                tmp2 = tmp2->Next;
            }
            tmp2->Item = tmp1->Item;
            tmp1 = tmp1->Next;
        }
        if (tmp2!=NULL) tmp2->Next = NULL;
        return *this;
    }
     
    template <class T>
    void Stack<T>::push(T Item)
    {
        StackItem *tmp = new StackItem;
        tmp->Item = Item;
        tmp->Next = Tete;
        Tete = tmp;
        return;
    }
     
    template <class T>
    T Stack<T>::pop(void)
    {
        T tmp;
        StackItem *ptmp = Tete;
     
        if (Tete!=NULL)
        {
            tmp = Tete->Item;
            Tete = Tete->Next;
            delete ptmp;
        }
        return tmp;
    }
     
    template <class T>
    bool Stack<T>::is_empty(void) const
    {
        return (Tete==NULL);
    }
     
    template <class T>
    void Stack<T>::flush(void)
    {
        while (Tete!=NULL) pop();
        return;
    }
     
    int main() {}
    Je sais que int main() est vide mais c'est parce que je ne sais pas encore comment appeler le Pile<Pair,10> pp.

    J'ai déjà fait un code pour la class Pair et pour la class Point mais il me semble qu'il ne fonctionne pas de cette manière...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
     
    class Par {
    private:
      int left;
      int right;
    public:
      Par() { 
        left = 0; 
        right = 0;  
      };
      void set_left(int n) { left = n; }
      void set_right(int n) { right = n; }
      int get_left() { return left; }
      int get_right() { return right; }
    };

    Voilà mes doutes. Merci et bonsoir!


    //Paulinho2005.
      0  0

  5. #5
    Membre éprouvé
    Avatar de thecaptain
    Homme Profil pro
    Architecte de système d'information
    Inscrit en
    décembre 2003
    Messages
    919
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Architecte de système d'information

    Informations forums :
    Inscription : décembre 2003
    Messages : 919
    Points : 1 210
    Points
    1 210
    Par défaut
    Salut à tous,

    j'ai un souci dans le même style. J'essaie de coder la classe Queue (pour exercice donc). Jusque la pas de souci. Cependant, pensant à devoir coder Stack par après, j'ai fait une classe template DataNode qui se présente comme suit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    //DataNode.h
    #ifndef DATANODE_H
    #define DATANODE_H
     
    namespace list
    {
        template <typename T>
        class DataNode
        {
            public:
                    					DataNode(T* data); //constructor
                    void 				setData(T* data); //set the data of the node
                    T* 					getData(); //get the data of the node
     
            protected:
                    DataNode<T>*       	next; //next node
                    DataNode<T>*       	previous; //previous node      
     
            private:
            		void			   	init(); //init the node
                    T*                 	data_; //data of the DataNode
        };
    };
     
    #endif
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    //DataNode.ccp
    #include "DataNode.h"
     
    namespace list
    {
    	//------------//
    	//Constructors//
    	//------------//
        template <typename T>
        DataNode<T>::DataNode(T* data)
        {
        	init();
            setData(data);
        }
     
    	//--------------//
    	//Public methods//
    	//--------------//
        template <typename T>
        void DataNode<T>::setData(T* data)
        {
            data_ = data;
        }
     
        template <typename T>
        T* DataNode<T>::getData()
        {
            return data_;
        }
     
        //---------------//
        //Private methods//
        //---------------//
        template <typename T>
        void DataNode<T>::init()
        {
            //init the pointer
            next = 0;
            previous = 0;
        }
    };
    jusque la pas de souci, ca compile nickel et ca marche Le souci c'est de l'intégrer dans ma classe Queue qui est elle aussi un template. Je l'ai codée comme ceci :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    //Queue.h
    #ifndef QUEUE_H_
    #define QUEUE_H_
     
    #include "BasicList.h"
    #include "DataNode.cpp"
     
    namespace list
    {
    	template <typename T>
    	class Queue : public list::BasicList
    	{
    		public:
    							Queue(); //constructor
    			DataNode<T>*	getFirst(); //get the first node
    			DataNode<T>*	getLast(); //get the last node
    			int				size(); //get the size
            	void			add(T* data); //add an object
            	void			addNode(DataNode<T>* node); //add a node
            	T*				remove(); //remove an object
            	DataNode<T>*	removeNode(); //remove a node
     
    		private:
    			int				tSize; //size of the queue
    			DataNode<T>*	tFirst; //first node
    			DataNode<T>*	tLast; //last node
    	};
    }
     
    #endif
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    //Queue.ccp
    #include "Queue.h"
    #include "DataNode.h"
     
    namespace list
    {
    	//-----------//
    	//Constructor//
    	//-----------//
    	template <typename T>
    	Queue<T>::Queue()
    	{
    		tSize = 0;
    		tFirst = 0;
    		tLast = 0;
    	}
     
    	//--------------//
    	//Public methods//
    	//--------------//
    	template <typename T>
    	DataNode<T>* Queue<T>::getFirst()
    	{
    		return tFirst;
    	}
     
    	template <typename T>
    	DataNode<T>* Queue<T>::getLast()
    	{
    		return tLast;	
    	}
     
    	template <typename T>
    	int	Queue<T>::size()
    	{
    		return tSize;
    	}
     
    	template <typename T>
    	void Queue<T>::add(T* data)
    	{
    		DataNode<T> no(data);
    		addNode(&no); //la il me sort une erreur
    	}
     
    	template <typename T>
    	void Queue<T>::addNode(DataNode<T>* node)
    	{
    		//check the size
    		if (tSize == 0)
    		{
    			tLast = node;
    			tFirst = node;
    		}
     
    		//add the node at the end
    		else
    		{
    			tLast.next = node; //ici aussi erreur
    			node.previous = tLast; //la aussi
    			tLast = node;
    		}
     
    		//increment the size
    		tSize++;
    	}
     
    	template <typename T>
    	T* Queue<T>::remove()
    	{
    		return (tSize == 0) ? 0 : removeNode().getData(); //erreur :(
    	}
     
    	template <typename T>
    	DataNode<T>* Queue<T>::removeNode()
    	{
    		//check the size
    		if (tSize == 0)
    		{
    			return 0;	
    		}
     
    		//if there is only one node
    		if (tSize == 1)
    		{
    			tLast = 0;
    		}
     
    		//remove the node
    		DataNode<T>* removed = tFirst;
    		tFirst = removed.next; //encore une erreur
    		if (tFirst != 0)
    		{
    			tFirst.previous = 0; //et la aussi
    			removed.next = 0; //et ici aussi
    		}
     
    		//decrement the size
    		tSize--;
     
    		//return the removed object
    		return removed;
    	}
    }
    J'ai rapidos fait le main ci-dessous :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    //main.ccp
    #include "Main.h"
    #include <iostream>
    #include "ch/thecaptain/data/list/Queue.cpp"
     
    using namespace std;
    using namespace list;
     
    //template class Queue<int>; <-- j'ai trouvé ca sur
    //http://www.parashift.com/c++-faq-lite/templates.html
    //mais ca a pas l'air de marcher
     
    Main::Main()
    {
    };
     
    int main()
    {
    	int k = 15;
    	Queue<int> q;
    	q.add(&k); //la il me dit erreur
     
    	int* p = q.remove(); //la aussi
    	k = *p;
     
    	cout << k << endl;
     
    	return 0;
    };
    En bref, il me sort les erreurs suivantes (que j'ai de la peine à comprendre) :
    Citation Envoyé par le compilo
    Queue.cpp: In member function `T* list::Queue<T>::remove() [with T = int]':
    Main.cpp:20: instantiated from here
    Queue.cpp:70: request for member `getData' in `this->list::Queue<T>::removeNode() [with T = int]()', which is of non-aggregate type `list:ataNode<int>*'
    Queue.cpp: In member function `void list::Queue<T>::addNode(list:ataNode<T>*) [with T = int]':
    Queue.cpp:42: instantiated from `void list::Queue<T>::add(T*) [with T = int]'
    Main.cpp:18: instantiated from here
    Queue.cpp:58: request for member `next' in `this->list::Queue<int>::tLast', which is of non-aggregate type `list:ataNode<int>*'
    Queue.cpp:59: request for member `previous' in `node', which is of non-aggregate type `list:ataNode<int>*'
    Queue.cpp: In member function `list:ataNode<T>* list::Queue<T>::removeNode() [with T = int]':
    Queue.cpp:70: instantiated from `T* list::Queue<T>::remove() [with T = int]'
    Main.cpp:20: instantiated from here
    Queue.cpp:90: request for member `next' in `removed', which is of non-aggregate type `list:ataNode<int>*'
    Queue.cpp:93: request for member `previous' in `this->list::Queue<int>::tFirst', which is of non-aggregate type `list:ataNode<int>*'
    Queue.cpp:94: request for member `next' in `removed', which is of non-aggregate type `list:ataNode<int>*'
    Enfin, pour info, j'utilise Eclipse avec le plugin CDT avec le compilateur de dev-cpp (mingw32). Comment éclaircir tout ceci ?

    Merci d'avance

    @++
    Libzippp (C++)
    Lost in AStorm
      0  0

  6. #6
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 37
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2003
    Messages : 10 651
    Points : 15 920
    Points
    15 920
      0  0

Discussions similaires

  1. [Smarty] Pourquoi le php n'est pas recommandé dans les templates ?
    Par SlymDesign dans le forum Bibliothèques et frameworks
    Réponses: 5
    Dernier message: 10/10/2007, 12h21
  2. Bug aléatoire et pas très bien compris (open/close_system)
    Par LordPeterPan2 dans le forum Simulink
    Réponses: 8
    Dernier message: 03/07/2007, 12h08
  3. Réponses: 17
    Dernier message: 03/09/2006, 20h46
  4. 2 SELECT Qui ne s'entendent pas très bien entre eux :(
    Par moutanakid dans le forum MS SQL Server
    Réponses: 2
    Dernier message: 05/08/2004, 17h46

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo