Discussion :

[gassi64]

Bonjour,
j'ai lu que pour vider une std::queue on faisait :

Code :

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

1
2
3
4
5
6
 
void clear(std::queue <void * > &q)
{
   std::queue< void * > empty;
   std::swap( q, empty );
}

Je voudrais rendre cette fonction template pour la faire fonctionner pour des void* mais aussi des objets de types que j'ai créé.
J'ai fait :

Code :

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

1
2
3
4
5
6
7
 
template <typename T> 
	void clear(std::queue <T* > &q)
{
   std::queue< T* > empty;
   std::swap( q, empty );
}

Cependant cela ne compile même pas.

fatal error C1001: INTERNAL COMPILER ERROR
(compiler file 'msc1.cpp', line 1786)
Please choose the Technical Support command on the Visual C++
Help menu, or open the Technical Support help file for more information
Error executing cl.exe.

Les template ne s'appliquent ils qu'aux classes ? Ne puis je pas faire ce que je souhaite? Ou y a t'il mieux pour nettoyer une std:queue contenant des objets homogènes quelconques ?

Merci...

[Dalini71]

Hello,

La ligne qui fait planter, se serait pas celle du swap ?

[gassi64]

en fait ca plante pas, ça compile même pas !
pourquoi? peut être que le swap n'aime pas le template ?

[Dalini71]

Je viens de tester vite fait :

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
using namespace std;
 
template <typename T>
void clear(queue <T*> &q)
{
   queue< T* > empty;
   swap( q, empty );
}
 
int main()
{
    queue<int*> q;
    clear(q);
    queue<void*> q2;
    clear(q2);
    return 0;
}

et ça compile sans problème.
Soit j'ai loupé quelque chose, soit ça vient d'autre part dans ton code IMO.

[gassi64]

Hum...moi sans l'utiliser ça compile, mais en utilisant clear(q) sur la queue<void*> j'obtiens :

error LNK2001: unresolved external symbol "void __cdecl clear(class std::queue<void *,class std::deque<void *,class std::allocator<void *> > > &)" (?clear@@YAXAAV?$queue@PAXV?$deque@PAXV?$allocator@PAX@std@@@std@@@std@@@Z)

et sur la queue<MaClass*> :

error C2664: 'clear' : cannot convert parameter 1 from 'class std::queue<class Parameter *,class std::deque<class Parameter *,cl
ass std::allocator<class Parameter *> > >' to 'class std::queue<void *,class std::deque<void *,class std::allocator<void *> > > &'
A reference that is not to 'const' cannot be bound to a non-lvalue
Error executing cl.exe.

[Dalini71]

Fais voir le portion de code concernée, doit y avoir un truc qui coince, aucune raison que ça marche chez moi et pas chez toi

[3DArchi]

Salut,
Le problème de link ne serait-il pas du à ce que la définition de la fonction template est dans un module cpp à part (cf. FAQ)?
Les erreurs que tu présentes laissent à penser que ton utilisation n'est pas aussi triviale que le code que tu présentes. Peux-tu proposer le code exact qui te pose problème ?

[Davidbrcz]

Pourquoi ne pas poper tant que ce nest pas vide ?

[3DArchi]

Pourquoi ne pas poper tant que ce nest pas vide ?

C'est comme pour un vector. Quand tu supprimes un élément, tu es sûr que le destructeur est appelé, en revanche, l'espace mémoire n'est pas forcément libéré. Avec cette méthode, tu obliges à libérer le conteneur précédent puisqu'avec le swap il change vers une variable de portée locale détruite en sortie de fonction.

[gassi64]

voici le code exact que j'ai remodelé pour en faire un test simple et qui donne la même erreur :

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
 
#include <iostream>
#include <queue>
 
class Parameter 
{
public:
	Parameter();
	Parameter(void* value, std::string ptrType);
 
	void* getValue();
	std::string getPtrType();
 
private:
	void* m_value;
	std::string m_ptrType;
};
 
Parameter::Parameter()
{
}
 
Parameter::Parameter(void* value, std::string ptrType)	
	: m_value(value), m_ptrType(ptrType)
{	
}
 
