STL et G++ : bind2nd et generate non reconnus ?

Version imprimable

16/05/2008, 23h40
Muetdhiver

STL et G++ : bind2nd et generate non reconnus ?
Bonjour,

J'avais un programme qui compilait parfaitement sous Visual C++ 2005.
Maintenant j'essai de le compiler avec Eclipse CDT sous Ubuntu. Pas mal de truc fonctionne mais il me reste ces problèmes avec l'utilisation des fonctions "bind2nd" et "generate" de la STL. Voici par exemple un cas d'utilisation :
Code:

1 2 3 4 std::generate( m_po_configuration->Get_Rack().begin() + loc_uc_previous_size, m_po_configuration->Get_Rack().end(), TRandomAlphabet( m_po_configuration ) );
Et voici ce que me répond GCC :

Citation:

erreur: no matching function for call to «generate(__gnu_cxx::__normal_iterator<TLetter**, std::vector<TLetter*, std::allocator<TLetter*> > >, __gnu_cxx::__normal_iterator<TLetter**, std::vector<TLetter*, std::allocator<TLetter*> > >, TGrid::Update_Rack_Randomly()::TRandomAlphabet)»

Je ne comprends donc rien : y a til quelque chose a faire pour faire coucher GCC et la STL ? Merci.

Alex.
17/05/2008, 10h03
loufoque

T'as bien inclus <algorithm> ?
18/05/2008, 11h08
Muetdhiver

Oui oui bien sur j'ai inclu <algorithm> d'ailleurs ca compile très bien sous Visual.

D'ailleurs dans cette même classe j'ai inclu <algorithm> pour trois fonctions : for_each, find_if et generate.

Et seul generate ne compile pas !!!!

En tout cas merci pour l'aide.

Alex.
18/05/2008, 13h00
Montag

Salut,

Pour qu'on puisse réellement t'aider il faudrait que tu fournisses un code compilable qui reproduise ton problème.

Très bien, alors voici une classe simplifiée de mon erreur avec generate :

.h
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #ifndef ESSAI_H_ #define ESSAI_H_ class Essai { public : void Main() ; }; #endif /*ESSAI_H_*/
et .cpp
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 #include "stdafx.h" #include "Essai.h" #include <algorithm> #include <vector> #include <ctime> void Essai::Main() { std::vector<int> vect(10); // Random functor class TestRand { public : TestRand( ){} int operator()() { static bool loc_b_init = false; if ( !loc_b_init ) { srand((unsigned int)time(NULL)); loc_b_init = true ; int loc_uc_num = static_cast<int>( rand() % ( 100 - 1 ) ) ; return loc_uc_num ; } else { return 0 ; } } }; std::generate( vect.begin(), vect.end(), TestRand() ); }
Résultat :

Citation:

../Krablenet/Sources/Essai.cpp: In member function «void Essai::Main()»:
../Krablenet/Sources/Essai.cpp:38: erreur: no matching function for call to «generate(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, Essai::Main()::TestRand)»

Alors que ca compile très bien sur Visual. Que se passe-t-il ? Le compilo de Visual m'a-t-il laissé passé une aberration ?

Merci.
Alex.

18/05/2008, 17h01
loufoque

Il faut que ta classe TestRand soit à la portée du fichier.
En effet, les types utilisés pour instancier des templates doivent avoir un linkage global. (ou un truc comme ça, je suis plus trop sûr des termes)
18/05/2008, 18h53
Muetdhiver
Citation:

Envoyé par loufoque

Il faut que ta classe TestRand soit à la portée du fichier.
En effet, les types utilisés pour instancier des templates doivent avoir un linkage global. (ou un truc comme ça, je suis plus trop sûr des termes)

Ok merci.
J'ai essayé la chose suivante :
1) déplacer la déclaration de classe TestRand dans la classe Essai (dans le fichier .h).
2) Déclarer la méthode
Code:

