Problème fonction template

Version imprimable

24/09/2010, 15h31
scheme

Problème fonction template
Bonjour à tous, j'ai un problème de compilation avec cette fonction:
Code:

1 2 3 4 5 6 7 8 template<typename T> int read(int key, T & sortie) { switch(m_instructions.type) { case STRING: sortie = linesPart.front(); //retourne une string return (1); } }
J'ai enlevé beaucoup de choses de cette fonction, j'espère que ça suffit pour comprendre.
linesPart.front(); retourne une string. Le compilateur me jette en disant:

Code:

cannot convert ‘std::basic_string<char, std::char_traits<char>, std::allocator<char> >’ to ‘int’ in assignment

d'ou sort ce int ? Pourquoi je ne peux pas mettre une string dans sortie alors que le compilateur ne sait même pas quelle type elle a ?

Je pensais que ces vérifications se faisaient à l'éxécution, je ne comprend pas pourquoi ça plante à la compilation.

Merci d'avance de votre aide ;)
24/09/2010, 15h49
koala01

Salut,

N'essayerais tu pas de passer autre chose qu'une std::string à ta fonction comme paramètre pour sortie :question:

De toute évidence, il semblerait que tu essaye de passer un entier, et il est donc parfaitement logique que le compilateur se plaigne de ne pas être en mesure de convertir un std::string en int ;)
24/09/2010, 15h52
Aleph69

Bonjour,

envoie le code où tu appelles ta fonction read.
A priori, tu as un type non reconnu.
Par exemple, tu as pu oublier d'inclure <string>.
Ca peut aussi venir du fait que tu n'as pas précisé que ta chaîne vient de la bibliothèque standard (remplacer string par std::string).
Le compilo essaye de convertir en int par défaut (sous visual en tous cas) et te renvoie ce genre d'erreur.

Le code est assez imposant, mais je ne peux pas vous envoyer la fonction string sans vous envoyer le reste. Ca donne ça:

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
//FileConfig.h
 
#ifndef FILECONFIG_H_
#define FILECONFIG_H_
 
#include "File.h"
#include "configFileMacros.h"
#include <fstream>
#include <vector>
 
using namespace std;
 
enum dataType {
	INT,
	FLOAT,
	DATE,
	SET,
	STRING
};
 
struct instructions {
	int lineNumber;
	dataType type;
};
 
 
class FileConfig: public File {
public:
	FileConfig(string _path);
	virtual ~FileConfig();
 
	using File::read;
 
	int keyToInstructions(int key);
	void setInstructions(int _lineNumber, dataType _type) {
		m_instructions.lineNumber = _lineNumber;
		m_instructions.type = _type;
	}
	vector<string> stringSplit(string str, char separateur = ';');
	string removeSpaces( string stringIn );
 
	template<typename T>
	bool fromString( const string & str, T & Dest ) //transforme la string vers un autre type
	{
	    istringstream iss( str ); // créer un flux à partir de la chaîne donnée
	    return iss >> Dest != 0; // tenter la conversion vers Dest
	}
 
	template<typename T>
	int read(int key, T & sortie) {
		keyToInstructions(key);
		ifstream file(path.c_str());
 
		vector<string> linesFull;
		string stringTmp;
 
        while (getline(file, stringTmp))
        	linesFull.push_back(stringTmp);
        file.close();
 
        for(unsigned int i = 0; i < linesFull.size(); i++) {
        	removeSpaces(linesFull.at(i));
        	if(linesFull[i].at(0) == ';') linesFull.at(i).erase();
        }
 
        vector<string> linesPart = stringSplit(linesFull[m_instructions.lineNumber]);
 
    	vector<string> dateTmp = stringSplit(linesPart.front(), ',');
    	vector<int> date;
 
        switch(m_instructions.type) {
        case INT:
        	int result_int;
        	sortie = fromString(linesPart.front(), result_int);
        	return (1);
        case FLOAT:
        	float result_float;
        	sortie = fromString(linesPart.front(), result_float);
        	return (1);
        case STRING:
        	//sortie = linesPart.front();
        	return (1);
        case DATE:
        	for(int i = 0; i < (int) dateTmp.size(); i++)
        		int test = atoi(dateTmp[i].c_str());
        		//date.push_back(atoi(dateTmp[i].c_str()));
        	sortie = date;
        	return (1);
        case SET:
        	sortie = stringSplit(linesPart.front(), ',');
        	return (1);
        default: return (0);
        }
	}
 
protected:
	struct instructions m_instructions;
	string path;
 
};
 
#endif /* FILECONFIG_H_ */

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
 
//FileConfig.cpp
 
#include "FileConfig.h"
 
FileConfig::FileConfig(string _path) : File(_path) {
}
 
FileConfig::~FileConfig() {
}
 
vector<string> FileConfig::stringSplit(string str, char separateur) {
	vector<string> result;
	unsigned int cutAt;
	while( (cutAt = str.find_first_of(separateur)) != str.npos )
	{
		if(cutAt > 0)
		{
			result.push_back(str.substr(0,cutAt));
		}
		str = str.substr(cutAt+1);
	}
	if(str.length() > 0)
	{
		result.push_back(str);
	}
	return result;
}
 
string FileConfig::removeSpaces( string stringIn ) {
	string::size_type pos = 0;
	bool spacesLeft = true;
 
	while( spacesLeft )
	{
		pos = stringIn.find(" ");
		if( pos != string::npos )
			stringIn.erase( pos, 1 );
		else
			spacesLeft = false;
	}
 
	return stringIn;
}
 
int FileConfig::keyToInstructions(int key) {
	switch(key) {
	case OBS_TYPE: // obs_type (0, 2 ou 3)
		setInstructions(0, INT);
		return (1);
	case DATE_MERIDIEN: // date méridien (jj/mm/aaaa)
		setInstructions(1, DATE);
		return (1);
        case REF: //reference
                setInstructions(2, STRING);
                return (1);
        // [...]
	case RECEPTEUR_MANUEL: // (0-sans, 1-oui)
		setInstructions(34, INT);
		return (1);
	default:
		cout << "setInstructions fail: bad key number" << endl;
		return (0);
	}
}

et j'appelle la classe à partir d'une autre, de cette manière:

Code:

1
2
3
FileConfig file("cur/config.cur");
int type;
int status = file.read(OBS_TYPE, type);

Il y a surement des erreurs dans les méthodes, je n'ai pas encore réussi à le compiler complètement donc à faire des tests.

Dans mon exemple, j'envoie un int, donc dans le switch principal je devrais tomber sur le case INT, par sur le case STRING. Je ne comprend donc pas pourquoi j'ai cette erreur avec ce cas. J'espère que vous arrivez à comprendre le code, il est compliqué parce que le fichier de configuration que je dois lire est complètement hétérogène, il est fait de cette manière (et je ne peux pas le modifier):

Code:

1
2
3
4
5
6
7
8
9
10
;  -------------------------------------------------------- 
;  Fichier : /data2/cur/manip.cfg
;  Tout ce qui suit un point-virgule est un commentaire 
;  Dans une ligne, les parametres sont separes par une virgule
;  -------------------------------------------------------- 
0		; Type (0-soleil, 1-acq, 2-ctr, 3-test, 4-para)
26,08,2010 ;
SOLEIL		; Reference
1		; Coordonnnes Auto (1-oui, 0-non)
11,53,02, 47 ;

C'est très sympa de m'apporter votre aide :)

