Principal › Foros › PC: Scene, Homebrew, OpenSource y Software › Programacion › Programacion C y C++

Anuncios Google

Error al mostrar imagenes mediante función almacenada en clase

Sáb, 2009-06-06 22:46 — burnxez
Old One

Hola, en está ocasión vengo con otro problema relacionado con lo que estoy tratando de construir, después de almacenar todo en clases e iniciar una reescritura de casi el 50 % de mis ficheros (En realidad no es tanto cómo parece, pues no son muy grandes), ahora me encuentro con un código más ordenado y limpio, pero con un grán problema a la hora de "Blitear" mis imagenes. Explico la estructura de mi código:

barra.hpp: Contiene las funciones y variables tanto privadas cómo publicas

barra.cpp: Define el uso de las funciones y variables de la libreria barra.hpp

pelota.hpp: Contiene las funciones y variable tanto privadas cómo publicas.

pelota.cpp: Define el uso de funciones y variables de la libreria pelota.hpp

pong++.cpp: Contiene la función main, así cómo la inicialización de SDL.

Una vez explicada la estructura de mis ficheros, copio/pego la salida del compilador.

pong++.cpp: In function ‘int main(int, char**)’:


pong++.cpp:116: error: no se encontró una función coincidente para la llamada a ‘Barra::mostrar(<unresolved overloaded function type>, <unresolved overloaded function type>, <unresolved overloaded function type>, SDL_Surface*&)’
barra.cpp:31: nota: los candidatos son: void Barra::mostrar(int, int, SDL_Surface*, SDL_Surface*)


pong++.cpp:134: error: no se encontró una función coincidente para la llamada a ‘Barra::mostrar(<unresolved overloaded function type>, <unresolved overloaded function type>, <unresolved overloaded function type>, SDL_Surface*&)’
barra.cpp:31: nota: los candidatos son: void Barra::mostrar(int, int, SDL_Surface*, SDL_Surface*)


pong++.cpp:149: error: no se encontró una función coincidente para la llamada a ‘Pelota::mostrar()’
pelota.cpp:22: nota: los candidatos son: void Pelota::mostrar(int, int, SDL_Surface*, SDL_Surface*)

Después de está salida del compilador, pongo las funciones que marcan error correspondientes a "Barra":

//Fichero barra.hpp
 
#ifndef BARRA_H
#define BARRA_H
 
#include <SDL/SDL.h>
 
class Barra {
	private:
		int x;
		int y;
		SDL_Rect rect;
		SDL_Surface *imagen;
	public:
		int set_img();
		void setimagen (SDL_Surface *setimagen) {imagen = setimagen;} //Cargar imagen
		int sprite(); //Iniciar sprite, x, y, imagen
		void destroy_sprite();
		void mostrar(int x, int y, SDL_Surface *origen, SDL_Surface *destino);
		int mover();
 
		//----------------------------Coordenadas-------------------------------
		int getX() {return x;} //Obtener posicion X
		void setX(int xx) {x = xx;} //Establecer posicion X
		int getY() {return y;} //Obtener posicion Y
		void setY(int yy) {y = yy;}//Establecer posicion Y
		//----------------------------------------------------------------------
		void *getimagen (SDL_Surface *obtenerimagen) {obtenerimagen = imagen;} //Obtener imagen a mostrar en main
};
 
#endif

//Fichero barra.cpp
 
void Barra::mostrar(int x, int y, SDL_Surface *origen, SDL_Surface *destino) {
 
    rect.x = x;
    rect.y = y;
 
    SDL_BlitSurface(origen, NULL, destino, &rect);
}

Fichero pong++.cpp
 
/*Declaración de barrai y barrad*/
Barra barrai, barrad;
 
//Inicialización de SDL
 
//Comienzo de main
 
//Cargar imagen
 
//Inicializar barrai/barrad
 
/*Mostrar barrai/barrad*/
 
if (barrai.mostrar(barrai.getX, barrai.getY, barrai.getimagen, pantalla) == 1) {
		cout << endl << "Error al mostrar la barra 1" << endl;
 
		return 1;
	}
//Obviamente, para la barrad, sólo se cambia la letra correspondiente.
 
//Manejo de eventos
 
//Fin

Ahora las funciones que marcan error correspondientes a "Pelota":

//Dentro de fichero pelota.hpp
 
#ifndef PELOTA_H
#define PELOTA_H
 
