Problème conteneur map

Version imprimable

Bonjour à tous. Voila j'ai une erreur de compilation sur ce code mais je sais pas pourquoi :

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
#ifndef __ISoundType_H__
#define __ISoundType_H__
 
#include <map>
#include <string>
#include "SLEType.h"
 
namespace SLE
{
	namespace Audio
	{
		//Classe abstraite pour la gestion des sons
		template<typename T>
		class ISoundType
		{
		public:
                        ISoundType(){}
			virtual ~ISoundType(){}
 
			//Enregistre un son dans le conteneur
			virtual void registerSound(std::string strPath, std::string strName) = 0;
 
			//Supprime un son spécifié en paramètre du conteneur
			virtual void deleteSound(std::string strName) = 0;
 
			//Lit le son spécifié en paramètre
			virtual void playSound(std::string strName) = 0;
 
			//Stop le son spécifié en paramètre
			virtual void stopSound(std::string strName) = 0;
 
			//Met en pause le son spécifié en paramètre
			virtual void pauseSound(std::string strName) = 0;
 
			//Modifie le volume du son
			virtual void setSoundVolume(uint iVolume) = 0;
 
		protected:
			//Conteneur des sons
			std::map<std::string, T*> m_sound;
			//Itérateur pour le parcours du conteneur
			std::map<std::string, T*>::iterator m_soundIter;
		};
	}
}
 
#endif

Mon compilateur m'indique que l'erreur ce trouve sur la déclaration de l'itérateur du conteneur map.
Help me please!!!

PS : voici un lien vers les erreurs si vous vous sentez le courage de tous lire http://rafb.net/p/bqXMFh99.html

28/10/2007, 00h11
Médinoc

Et si tu rajoutes le mot-clé typename ?
28/10/2007, 00h30
HanLee

D'ailleurs, tu devrais prendre tous tes paramètres de type std::string par référence constante aussi.
28/10/2007, 09h49
trecks

Oui j'ai déja vu les paramètres std::string par références constantes. Mais qu'est ce que cela apporte de plus??

Sinon j'ai rajouté typename devant la déclaration de mes 2 conteneurs map seulement je comprend pas pourquoi je dois faire ça.
28/10/2007, 09h52
Médinoc

Ça supprime des copies inutiles (je ne pense pas que std::string fasse du copy-on-write sur ta plate-forme).
28/10/2007, 10h01
trecks

Dans ce cas si ça permet de supprimer des copies inutiles il faudrait le faire pour tous les paramètres.
En fait la source que je vous est montré fait parti du moteur de jeu 2D que j'essaie de coder, et normalement je dois présenter ce moteur à mon BTS en tant qu'activité objet, le problème c'est que si l'examinateur voit que j'ai passé ces std::string par référence il va me tuer vu que pour lui, quand on passe une variable par référence c'est qu'on a l'intention de la modifier. Voila si vous pouviez m'éclairer...
28/10/2007, 10h04
Médinoc

Si on passe une variable par référence, c'est qu'on a l'intention de la modifier.
Si on passe une variable par référence constante, c'est qu'on n'a pas l'intention de la modifier.

Note: Ne fais ça que pour les objets (gros de préférence) : Passer un int par référence constante ne sert à rien et ralentirait plus qu'autre chose.
28/10/2007, 10h07
koala01

Salut,

Sauf erreur, les classes template n'acceptent pas les méthodes virtuelles...

Si je ne dis pas de bêtises, il faut donc passer par le Curiously RecurringTemplate Pattern pour permettre un fonctionnement "polymoprhique" :P
28/10/2007, 10h26
Laurent Gomila

Citation:

Sauf erreur, les classes template n'acceptent pas les méthodes virtuelles...

Erreur : ce sont les fonctions templates qui ne peuvent pas être virtuelles ;)
28/10/2007, 10h45
trecks

ok ça marche impec merci beaucoup!
28/10/2007, 11h32
koala01

Citation:

Envoyé par Laurent Gomila

Erreur : ce sont les fonctions templates qui ne peuvent pas être virtuelles ;)

:oops: au temps pour moi :oops:

