absturz....

[ücü]

Kann hat jemand eine Idee, warum es zu einem Absturz beim Beenden des Programms kommt??? desweiteren wird auch kein Sound ausgegeben.

/*************************************************************************//
//
// Datei:		sound.h	
// Autor:		ücü
// Erstellt:	20.02.2006
// Geändert:	20.02.2006
//
//*************************************************************************//

//*************************************************************************//
// INCLUDE GUARD
//*************************************************************************//
#if !defined(__sound_h__)
#define __sound_h__
//*************************************************************************//

//*************************************************************************//
// HEADERS
//*************************************************************************//
#include <al/alut.h>
#include <iostream>

//*************************************************************************//
// LIBRARYS
//*************************************************************************//
#pragma comment(lib, "alut.lib")

//*************************************************************************//
// NAMESPACE
//*************************************************************************//
namespace audio
{

struct sndAttrb
{

};

class sound
{
private:
	unsigned int *buffer_;
	unsigned int *source_;

public:
	sound(void);
	~sound(void);

	void setBuffer(unsigned int& buffer);
	void setSource(unsigned int& source);

	bool load(const std::basic_string<char>& filename);
	void setRepeat(bool repeat);

	void play	(void);
	void rewind	(void);
	void stop	(void);
	void pause	(void);
};

}

//*************************************************************************//
// INCLUDE GUARD
//*************************************************************************//
#endif

//*************************************************************************//

//*************************************************************************//
//
// Datei:		sound.cpp	
// Autor:		ücü
// Erstellt:	20.02.2006
// Geändert:	20.02.2006
//
//*************************************************************************//

//*************************************************************************//
// HEADERS
//*************************************************************************//
#include "sound.h"

//*************************************************************************//
// NAMESPACE
//*************************************************************************//

namespace audio
{

//*************************************************************************//
// PUBLIC Konstruktor
//*************************************************************************//
sound::sound(void)// : buffer_(NULL), source_(NULL)
{

}

//*************************************************************************//
// PUBLIC Destruktor
//*************************************************************************//
sound::~sound(void)
{
	if(buffer_)
		delete(buffer_);
	if(source_)
		delete(source_);
}

//*************************************************************************//
// PUBLIC setBuffer
//*************************************************************************//
void sound::setBuffer(unsigned int& buffer)
{
	buffer_ = &buffer;
}

//*************************************************************************//
// PUBLIC setSource
//*************************************************************************//
void sound::setSource(unsigned int& source)
{
	source_ = &source;
}

//*************************************************************************//
// PUBLIC load
//*************************************************************************//
bool sound::load(const std::basic_string<char>& filename)
{
	alGetError();

	ALenum		format;
	ALvoid*		data;
	ALsizei		size;
	ALsizei		freq;
	ALboolean	loop;

	alutLoadWAVFile(filename.c_str(), &format, &data, &size, &freq, &loop);
	alBufferData(*buffer_, format, data, size, freq);
	alutUnloadWAV(format, data, size, freq);

	alSourcei(*source_, AL_BUFFER, *buffer_);

	if(alGetError() != AL_NO_ERROR)
		return false;
	return true;
}
//*************************************************************************//
// PUBLIC setRepeat
//*************************************************************************//
void sound::setRepeat(bool repeat)
{

}

//*************************************************************************//
// PUBLIC play
//*************************************************************************//
void sound::play(void)
{
	alSourcePlay(*source_);
}

//*************************************************************************//
// PUBLIC rewind
//*************************************************************************//
void sound::rewind(void)
{
	alSourceRewind(*source_);
}

//*************************************************************************//
// PUBLIC stop
//*************************************************************************//
void sound::stop(void)
{
	alSourceStop(*source_);
}

//*************************************************************************//
// PUBLIC pause
//*************************************************************************//
void sound::pause(void)
{
	alSourcePause(*source_);
}

}

//*************************************************************************//

//*************************************************************************//
//
// Datei:		manager.h	
// Autor:		ücü
// Erstellt:	20.02.2006
// Geändert:	20.02.2006
//
//*************************************************************************//

//*************************************************************************//
// INCLUDE GUARD
//*************************************************************************//
#if !defined(__manager_h__)
#define __manager_h__
//*************************************************************************//

//*************************************************************************//
// HEADERS
//*************************************************************************//
#include <al/al.h>
#include <al/alc.h>
#include "sound.h"

//*************************************************************************//
// LIBRARYS
//*************************************************************************//
#pragma comment(lib, "OpenAL32.lib")

//*************************************************************************//
// NAMESPACE
//*************************************************************************//
namespace audio
{

	const unsigned int maxBuffers	= 100;
	const unsigned int maxSources	= 100;

}

namespace audio
{

class manager
{
private:
	ALCdevice*		device_;
	ALCcontext*		context_;

	unsigned int	buffers_[maxBuffers];
	unsigned int	sources_[maxSources];
	sound			sounds_ [maxSources];

private:
	manager(void);
	manager(const manager& other);
	~manager(void);

	manager& operator =(const manager& other);

public:
	inline static manager& getInst(void)
	{
		static manager instance;

		return(instance);
	}

	void initialize		(void);
	void restore		(void);
	void shutdown		(void);

	bool loadSound(unsigned int snd,
				   const std::basic_string<char>& filename);

	void remove		(unsigned int snd);
	void removeAll	(void);

	void play		(unsigned int snd);
	void playAll	(void);

	void rewind		(unsigned int snd);
	void rewindAll	(void);

	void pause		(unsigned int snd);
	void pauseAll	(void);

	void stop		(unsigned int snd);
	void stopAll	(void);

	void setRepeat	(unsigned int snd, bool repeat);
};

}