24/09/2010, 16h32
Aleph69
koala01 avait raison : tu passes bien un entier en paramètre au lieu d'un string... 8O
Code:

1 2 3 int type; int status = file.read(OBS_TYPE, type);
24/09/2010, 16h51
scheme

Oui, mais le problème n'est pas là, normalement ça ne devrait pas tomber dans le case STRING mais dans le case INT.

Dans mon switch principal, je n'ai pas de problème pour les case INT et FLOAT, mais j'en ai pour STRING, DATE et SET. Je ne comprend pas du tout pourquoi :s

Ca m'affiche la même erreur pour les 3 cas :calim2:
24/09/2010, 21h22
Aleph69

A quoi correspond OBS_TYPE?
A priori, il ne contient pas la valeur que tu penses.
25/09/2010, 00h50
scheme

OBS_TYPE est :

Code:

#define OBS_TYPE 0

donc int à priori
25/09/2010, 11h38
Jean-Marc.Bourguet

Même si tu ne passes pas dans une des branches de ton switch, elle doit être valide.

Citation:

Envoyé par scheme

Oui, mais le problème n'est pas là, normalement ça ne devrait pas tomber dans le case STRING mais dans le case INT.

Comment le compilateur le sait ? => d'où la réponse de Jean Marc. Toute ta fonction instanciée doit être valide.

Tu pourrais utiliser une classe trait et rendre ton switch/case plus contraignant (à la volée) :
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 enum dataType { INT, FLOAT, DATE, SET, STRING }; template<typename T> struct trait; template<int> struct trait<int> { static const dataType e_type = INT; typedef int type_retour; }; //etc... template<typename T> int read(int key, T & sortie) { typedef trait<T> trait_t; // ... switch(m_instructions.type) { case trait_t::e_type: typename trait_t::type_retour result; sortie = fromString(linesPart.front(), result); return (1); default: //erreur; return 0; }

27/09/2010, 11h38
scheme

Je ne savais pas que toutes les branches du switch devaient compiler en fonction de ce qu'on rentre dans la fonction, même si à l'exécution on ne passe pas par elle :s

C'est très embêtant, je ne sais pas encore comment je vais me débrouiller du coup :calim2:

Merci de m'avoir apporté votre aide :)

Citation:

Envoyé par scheme

C'est très embêtant, je ne sais pas encore comment je vais me débrouiller du coup :calim2:

Et en explorant la classe trait comme proposé avant pour avoir un switch dépendant du type instancié :

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
enum dataType {
    INT,
    FLOAT,
    DATE,
    SET,
    STRING
};
 
template<typename T> struct trait;
 
template<int> struct trait<int>
{
    static const dataType e_type = INT;
    typedef int type_retour;
};
//etc...
 
template<typename T>
int read(int key, T & sortie) {
   typedef trait<T> trait_t;
   // ... 
       switch(m_instructions.type) {
       case trait_t::e_type:
            typename trait_t::type_retour result;
            sortie = fromString(linesPart.front(), result);
            return (1);
       default:
          //erreur;
          return 0;
       }