ba en fait ca marche pas
dans mon logger il me dit que je peux pas charger le son

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
#ifndef __ISoundType_H__
#define __ISoundType_H__
 
#include <map>
#include <string>
#include "SLEType.h"
 
namespace SLE
{
	namespace Audio
	{
		//Classe abstraite pour la gestion des sons
		template<typename T>
		class ISoundType
		{
		public:
			ISoundType(){}
			virtual ~ISoundType(){}
 
			//Enregistre un son dans le conteneur
			virtual void registerSound(const std::string &strPath, const std::string &strName) = 0;
 
			//Supprime un son spécifié en paramètre du conteneur
			virtual void deleteSound(const std::string &strName) = 0;
 
			//Lit le son spécifié en paramètre
			virtual void playSound(const std::string &strName) = 0;
 
			//Stop le son spécifié en paramètre
			virtual void stopSound(const std::string &strName) = 0;
 
			//Met en pause le son spécifié en paramètre
			virtual void pauseSound(const std::string &strName) = 0;
 
			//Modifie le volume du son
			virtual void setSoundVolume(uint iVolume) = 0;
 
		protected:
			//Conteneur des sons
			typename std::map<std::string, T*> m_sound;
			//Itérateur pour le parcours du conteneur
			typename std::map<std::string, T*>::iterator m_soundIter;
		};
	}
}
 
#endif

voici le code de la classe abstraite ISoundType

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
#ifndef __CStreamManager_H__
#define __CStreamManager_H__
 
#include <FMOD/fmod.h>
#include "ISingleton.h"
#include "ISoundType.h"
 
namespace SLE
{
	namespace Audio
	{
		class CStreamManager : public ISoundType<FSOUND_STREAM>, public ISingleton<CStreamManager>
		{
			friend class ISingleton<CStreamManager>;
 
		public:
			void registerSound(const std::string &strPath, const std::string &strName);
 
			void deleteSound(const std::string &strName);
 
			void playSound(const std::string &strName);
 
			void stopSound(const std::string &strName);
 
			void pauseSound(const std::string &strName);
 
			void setSoundVolume(uint iVolume);
 
		private:
			CStreamManager();
			virtual ~CStreamManager();
		};
	}
}
 
#endif

ca c'est le code de CStreamManager.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
66
67
68
#include "CStreamManager.h"
#include "CInternalLogger.h"
 
using namespace SLE;
using namespace Audio;
 
CStreamManager::CStreamManager()
{}
 
CStreamManager::~CStreamManager()
{
	m_soundIter = m_sound.begin();
	for(m_soundIter; m_soundIter != m_sound.end(); m_soundIter++)
	{
		//FSOUND_Stream_Close(m_soundIter->second());
		m_sound.erase(m_soundIter);
	}
}
 
void CStreamManager::registerSound(const std::string &strPath, const std::string &strName)
{
	m_sound[strName] = FSOUND_Stream_Open(strPath.c_str(), FSOUND_LOOP_NORMAL, 0, 0);
	if(!m_sound[strName])
		CInternalLogger::getInstance()->logToFile("Impossible de charger en mémoire le son : ");
}
 
void CStreamManager::deleteSound(const std::string &strName)
{
	FSOUND_Stream_Close(m_sound[strName]);
	m_sound.erase(strName);
}
 
void CStreamManager::playSound(const std::string &strName)
{
	//Si la chanson est en pause
	if(FSOUND_GetPaused(1))
	{
		if(!FSOUND_SetPaused(1, 0)) // On enlève la pause
			CInternalLogger::getInstance()->logToFile("Impossible de lire le son : mise en pause");
	}
	//Sinon on la lit
	else
	{
		if(!FSOUND_Stream_Play(FSOUND_FREE, m_sound[strName]))
			CInternalLogger::getInstance()->logToFile("Impossible de lire le son : ");
	}
}
 
void CStreamManager::stopSound(const std::string &strName)
{
	if(!FSOUND_Stream_Stop(m_sound[strName]))
		CInternalLogger::getInstance()->logToFile("Impossible d'arrêter le son : ");
}
 