//*************************************************************************//
// INCLUDE GUARD
//*************************************************************************//
#endif

//*************************************************************************//

//*************************************************************************//
//
// Datei:		manager.cpp	
// Autor:		ücü
// Erstellt:	20.02.2006
// Geändert:	20.02.2006
//
//*************************************************************************//

//*************************************************************************//
// HEADERS
//*************************************************************************//
#include "manager.h"

//*************************************************************************//
// NAMESPACE
//*************************************************************************//
namespace audio
{

//*************************************************************************//
// PRIAVTE Konstruktor
//*************************************************************************//
manager::manager(void)
{
	device_		= NULL;
	context_	= NULL;

	for(unsigned int i = 0; i < maxBuffers; i ++)
		sounds_[i].setBuffer(buffers_[i]);

	for(unsigned int i = 0; i < maxSources; i ++)
		sounds_[i].setSource(sources_[i]);
}

//*************************************************************************//
// PRIAVTE Copy-Konstruktor
//*************************************************************************//
manager::manager(const manager& other)
{

}

//*************************************************************************//
// PRIAVTE Destruktor
//*************************************************************************//
manager::~manager(void)
{
	shutdown();
}

//*************************************************************************//
// PUBLIC initialize
//*************************************************************************//
void manager::initialize(void)
{
	device_ = alcOpenDevice(NULL);
	if(device_)
	{
		context_ = alcCreateContext(device_, NULL);
		alcMakeContextCurrent(context_);
	}

	alGenBuffers(maxBuffers, buffers_);
	alGenSources(maxSources, sources_);
}

//*************************************************************************//
// PUBLIC restore
//*************************************************************************//
void manager::restore(void)
{
	shutdown();

	device_ = alcOpenDevice(NULL);
	if(device_)
	{
		context_ = alcCreateContext(device_, NULL);
		alcMakeContextCurrent(context_);
	}

	alGenBuffers(maxBuffers, buffers_);
	alGenSources(maxSources, sources_);
}

//*************************************************************************//
// PUBLIC shutdown
//*************************************************************************//
void manager::shutdown(void)
{	
	alDeleteSources(maxSources, sources_);
	alDeleteBuffers(maxBuffers, buffers_);

	context_	= alcGetCurrentContext();
	device_		= alcGetContextsDevice(context_);

	alcMakeContextCurrent(NULL);
	alcDestroyContext(context_);
	alcCloseDevice(device_);
}

//*************************************************************************//
// PUBLIC create
//*************************************************************************//
bool manager::loadSound(unsigned int snd,
						const std::basic_string<char>& filename)
{
	if(snd < maxSources)
		if(sounds_[snd].load(filename))
			return(true);
	return(false);
}

//*************************************************************************//
// PUBLIC remove
//*************************************************************************//
void manager::remove(unsigned int snd)
{

}

//*************************************************************************//
// PUBLIC removeAll
//*************************************************************************//
void manager::removeAll(void)
{

}

//*************************************************************************//
// PUBLIC play
//*************************************************************************//
void manager::play(unsigned int snd)
{
	if(snd < maxSources)
	sounds_[snd].play();
}

//*************************************************************************//
// PUBLIC playAll
//*************************************************************************//
void manager::playAll(void)
{
}

//*************************************************************************//
// PUBLIC play
//*************************************************************************//
void manager::pause(unsigned int snd)
{
	if(snd < maxSources)
		sounds_[snd].pause();
}

//*************************************************************************//
// PUBLIC pauseAll
//*************************************************************************//
void manager::pauseAll(void)
{
}

//*************************************************************************//
// PUBLIC stop
//*************************************************************************//
void manager::stop(unsigned int snd)
{
	if(snd < maxSources)
		sounds_[snd].stop();
}

//*************************************************************************//
// PUBLIC stopAll
//*************************************************************************//
void manager::stopAll(void)
{
}

//*************************************************************************//
// PUBLIC setRepeat
//*************************************************************************//
void manager::setRepeat(unsigned int snd, bool repeat)
{
	if(snd < maxSources)
		sounds_[snd].setRepeat(repeat);
}

}

//*************************************************************************

und in der main:

int main(int argc, wchar_t* argv[])
{

	audio::manager::getInst().initialize();
	if(!audio::manager::getInst().loadSound(1, "ump45.wav"))
	std::cout << "Cant load Sound";	
	audio::manager::getInst().play(1);
	audio::manager::getInst().shutdown();	

	char a;
	std::cin >> a;

	return 0;
}

[ücü]

Beim absturz soll die manager::shutdown dran schuld sein. wenn ich die aber raus nehme, kommt es auch zu einem absturz.

Hier die Absturzmeldung:
http://img442.imageshack.us/img442/8945/clipboard5qe.jpg

[golden_jubilee]

beschreib deinen fehler mal bitte genau und benutze erstmal den debugger
das ist ein bisschen viel code ....

EDIT: ich glaube kaum das jemand aus den adressen den fehler lesen kann

[ücü]

Sry, ich habe auch keine Ahnung vom Debuggen, bis jetzt gings auch immer ohne.

[golden_jubilee]

ücü schrieb:

Sry, ich habe auch keine Ahnung vom Debuggen, bis jetzt gings auch immer ohne.

dazu sag ich jetzt nichts, außer vlt. das es hier glaub einen artikel zu dem thema gibt

[ücü]

Der Debuger zeigt beim herunterfahren des Programms folgenden Fehler an: { CXX0036: Fehler: Fehlerhafte Kontextangabe {...}

[ücü]

Gut, hat sich geklärt. Es ist ein fataler Konzeptfehler im Projekt