3. Fehler über nichtdeklarierten Bezeichner, obwohl ordnungsgemäß deklariert

Fehler über nichtdeklarierten Bezeichner, obwohl ordnungsgemäß deklariert

  • R

    Hallo,

    ich bekomme einen Fehler über einen nichtdeklarierten Bezeichner, obwohl ich ihn ordnungsgemäß deklariert habe.
    Der Fehler weist auch auf die Getter-Methode hin, obwohl ich die Variable schonmal im Konstruktor auf 0 setze.
    Hier mal der Code:

    sprite.h

    #ifndef _SPRITE_
#define _SPRITE_

#include <d3d9.h>
#include <d3dx9.h>
#include <vector>

#include "ResourceManager.h"
#include "global.h"

using namespace std;

// Definition der Bewegungsrichtungen
enum DIRECTION { LEFT, RIGHT, UP, DOWN };

// Definition der Spriteklasse
class CSprite
{
    public:
       CSprite();
       virtual ~CSprite();

       // Erzeugung des Sprites
       void Create(LPDIRECT3DDEVICE9 lpDevice,CResourceManager* ResManager ,int AnimationSpeed);

       // Textur hinzufügen
        void AddTexture(LPDIRECT3DTEXTURE9 lpTexture);

       // Sprite zeichnen
       void Draw(void);

       // absolute Position festlegen
       void SetPosition(float x,float y);

       // absolute Rotation festlegen
       void SetRotation(float rotation);

       // absolute Skalierung festlegen
       void SetScale(float scale);

       // Schrittweite festlegen
       void SetStep(float StepX,float StepY);

       // relative Bewegung um StepX,StepY Pixel
       void Move(DIRECTION dir);

       // relative Skalierung 
       void Scale(float dScale);

       // relative Rotation
       void Rotate(float dRotation);

       // Sprite an den Bildschirmbegrenzungen abprallen lassen
       void Bounce(void);

	   // testen ob die nächste Animation angezeigt werden soll
        void Animate(void);

	   // die Position des Sprites zurückgeben
        D3DXVECTOR2 GetPosition(void);

		// Höhe und Breite des Sprites zurückgeben
        int GetHeight(void);
        int GetWidth(void);

		//Typus setzen
		void SetType(int type);
		int GetType(void);

     protected:

       // Zeiger auf das Direct3D Device
       LPDIRECT3DDEVICE9 m_lpDevice;

       // Zeiger auf das ID3DXSprite-Objekt
       LPD3DXSPRITE m_lpSprite;

	   // Zeiger auf den ResourceManager speichern
       CResourceManager* m_ResManager;

       // aktuelle Position
       D3DXVECTOR2 m_vPosition;

       // Skalierung
       D3DXVECTOR2 m_vScale;

       // Rotationsmittelpunkt
       D3DXVECTOR2 m_vRotationCenter;

       // aktuelle Rotation
       float m_Rotation;

       // Schrittweite
       float m_StepX;
       float m_StepY;

	   //Typus
	   int m_Art;

       // Breite und Höhe
       int   m_Width;
       int   m_Height;

        // Geschwindigkeit für die Animation
        float m_AnimationSpeed;

       // diese Variable wird erhöhrt, bis m_AnimationSpeed
       // erreicht wurde und wird dann wieder auf 0 gesetzt
       // und die nächste Grafik wird angezeigt
       int m_AnimationDelay;

       // momentante Grafik (Textur) in der Animation
       float m_CurrentImage;

       // vector zur Speicherung der Texturen für die Animationen
       vector<LPDIRECT3DTEXTURE9> m_AnimationVec;
};
#endif

    Sprite.cpp - Code gekürzt

    #include "Sprite.h"

// Konstruktor - Initialisierungen
CSprite::CSprite(void)
{
    m_Rotation = 0;

    m_StepX    = 0;
    m_StepY    = 0;

    m_Width    = 0;
    m_Height   = 0;

    m_AnimationSpeed = 0;
    m_AnimationDelay = 0;
    m_CurrentImage   = 0;

    m_lpDevice = NULL;                  
    m_lpSprite = NULL;

	m_Art = 0;
}

// Destructor - freigeben der Objekte
CSprite::~CSprite(void)
{
    if(NULL != m_lpSprite)
    {
        m_lpSprite->Release();
        m_lpSprite = NULL;
    }

    // die Texturen dürfen hier nicht mehr frei gegeben
    // werden, da dies im ResourcenManager erfolgt
}

//Typus abfragen
int GetType(void)
{
	return m_Art;
}

//Typus setzen
void SetType(int type)
{
	m_Art = type;
}

    Fehlermeldung:

    1>------ Erstellen gestartet: Projekt: SpriteBounce, Konfiguration: Debug Win32 ------
1>Kompilieren...
1>sprite.cpp
1>e:\spiel\spritebounce\sprite.cpp(57) : error C2065: 'm_Art': nichtdeklarierter Bezeichner