void CStreamManager::pauseSound(const std::string &strName)
{
	if (!FSOUND_GetPaused(1)) // Si la chanson n'est en pause
	{
		if(!FSOUND_SetPaused(FSOUND_ALL, 1)) // On met en pause
			CInternalLogger::getInstance()->logToFile("Impossible de mettre en pause le son : ");
	}
}
 
void CStreamManager::setSoundVolume(uint iVolume)
{
	if(!FSOUND_SetVolume(FSOUND_ALL, iVolume))
		CInternalLogger::getInstance()->logToFile("Impossible d'ajuster le volume sonore pour les sons de type stream");
}

la le code du cpp

et dans le main

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
#include <iostream>
#include "SLE.h"
 
using namespace SLE;
using namespace Audio;
 
int main(int argc, char **argv)
{
	CSLEngine *_pEngine = CSLEngine::getInstance();
 
	CStreamManager *_pStreamManager = CStreamManager::getInstance();
 
	_pStreamManager->registerSound("Hypnotise.mp3", "Hypnotise");
 
	_pStreamManager->playSound("Hypnotise");
 
	_pEngine->createVideoMode(800, 600, 32, false, "SLEngine v0.1 - Test", 4);
 
	while(_pEngine->isRunning())
	{
		_pEngine->beginScene(true, true, true, 0, 0, 0, 0);
 
		_pEngine->onEvent();
 
		_pEngine->renderScene();
 
		_pEngine->endScene();
	}
 
	_pEngine->killInstance();
 
 
	return EXIT_SUCCESS;
}

et avec tout ca dans mon logger il me dit "impossible de charger le son" : je pense que ca vient du conteneur map de la classe ISoundType, j'ai rajouté typename devant mais je sais pas si la synthaxe est réèlement correcte, en tout cas mon compilateur lance correctement l'appli mais ne charge pas le son!

Il me parait clair que ce test renvoie vrai, donc que la fonction FSOUND_Stream_Open a renvoyé un pointeur nul juste avant.

Code:

if(!m_sound[strName])

Le premier typename pour déclarer ta map est inutile, le second est obligatoire parce que dans ce contexte le compilateur n'arrive pas à savoir si iterator designe un type ou une variable. Regarde bien la FAQ C++ section Templates, c'est expliqué.
Code:

1 2 3 4 5 protected: //Conteneur des sons typename std::map<std::string, T*> m_sound; //Itérateur pour le parcours du conteneur typename std::map<std::string, T*>::iterator m_soundIter;
Par contre d'habitude, j'ai plutôt tendance à faire ça (plus joli et pratique) :
Code:

1 2 3 4 5 6 7 8 public: typedef std::map<std::string, T*> SoundMap; protected: //Conteneur des sons SoundMap m_sound; //Itérateur pour le parcours du conteneur typename SoundMap::iterator m_soundIter;
Je souligne qu'il est assez rare d'avoir un iterateur comme membre de classe. C'est assez dangereux car après certaines opérations sur la map (insertions ou suppressions je ne sais plus trop) il peut devenir invalide et son acces provoque une erreur.

Dernière remarque, une map avec comme clef std::string est très pratique pour l'utilisateur, mais réduit pas mal les perfs car il y a comparaison de chaque (au pire) caractères, mais ce n'est peut-être pas important dans ton cas.

28/10/2007, 16h30
trecks

Merci NiamorH, en effet c'est plus clair et j'ai aussi déplacer l'itérateur pour le mettre dans chaque classe dérivée, par contre mon problème est toujours le même, mon logger m'indique que le son n'a pas été chargé et ne peux pas être lu (dans le main)
28/10/2007, 16h46
Mat007

Salut,

Citation:

Envoyé par trecks

mon logger m'indique que le son n'a pas été chargé et ne peux pas être lu (dans le main)

Ca n'a vraisemblablement aucun rapport avec la std::map, je verrais plus l'appel à FSOUND_Stream_Open qui échoue.

MAT.
31/10/2007, 18h29
trecks

salut, bon en fait j'ai trouvé la solution, vous allez surement bien vous marrez, j'avais juste oublié d'initialiser FMOD, c'est pour ça que mon logger m'indique toujours des erreurs.

Merci à tout le monde pour votre aide.
@+