[template] transformer une classe en template

Version imprimable

bonjour j'ai le code suivant

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
class ThreadList {
public:
	class iterator{
	private:
		ThreadList *source;
		int index = 0;
	public:
		iterator(ThreadList *source) : source(source){
			try{
				source->iteratorAdded();
			}
			catch (...){
			}
		};
		iterator(iterator &iter) : iterator(iter.source) {
		};
		~iterator(){
			try{
				source->iteratorDeleted();
			}
			catch (...){
			}
		}
		IThread* operator*() 
		{ 
			try{
				return source->list[index];
			}
			catch (...){
				return NULL;
			}
		}
		IThread* operator++()
		{
			IThread* i = source->list[index];
			index ++;
			return i;
		}
		bool operator!=(const int& rhs)
		{
			return !(index >= source->list.size() && rhs == 0);
		}
	};
private:
	bool _AutoStart;
	int _Iterator;
	void iteratorAdded() {
		_Iterator++;
		cout << "iterator added = " << _Iterator << endl;
	}
	void iteratorDeleted(){		
		_Iterator--;
		cout << "iterator deleted = " << _Iterator << endl;
		if (_Iterator == 0){
			clearList();
		}
	};
	void clearList(){
		cout << "Clear list" << endl;
	};
public:
	ThreadList(bool autoStart = true) {
		_AutoStart = autoStart;
		_Iterator = 0;
	}
	~ThreadList() {
		for (vector<IThread*>::iterator it = list.begin();
			it < list.end(); it++) {
			delete (*it);
		}
	}
	void add(IThread* thread) {
		if (_AutoStart)
			thread->start();
		list.push_back(thread);		
	}
	iterator begin(){		
		iterator it(this);
		return it;
	}
private:
	vector<IThread*> list;
};

et j'essai de la transformer en template

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
template<class T>
class ClearableList {
public:
	class iterator{
	private:
		T source;
		int index = 0;
	public:
		iterator(T source) : source(source){
			try{
				source.iteratorAdded();
			}
			catch (...){
			}
		};
		iterator(iterator &iter) : iterator(iter.source) {
		};
		~iterator(){
			try{
				source->iteratorDeleted();
			}
			catch (...){
			}
		}
		T operator*()
		{
			try{
				return source.list[index];
			}
			catch (...){
				return NULL;
			}
		}
		T operator++()
		{
			IThread* i = source->list[index];
			index++;
			return i;
		}
		bool operator!=(const int& rhs)
		{
			return !(index >= source.list.size() && rhs == 0);
		}
	};
private:
	int _Iterator;
	void iteratorAdded() {
		_Iterator++;
		cout << "iterator added = " << _Iterator << endl;
	}
	void iteratorDeleted(){
		_Iterator--;
		cout << "iterator deleted = " << _Iterator << endl;
		if (_Iterator == 0){
			clearList();
		}
	};
	void clearList(){
		cout << "Clear list" << endl;
	};
public:
	ClearableList() {
		_Iterator = 0;
	}
	~ClearableList() {
		for (vector<T>::iterator it = list.begin();
			it < list.end(); it++) {
			delete (*it);
		}
	}
	void add(T value) {
		list.push_back(value);
	}
	iterator begin(){
		iterator it(this);
		return it;
	}
private:
	vector<T> list;
};

or j'ai un problème sur la fonction (il ne veut pas compiler)

Code:

1
2
3
4
iterator begin(){
		iterator it(this);
		return it;
	}

vous auriez une idée ?

24/09/2014, 20h18
jo_link_noir

Et l'erreur ?

À vu de nez se n'est pas T qu'il faut utiliser pour iterator::source mais ClearableList*.
Aussi, tu ne devrais pas t'autoriser des delete sur T car tu manipules des T et non des T*. Sinon, quant tu voudra utiliser des pointeur intelligent ça ne fonctionnera plus.

(En fait, pour mettre en template il suffit de faire rechercher/remplacer (IThread -> T ou IThread* -> T).)
(et éventuellement ajouter des références (constantes).)

Pourquoi ne pas utiliser vector<t>::iterator ?

voila quand je fais ca
Code:

1 2 3 4 5 6 7 8 ClearableList<IThread*> it; ClearableList<IThread*> *i = new ClearableList<IThread*>(); i->add(new IThread); i->add(new IThread); i->add(new IThread); ClearableList<IThread*>::iterator x = i->begin();
j'ai l'erreur

Code:

error C2664: 'ClearableList<IThread *>::iterator::iterator(ClearableList<IThread *>::iterator &)'*: impossible de convertir l'argument 1 de 'ClearableList<IThread *> *const ' en 'IThread *'

sur la ligne

Code:

ClearableList<IThread*>::iterator x = i->begin();

Citation:

Envoyé par jo_link_noir

Pourquoi ne pas utiliser vector<t>::iterator ?

si je fais cette classe c justement pour masquer que j'utilise un vector, donc je ne vais pas utiliser son iterator, en plus je veux gérer une mise a jour de la liste quand on a plus d'iterator d'utilisé

ce que je comprend pas par contre c'est la raison pour laquelle le passage de la classe au template pose problème .....

01/10/2014, 10h25
Invité
Salut,

le message est clair pourtant :

Code:

error C2664: 'ClearableList<IThread *>::iterator::iterator(ClearableList<IThread *>::iterator &)'*: impossible de convertir l'argument 1 de 'ClearableList<IThread *> *const ' en 'IThread *'

Il te dit qu'il ne peut pas convertir une variable constante en une variable non constante. (ce qui est logique)

As tu essayé avec un const_iterator ?
Code:

1 2 ClearableList<IThread*>::const_iterator x = i->begin();

En général les gens s'en moque de connaitre le type de l'itérateur, ce qu'ils veulent c'est l'utiliser. En faite utiliser directement celui de std::vector ce n'est pas exposer ton implémentation, c'est juste réutiliser ce qui marche. Et comme ton élément à des services proche du std::vector qu'il stocke, je partirais même sur :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 template<class T> struct ClearableList : private std::vector<T> { using std::vector<T>::iterator; using std::vector<T>::begin; using std::vector<T>::end; void add(const T& value) { push_back(value); } void add(T&& value) { push_back(std::move(value)); } };
(Non testé)