#include <SDL/SDL.h>
 
class Pelota {
	private:
		int x;
		int y;
		SDL_Rect rect;
		SDL_Surface *imagen;
	public:
		int set_img();
		int setimagen (SDL_Surface *setimagen) {setimagen = imagen;} //Cargar imagen
		int sprite(); //Inicializar el sprite
		void destroy_sprite();
		void mostrar(int x, int y, SDL_Surface *origen, SDL_Surface *destino);
		int mover();
 
		//----------------------------Coordenadas-------------------------------
		int getX() {return x;} //Obtener posicion X
		void setX(int xx) {x = xx;} //Establecer posicion X
		int getY() {return y;} //Obtener posicion Y
		void setY(int yy) {y = yy;}//Establecer posicion Y
		//----------------------------------------------------------------------
 
		void *getimagen (SDL_Surface *obtenerimagen) {obtenerimagen = imagen;} //Obtener imagen a mostrar en main
};
 
#endif

//Dentro de fichero pelota.cpp
 
void Pelota::mostrar(int x, int y, SDL_Surface *origen, SDL_Surface *destino) {
	rect.x = x;
	rect.y = y;
 
	SDL_BlitSurface(origen,NULL, destino, &rect);
}

//Dentro de fichero pong++.cpp
 
/*Declaración de pelota*/
Pelota pelota;
 
//Inicialización de SDL
 
//Comienzo de main
 
//Cargar imagen
 
//Inicializar pelota
 
/*Mostrar pelota*/
 
if (pelota.mostrar() == -1) {
		cout << endl << "Error al mostrar la pelota " << endl;
	}
 
//Manejo de eventos
 
//Fin

No entiendo por que me marca error en la función "mostrar" si es la que siempre he usado desde que comenzé a programar, sólo que ahora la he "adaptado" para que esté dentro de una clase y no revuelta con las otras funciones en un único fichero.

Saludos

‹ Movimiento de imagen raro SDL & C++ Definir una clase y/o funcion y usarla en una libreria C++ ›

Anuncios Google

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Dom, 2009-06-07 03:18 — pspgorrister
Coder
Imagen de pspgorrister

Bueno, podría analizar más

Bueno, podría analizar más el código, el error está en al declaración del método mostrar, pero realmente todo se resume a que estás usando las cosas mal:

Si te fijas ese código no tiene sentido, creas una método mostrar, al que le pasas como parámetro sus coordenadas, y la imagen, no hace falta pasarsela como parámetro, barrai es un objeto, YA TIENE esos datos, puedes acceder a ellos desde cualquier método del la clase. Es que esa es la ventaja de la POO, que encapsulas los datos en la clase Risa. Lo que estás haciendo son simple funciones.

if (barrai.mostrar(barrai.getX, barrai.getY, barrai.getimagen, pantalla) == 1) {
		cout << endl << "Error al mostrar la barra 1" << endl;
 
		return 1;
	}

Ese código si usas un objeto no puede ser así (bueno, como poder puede, pero no tiene sentido hacerlo):

//Esto es algún lugar donde defines la barra...
barrai.setX(13);
barrai.setY(100);
barrai.setImage(.....);
 
//...
//Aqui hay más codigo .....
//....
 
//El correcto uso de la función mostrar, no necesita los parámetros, bueno la pantalla quizás. (1)
if (barrai.mostrar(pantalla) == 1) {
		cout << endl << "Error al mostrar la barra 1" << endl;
 
		return 1;
	}

(1)He puesto esta reseña, lo que no quiero es ser pesao, pero puedes hacer un planteamiento diferente:

Crear una clase Pantalla, que llevería la pantalla principal, resolución, profundidad de color, los métodos blit, etc. Sería la abstraccion de las funciones SDL que manejan la pantalla.

Y en vez de hacer que la barra se pinte a traves de una variable pantalla, hacer que el objeto pantalla pinte un objeto barra. Esto es más POO y a la hora de programa te simplifica el código. Un cutrejemplo

CPantalla pantalla; //Este objeto manejará la pantalla principal
 
//El objeto pantalla se encarga de hacer el SDL_SetVideoMode, los valores alto, ancho, etc hay
//que guardarlos en variables privadas en las clases porque luego seguramente se volverán a usar
 
if (pantalla.setVideoMode(alto, ancho, bbp) == -1) {
    cerr << "No se ha podido inicializar el modo gráfico" << endl;
    exit ERROR;
}
 
