Discussion :

[foulques.nera]

Bonjour,

je souhaite implémenter une classe surchargeant std::list< xx>.

J'ai commencé par écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
template< class _Data> 
class ZList : public list< _Data> {
	private:
		ZMutex _access;
	public:
		ZList();
		void clear();		
		void pop_back();
		void pop_front();
		void push_back(const _Data& val);
		void push_front(const _Data& val);
		void remove(const _Data& val);
   };

Mais le compilateur tique sur l'implémentation de remove :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
void ZList<class _Data>::remove(
	const _Data& val) {
 
	ZMutexLocker loker( _access);
	list::remove( val);
	}

Quelqu'un a il un exemple de ce type de surcharge ?

[Bousk]

Bonjour,

d'abord, hériter de std::list est une mauvaise idée, le destructeur n'est pas virtuel.
Ensuite, où est ce code ? dans un fichier header j'espère ?
Enfin, la syntaxe est mauvaise, puisque la bonne est la suivante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template< class T >
void MyClass::MyFunction() {}

[foulques.nera]

Excellent conseil qui change tout.
Mais puisque vous le suggérer, qu'y a t'il de mieux que la std::list dans la STD ?

[Ehonn]

Comme le dis Bousk, ton code template doit être dans un fichier d'en-tête
Tu utilises list dans ton code, qui est un std::list
La FAQ C++ dit: http://cpp.developpez.com/faq/cpp/?p...PACE_using_std
«Il est conseillé de limiter l'utilisation de using namespace car cela fait tout simplement perdre l'utilité des namespaces. En particulier, son usage est à proscrire dans les fichiers d'en-tête»

[Ehonn]

Excellent conseil qui change tout.
Mais puisque vous le suggérer, qu'y a t'il de mieux que la std::list dans la STD ?

std::list est très bien (ça dépend de ce que vous voulez faire)

Bousk dit que c'est une mauvaise idée d'hériter de std::list car son destructeur n'est pas virtuel.
http://cpp.developpez.com/faq/cpp/?p...ge_destructeur
Préférer donc une agrégation ou un typedef (si un seul type) ou un alias de templates de C++11.

[koala01]

Salut,

Excellent conseil qui change tout.
Mais puisque vous le suggérer, qu'y a t'il de mieux que la std::list dans la STD ?

Le problème n'est pas (forcément) que std::list est inadapté à tes besoins...

Le problème est, surtout, que std::list (et toutes les collections fournies par le standard, d'ailleurs) ont une sémantique de valeur, et que les classes ayant sémantique de valeur ne sont pas destinées à servir à un héritage public.

Outre ce problème de sémantique et l'absence de destructeur virtuel, on peut aussi citer le fait que, pour envisager un héritage public, il faut respecter le principe de substitution de liskov (LSP de son petit nom) et que ce principe s'appuie, entre autres, sur des règles de programmation par contrat, dont, pour ce qui nous intéresse une règle qui dit que

les préconditions (les conditions que doit remplir un objet avant l'exécution d'une partie de code) ne peuvent pas être plus fortes pour le type dérivé que pour le type de base

Or, le fait d'avoir une précondition (qui apparaitra d'ailleurs dans ton code sous la forme d'un test sur le mutex ) de "il n'y a pas de mutex qui vient bloquer l'exécution sur la fonction" est un renforcement de "pas de précondition du tout".

Tu ne peux donc pas, conceptuellement parlant, envisager de dire que ta ZList... est une liste.

Au pire, peux-tu considérer que ta ZList est... "implémentée sous la forme" d'une liste, au mieux, tu considère que ta ZList... utilise une liste en interne pour rendre les services que l'on en attend

Dans le premier cas, tu devrais utiliser l'héritage privé, dans le second cas, tu devrais créer un membre de type std::list<_Data> et dans tous les cas appeler les fonctions qui vont bien de std::list<_data> dans celles que tu crées pour ta ZList

[foulques.nera]

La seconde solution convient à mon niveau de débutant. Merci.