Discussion :

[trecks]

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

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
#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

[Médinoc]

Et si tu rajoutes le mot-clé typename ?

[HanLee]

D'ailleurs, tu devrais prendre tous tes paramètres de type std::string par référence constante aussi.

[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.

[Médinoc]

Ça supprime des copies inutiles (je ne pense pas que std::string fasse du copy-on-write sur ta plate-forme).

[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...

[trecks]

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

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
#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 :

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
#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 :

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
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 :

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
#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!

[NiamorH]

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

Code :

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

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 :

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

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 :

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

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.

[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)

[Mat007]

Salut,

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.

[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.
@+