//Es más sencillo mostrar las barras así, una vez definidas las clases.
pantalla.mostrar(barrai);
pantalla.mostrar(barrad);

 

Te voy a poner un código de una abstracción de SDL que hice hace un tiempo, fue un proyecto inacabado (quise hacer un juego para PSP, pero me faltó tiempo Llora), y no compilará porque hace referencias a clases que no están todavía, de todas formas, espero que te sea (a ti o a quien lo lea) de alguna utilidad, aunqué no pueda compilarse.

csdl.h

******************************************************************************
Class: CSDL
Author: GorristeR 2008. Under GPL3 License
Version: N/A
Description:
Abstracción del sistema SDL.
******************************************************************************/
#ifndef CSDL_H
#define CSDL_H
 
#include <SDL/SDL.h>
 
#include "csprite.h"
#include "csurface.h"
#include "cevent.h"
#include "ckey.h"
 
class CSDL
{
    public:
        CSDL();
        int Init(const Uint32& flags);
        SDL_Surface* SetVideoMode(const int h, const int w, const int b, const Uint32& flags);
        SDL_Surface* SetPSPVideoMode();
        SDL_Surface* GetVideoSurface() { return m_Screen; }
        int Clear(const Uint8 r, const Uint8 g, const Uint8 b);
        int GetW() { return m_Screen->w; }
        int GetH() { return m_Screen->h; }
 
        void CenterX(CSurface* surface);
        void CenterY(CSurface* surface);
        void CenterXY(CSurface* surface);
 
        void CenterX(CSprite* sprite);
        void CenterY(CSprite* sprite);
        void CenterXY(CSprite* sprite);
 
        int GetTicks() { m_InitTicks = SDL_GetTicks(); return m_InitTicks; }
        //Espera m milisegundos desde GetTicks();
        void Wait(const int& m);
 
        int PollEvent() { return m_Event.PollEvent(); }
        int EventType() { return m_Event.Type(); }
 
        Uint8* GetKeyState() { return m_Key.GetKeyState(); }
        bool KeyPressed(int k) { return m_Key.KeyPressed(k); }
 
        int Flip() { return SDL_Flip(m_Screen); }
        int Blit(CSprite* sprite); //const?
        int Blit(CSurface* surface); //const?
        virtual ~CSDL();
    protected:
    private:
        //Flags usados en SDL_InitVideo
        Uint32 m_InitFlags;
        //Flags usados en SDL_VideoMode
        Uint32 m_VideoFlags;
        SDL_Surface* m_Screen;
        CEvent m_Event;
        CKey m_Key;
        //Usada para pausar el juego X frames
        int m_InitTicks;
};
 
#endif // CSDL_H

 

csdl.cpp

#include "csdl.h"
#include <iostream>
 
int CSDL::Init(const Uint32& flags)
{
    int result;
    m_InitFlags = flags;
    result = SDL_Init(m_InitFlags);
    atexit(SDL_Quit);
    return result;
}
 
SDL_Surface* CSDL::SetVideoMode(const int h, const int w, const int b, const Uint32 flags)
{
    m_Screen = SDL_SetVideoMode(h, w, b, flags);
    m_VideoFlags = flags;
    return m_Screen;
}
 
SDL_Surface* CSDL::SetPSPVideoMode()
{
    return SetVideoMode(480, 272, 24, SDL_HWSURFACE|SDL_DOUBLEBUF);
}
 
void CSDL::CenterX(CSurface* surface)
{
    surface->SetX((GetW() - surface->GetW()) /2);
}
 
void CSDL::CenterY(CSurface* surface)
{
    surface->SetY((GetH() - surface->GetH()) /2);
}
 
void CSDL::CenterXY(CSurface* surface)
{
    CenterX(surface);
    CenterY(surface);
}
 
void CSDL::CenterX(CSprite* sprite)
{
        sprite->SetX((GetW() - sprite->GetW()) / 2);
}
 
void CSDL::CenterY(CSprite* sprite)
{
        sprite->SetY((GetH() - sprite->GetH()) / 2);
}
 
void CSDL::CenterXY(CSprite* sprite)
{
        CenterX(sprite);
        CenterY(sprite);
}
 
void CSDL::Wait(const int& m)
{
    int lastTicks;
    do {
        lastTicks = SDL_GetTicks();
    } while (lastTicks - m_InitTicks < m);
}
 