...

    Vielleicht ist es auch nur ein ganz banaler Fehler und ich übersehe ihn nur. Ich habe das Projekt auch schonmal bereinigt und neu erstellt - hilft nix. Ich verwende VS 2005 Professional Edition.

    Danke schonmal für eure Hilfe.
    MfG Bastie

    0
  • C
    Mod

    Klassenname bei der Definition der Memberfunktionen vergessen?

    0
  • A

    camper schrieb:

    Klassenname bei der Definition der Memberfunktionen vergessen?

    sieht ganz so aus.
    OP: du kannst den code für die methoden direkt in die 'class' mit hineinschreiben. dann passiert sowas nicht. beispiel:

    class CSprite
{
    public:
    ...
      int GetType(void)
      {
         return m_Art;
      }
    ...
};

    🙂

    0
  • *

    Ehm naja dein Code ist optimierungsbedürftig ^^ Also

    #if !defined(SPRITE_H__INCLUDED)
#define SPRITE_H__INCLUDED

#if (_MSC_VER >= 1300)
#pragma once
#endif // (_MSC_VER >= 1300)

#include <d3d9.h>
#include <d3dx9.h>
#include <vector>

#include "ResourceManager.h"
#include "global.h"

// Definition der Bewegungsrichtungen
enum DIRECTION { LEFT, RIGHT, UP, DOWN };

// Definition der Spriteklasse
class Sprite
{
public:
	Sprite();
	virtual ~Sprite();

public:
	// Erzeugung des Sprites
	void create(LPDIRECT3DDEVICE9, CResourceManager*, int);
	// Textur hinzufügen
	void add_texture(LPDIRECT3DTEXTURE9 lpTexture);
	// Sprite zeichnen
	void draw();
	// absolute Position festlegen
	void set_position(float x, float y) { m_vPosition.x = x; m_vPosition.y = y; }
	// absolute Rotation festlegen
	void set_rotation(float rot) { m_Rotation = rot; }
	// absolute Skalierung festlegen
	void set_scale(float);
	// Schrittweite festlegen
	void set_step(float x, float y) { m_vStep.x = x; m_vStep.y = y; }
	// relative Bewegung um StepX,StepY Pixel
	void move(const DIRECTION&);
	// relative Skalierung
	void scale(float);
	// relative Rotation
	void rotate(float);
	// Sprite an den Bildschirmbegrenzungen abprallen lassen
	void bounce();
	// testen ob die nächste Animation angezeigt werden soll
	void animate();
	// die Position des Sprites zurückgeben
	D3DXVECTOR2 get_position() const { return m_vPosition; };
	// Höhe und Breite des Sprites zurückgeben
	std::size_t get_height() const { return m_Height; }
	std::size_t get_width() const { return m_Width; }
	//Typus setzen
	void set_type(int type) { m_Art = type; }
	int get_type() const { return m_Art; }

protected:
	// Zeiger auf das Direct3D Device
	LPDIRECT3DDEVICE9	m_lpDevice;
	// Zeiger auf das ID3DXSprite-Objekt
	LPD3DXSPRITE		m_lpSprite;
	// Zeiger auf den ResourceManager speichern
	CResourceManager*	m_ResManager;
	// aktuelle Position
	D3DXVECTOR2			m_vPosition;
	// Skalierung
	D3DXVECTOR2			m_vScale;
	// Rotationsmittelpunkt
	D3DXVECTOR2			m_vRotationCenter;
	// aktuelle Rotation
	float				m_Rotation;
	// Schrittweite
	D3DXVECTOR2			m_vStep;
	//Typus
	int					m_Art;
	// Breite und Höhe
	std::size_t			m_Width;
	std::size_t			m_Height;
	// Geschwindigkeit für die Animation
	float				m_AnimationSpeed;
	// diese Variable wird erhöhrt, bis m_AnimationSpeed
	// erreicht wurde und wird dann wieder auf 0 gesetzt
	// und die nächste Grafik wird angezeigt
	int					m_AnimationDelay;
	// momentante Grafik (Textur) in der Animation
	float				m_CurrentImage;
	// vector zur Speicherung der Texturen für die Animationen
	std::vector<LPDIRECT3DTEXTURE9>		m_AnimationVec;
};

#endif // SPRITE_H__INCLUDED

    ... ist noch nicht alles drin ... Initialisierungsliste usw. gehört auch noch darein ...

    CSprite::~CSprite(void)
{
    if(NULL != m_lpSprite)
    {
        m_lpSprite->Release();
        m_lpSprite = NULL;
    }

    // die Texturen dürfen hier nicht mehr frei gegeben
    // werden, da dies im ResourcenManager erfolgt
}

    kann man auch so machen:

    template <typename T>
vois safe_release(T* type) { if (type != NULL) { type->Release(); type = NULL; } }

Sprite::~Sprite()
{
    safe_release(m_lpSprite);
}

    ...

    0

  • (D)Evil schrieb:

    kann man auch so machen:

    template <typename T>
vois safe_release(T* type) { if (type != NULL) { type->Release(); type = NULL; } }

Sprite::~Sprite()
{
    safe_release(m_lpSprite);
}

    ...

    Oder gleich boost::intrusive_ptr verwenden.

    0
  • R

    Vielen Dank für die schnellen Antworten.

    Fehler habe ichs chon ausgebessert und die Methoden-Deklaration werd ich wohl weiterhin erstmal in der .cpp machen.

    MfG

    0
Anmelden zum Antworten