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

Version imprimable

29/10/2005, 21h45
Paulinho

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!
29/10/2005, 22h53
Strab

Citation:

Envoyé par Règles du forum

Nous ne sommes pas là non plus pour faire vos exercices.
30/10/2005, 19h31
Laurent Gomila

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.

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:

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:

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.

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:

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:

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:

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:

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:

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::DataNode<int>*'
Queue.cpp: In member function `void list::Queue<T>::addNode(list::DataNode<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::DataNode<int>*'
Queue.cpp:59: request for member `previous' in `node', which is of non-aggregate type `list::DataNode<int>*'
Queue.cpp: In member function `list::DataNode<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::DataNode<int>*'
Queue.cpp:93: request for member `previous' in `this->list::Queue<int>::tFirst', which is of non-aggregate type `list::DataNode<int>*'
Queue.cpp:94: request for member `next' in `removed', which is of non-aggregate type `list::DataNode<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 :)

@++

07/11/2005, 10h24
Laurent Gomila

Merci de ne pas multiposter

http://www.developpez.net/forums/vie....php?p=2348378