Discussion :

[thecaptain]

Salut à tous,

Navré de reposter le message, mais le sujet précédent étant résolu, je pense que j'aurais plus de chance d'avoir une réponse
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) :

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

@++