int CSDL::Clear(const Uint8 r, const Uint8 g, const Uint8 b)
{
    return SDL_FillRect(m_Screen, NULL, SDL_MapRGB(m_Screen->format, r, g, b));
}
 
int CSDL::Blit(CSurface* surface)
{
    return SDL_BlitSurface(surface->GetSurface(), NULL, m_Screen, surface->GetRect());
}
 
int CSDL::Blit(CSprite* sprite)
{
    return SDL_BlitSurface(sprite->GetSurface(), sprite->GetFrameRect(), m_Screen, sprite->GetRect());
}

 

main.cpp

#include <iostream>
#include <SDL/SDL.h>
#include <SDL_image.h>
 
#include "csdl.h"
 
using namespace std;
//TODO crear CSDLScreen
 
int main ( int argc, char** argv )
{
    CSDL sdl;
 
    //Inicializa el sistema de vídeo SDL
    if (sdl.Init(SDL_INIT_VIDEO) < 0) {
        cerr << "Error al iniciar SDL: " << SDL_GetError() << endl;
        return 1;
    }
 
    //Inicializa el modo de video y características varias.
    if (!sdl.SetVideoMode(480, 272, 16, SDL_HWSURFACE|SDL_DOUBLEBUF)) {
        cerr << "Error al iniciar modo 480x272: " << SDL_GetError() << endl;
        return 1;
    }
 
//Más codigo..........................

 

 

LuaDiE: Crea en Lua sin teclear código. Compatible HM7, HMv2, LuaPlayer, LuaDEV y PGE.

Mar, 2009-06-09 00:25 — burnxez
Old One
Imagen de burnxez

Gracias

Bueno, primero que nada agradecerte tanto por la respuesta, cómo por compartir tu código.

Bueno, ahora los problemas, si cambio lo que has dicho, aún me sigue dando problemas, he tratado de cambiar diversos parametros, tanto de la función, cómo de la llamada a la función pero no funca.

Ahora, estoy tratando de hacer lo que me has dicho, "en vez de hacer que la barra se pinte a traves de una variable pantalla, hacer que el objeto pantalla pinte un objeto barra" Supongo que será lo mejor, sólo unas preguntas, en este caso, las funciones para cargar imagen, mostrar, etc... no serán necesarias ¿Cierto? pues todo lo haré desde el objeto Pantalla, lo único que necesitaré será la función mover del objeto tanto barra como pelota ¿Voy bien?

Bueno, por ahora eso es todo en lo que tengo duda.

Saludos.

Edito: Pues por ahora, haré que la barra se pinte a si misma, pues necesito más experiencia con el manejo de SDL ya que hay cosas que aún no entiendo.

PD: Ya funciona mi función de mostrar :D. Gracias GorristeR

Dom, 2009-06-07 00:05 — Guillermo_Cornielle
Old One
Imagen de Guillermo_Cornielle

Un consejo

Mirate el source de Guns amors para PC de pipagerardo, o sino los sorces de los tutos, ahi esta algo parecido a lo que quieres hacer, saludos.

Manual del Perfecto Votante Para un voto libre y justo!.

TheGCProjects

Dom, 2009-06-07 01:53 — burnxez
Old One
Imagen de burnxez

Es diferente

Ahí están usando una clase para todo tipo de sprites, lo que yo estoy haciendo es una libreria y una clase por "sprite" ya he visto las fuentes, pero estás hacen referencia a otras funciones y estas a otras, así que para poder aplicar lo que viene ahí tendría que rehacer el código, pero combinando todo en lugar de dejar una librería por cosa.

He visto otros sources, de un sólo archivo, y a ellos les compila bien cómo yo lo hacia antes, con funciones sin meterme a clases, pero, la diferencia es que ellos si usan clases, si yo uso clases + funciones fuera de la clase, me genera errores catastroficos, de acuerdo a lo que me comentó GorristeR en el otro hilo, decidi usar clases y dentro de las clases definir las funciones sin recurrir a funciones externas declaradas fuera de la clase que harán lios durante la compilación.

Lo que no entiendo para nada es ese error de compilación, imagino que el error está en la sintaxis de alguna función, pero simplemente no puedo ver de cual se trata.

Saludos

PD: ZGC para el próximo año :D esperemos que se pueda....

El día de mañana Xtreem Rulez!!

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.