void* Parameter::getValue()
{
	return m_value;
}
 
std::string Parameter::getPtrType()
{
	return m_ptrType;
}
 
template <typename T> void clear(std::queue<T*> &q);
 
static std::queue<Parameter*> qtWidgetParametersQueue2;
 
int main(int argc, char* argv[])
{
	printf("begin treatment\n");
 
	qtWidgetParametersQueue2.push(new Parameter(reinterpret_cast<void*> (new char*("Toto OnFire")), "String"));
 
	clear(qtWidgetParametersQueue2);
 
	printf("end treatment\n");
 
	return 0;
}
 
template <typename T> 
	void clear(std::queue<T*> &q)
{
	std::queue< T * > empty;
	std::swap( q, empty );
}

Erreur :

--------------------Configuration: testQueue - Win32 Debug--------------------
Compiling...
testQueue.cpp(52) : fatal error C1001: INTERNAL COMPILER ERROR
(compiler file 'msc1.cpp', line 1786)
Please choose the Technical Support command on the Visual C++
Help menu, or open the Technical Support help file for more information
Error executing cl.exe.
testQueue.exe - 1 error(s), 0 warning(s)

L'erreur proviendrait elle du compilateur Visual C++ 6.0 ?


PS : Je swap un truc static ! n'est ce pas là l'erreur ???

[3DArchi]

L'erreur proviendrait elle du compilateur Visual C++ 6.0 ?

Il y a des chances
Pourquoi ne pas utiliser un compilo plus récent (Visual express ou MinGW si tu es sous windows) ?

[EDIT] : ton code compile sans (presque) aucun problème avec Visual Express et avec MinGW chez moi. Seul printf n'est pas reconnu sans l'en-tête adéquat (mais pourquoi ne pas utiliser std::cout dans du code C++ ? ) et un warning sur

Code :

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

Parameter(reinterpret_cast<void*> (new char*("Toto OnFire")), "String")

[Dalini71]

C'est comme pour un vector. Quand tu supprimes un élément, tu es sûr que le destructeur est appelé, en revanche, l'espace mémoire n'est pas forcément libéré. Avec cette méthode, tu obliges à libérer le conteneur précédent puisqu'avec le swap il change vers une variable de portée locale détruite en sortie de fonction.

Ca veut dire que pour vider un vector on devrait également utiliser cette méthode ?
myVector.clear() ou myVector.eraze(begin, end) ne suffisent pas ?

Sinon, c'est normal que std::queue ne possède pas une méthode permettant de libérer la mémoire ?

[3DArchi]

Ca veut dire que pour vider un vector on devrait également utiliser cette méthode ?
myVector.clear() ou myVector.eraze(begin, end) ne suffisent pas ?

Tout dépend du contexte. Si tu vides un vecteur pour le remplir ensuite, alors autant garder le bénéfice de la mémoire déjà allouée. Si en revanche tu veux gérer au plus près la mémoire utilisée, alors oui, ça peut être une solution.
[EDIT] clear/erase te garantissent que les destructeurs des éléments sont appelés mais pas forcément que la mémoire où sont effectivement les éléments est supprimée. Ca optimise les allocations/libérations

[Goten]

Pour le vector il y'a le swap trick...
std::vector<T>(someVector).swap(someVector);

Enfin dans la plus part des cas c'est pas intéressant de le faire, si il libère pas lui même y'a une raison, question d'optimisation comme l'a dit 3Darchi

[gassi64]

J'ai testé le code sur QtCreator...ça marche bien (donc avec MinGW)
...

Je vais changer mon programme pour ne plus utiliser de template...puis quand le chef se décidera pour le dernier visual on sort le champagne

Merci à tous

[3DArchi]

Pour le vector il y'a le swap trick...

Effectivement. C'est en gros la fonction proposée au début de la discussion.

[Goten]

Oui mais je répondais à Dalini dans le cas spécifique du vector qui possède une fonction membre swap.

Par rapport au PO : visual c++ 6.0 est vraiment vieux et deprecated. C'est pas étonnant qu'il est du mal .