1 2 3 4 5 6 int Essai::TestRand::operator()() { blabla }
3) L'utiliser dans mon generate de la sorte :

Citation:

std::generate( vect.begin(), vect.end(), Essai::TestRand() );

Voila, ca compile, mais les questions sont les suivantes :
Pourquoi mon ancien code ne compilait pas sous GCC mais sous Visual ?
N'y a t il pas moyen de garder mon ancienne facon de fonctionner que je trouve beaucoup plus élégante (le foncteur n'est dispo que dans la fonction qui va bien, mais pas du tout dans toute la classe), on réduit donc sa portée au minimum vital ?

En gros, pourquoi ne peut on pas déclarer une classe dans une fonction membre d'une autre classe (comme un foncteur local), ou alors comment ruser pour le faire ?

Merci pour votre aide.

Salut
Pourquoi utiliser une class pour un foncteur? une struct peut suffire (struct == class public)

Sinon le problème est que la déclaration d'une class dans une fonction n'est pas standard (je croie)
Tu n'est pas obligé de le mettre dans le .h, ceci suffit et est trés proche de ce que tu fait :

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
#include "stdafx.h"
#include "Essai.h"
#include <algorithm>
#include <vector>
#include <ctime>
 
 
// Random functor
	struct TestRand
	{	
		int operator()()
		{
			static bool loc_b_init = false;			
 
			if ( !loc_b_init )
			{
				srand((unsigned int)time(NULL));
				loc_b_init = true ;			
 
				int loc_uc_num =	static_cast<int>( rand() % ( 100 - 1 ) ) ;
 
				return loc_uc_num ;	
			}		
			else
			{
				return 0 ;
			}		
		}
	};
 
 
void
Essai::Main()
{
	std::vector<int> vect(10);
 
	std::generate( vect.begin(), vect.end(), TestRand() );
}

18/05/2008, 22h53
Montag

Citation:

Sinon le problème est que la déclaration d'une class dans une fonction n'est pas standard (je crois)

Il est tout à fait possible de définir une classe dans une fonction. Le problème c'est qu'on ne peut pas utiliser un type "local" (i.e déclaré dans une fonction) comme argument template.
19/05/2008, 09h18
yan

Citation:

Envoyé par Montag

Il est tout à fait possible de définir une classe dans une fonction. Le problème c'est qu'on ne peut pas utiliser un type "local" (i.e déclaré dans une fonction) comme argument template.

ha ok c'est ça la différence.
19/05/2008, 10h39
Muetdhiver

Merci pour vos réponses.
Je suis d'accord avec toi Mongaulois, a terme je vais vraiment être obligé de faire ce que tu me préconises, puisque donc, je viens de l'apprendre, utiliser un type local comme argument d'un template n'est possible que sous Visual (pas standard, donc, le Visual....).

Mais cela dit je trouve ca moche d'avoir une classe (ou une struct) au milieu de rien, entre deux fonctions membres de classe, utilisable par n'importe quelle autre classe important mon fichier.

Par exemple, si j'ai un fichier Essai2.cpp, j'importe Essai.cpp, et hop je peux réutiliser mon foncteur ! Enfin ca me parait pas très carré comme fonctionnement, mais si c'est la seule façon de faire avec la STL + les foncteurs, alors je dis amen !

Merci.
++
19/05/2008, 14h55
JolyLoic

C'est effectivement pas très propre, mais il faut faire comme ça aujourd'hui.

Ca fait partie des évolutions proposées de la norme :
http://www.open-std.org/jtc1/sc22/wg...2007/n2402.pdf
19/05/2008, 20h20
loufoque

Citation:

Pourquoi mon ancien code ne compilait pas sous GCC mais sous Visual ?

Parce GCC respecte la norme, et pas Visual C++.
En fait, il me semble que GCC acceptait ce genre de code dans de précédentes versions, mais qu'ils ont changé de comportement pour suivre le standard.