Mensajes

En el tema del lenguaje creo que te han orientado lo suficiente. En cuanto a librería gráfica tiraría a OpenGL + SDL en lugar de únicamente SDL.

En el tratamiento de error al abrir el fichero, muestras "Fallo", sin embargo sigues leyendo, pon un return al menos.

Linea:
for(int i=0;i<=filas;i++)

Esta linea cambiala hasta '< filas', porque si le pones '<= filas', le estás obligando que se meta en una posición de memoria del array no asignada, la última posición de un array es 'tamaño - 1'.

Al final, dentro de la función main(), lees el fichero y a pesar de no saber si se ha leido bien, porque das por hecho que se lee bien, destruyes la clase. y esto provoca un fallo de segmentación porque la matriz no se ha creado.

Es lo que puedo decirte de vista rápida. Pureba a solucionar eso...

El paso a int hay una función que te lo hace todo muy bonito, atoi()

Si en una función vas a pasarle una cadena constante, pon el argumento como constante también 'const char*'...

void leer(const char* s)

No existen los vectores.

En primer lugar, ¿Qué es un número ondulado?

Un entero positivo es ondulado si sus dígitos se van repitiendo en la forma ababab.... Sólo hay dos dígitos (a y b) que se repiten.
Casos especiales:
- Todos los enteros menores estrictos que 100 son ondulados.
- Los enteros de la forma ababa son ondulados. Es decir, lo importante es que se vayan alternando los dos dígitos.

Ejemplos de números ondulados: 2, 82, 737, 1010, 10101, 222, 5555
Ejemplos de números NO ondulados: 1987, 827, 827827, 1001, 955

Pues resulta que no me aclaro a como hacerlo.

Resulta que acabo de entrar en la universidad en el grado de informática y hemos dado los temas 1 y 2, los cuales no enseñan ni vectores, ni ninguna herramienta más allá de las simples operaciones, condiciones y bucles.

Entonces, ¿Cómo podría decir si un número es ondulado?. Hasta aquí lo que he podido hacer.

Código (cpp) [Seleccionar] Expandir


#include <iostream>

using namespace std;

int main()
{
int numero;
int copiaNumero;
int cifra, cifraAux;
cin >> numero;

if ( numero < 100 )
{
cout << "RESULTADO = SI" << endl;
}
else
{
copiaNumero = numero;

while ( (copiaNumero / 10) != 0 )
{
// Guarda la cifra leida
cifra = copiaNumero % 10;
copiaNumero = copiaNumero / 10;


//cifra = cifra * 10 + cifra;

/* HASTA AQUI */

}
}

system( "pause" );
return 0;
}


¿Alguien puede ayudarme? No pido que escribais el código, sólo pido una idea, un empujon para aclararme como podría hacerlo.

Gracias!

Código (cpp) [Seleccionar] Expandir


#include <iostream>

using namespace std;

int main()
{
int numero;
int copiaNumero;
int cifra1, cifra2;
int numeroCifras;
bool esOndulado = false;
bool penultimaCifra = false, salida = false;

cin >> numero;

if ( numero < 100 )
{
cout << "RESULTADO = SI" << endl;
return 0;
}
else
{
numeroCifras = 1;
copiaNumero = numero;

while ( !salida )
{
if ( numeroCifras == 1 )
{
cifra1 = copiaNumero % 10;
}
else if ( numeroCifras == 2 )
{
cifra2 = copiaNumero % 10;
}
else
{
if ( numeroCifras % 2 == 0 )
{
if ( cifra2 == (copiaNumero%10) )
esOndulado = true;
else
esOndulado = false;
}
else
{
if ( cifra1 == (copiaNumero%10) )
esOndulado = true;
else
esOndulado = false;
}
}

copiaNumero = copiaNumero / 10;
numeroCifras++;

if ( penultimaCifra )
salida = true;

if ( copiaNumero / 10 == 0 )
penultimaCifra = true;

}
}

if ( esOndulado )
cout << "Es ondulado" << endl;
else
cout << "No es ondulado" << endl;

system( "pause" );
return 0;
}



Ese es el código que final que he conseguido, funciona, aunque posiblemente se pueda hacer mas reducido.

Gracias!

Los tengo normalmente a 30 milisegundos. Esa pausa es minúscula, pero como he dicho antes, carga mucho la CPU. Si lo pongo a 100 milisegundos la pausa en mi opinión es demasiado grande. Con 100 milisegundos de pausa en cada loop la aplicación se ve muy fea...

[SVideo.h]

Bueno, aquí dejo una parte de una librería sobre SDL para acelerar el proceso de crear una aplicación con SDL. Es un poco patatera y no tiene demasiadas cosas. Espero que sirva de algo y de pie a seguirla.

SVideo.h

Código (cpp) [Seleccionar] Expandir



/**
SVideo.h
**/

#ifndef __S_VIDEO_H__
#define __S_VIDEO_H__

#define SVIDEO_DEBUG

#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>

#ifdef SVIDEO_DEBUG
#include <iostream>
#endif

#include <vector>
#include <string>

class SVideo
{
public :
SVideo(int width, int height, int depth, bool fullscreen, bool initialize = true);
~SVideo();

// Gestión de fuentes
int CreateFont(std::string font, int size);
static int GetWidth(TTF_Font *font, std::string text);
static int GetHeight(TTF_Font *font, std::string text);
void DrawText(TTF_Font *font, std::string text, SDL_Color color, int x, int y);
TTF_Font *GetFont(unsigned int index);

// Gestión de superficies
int CreateSurface(std::string image);
void DrawSurface(SDL_Surface *surface, int x, int y);
void DrawSurface(SDL_Surface *surface, SDL_Rect rect);
SDL_Surface *GetSurface(unsigned int index);

// Gestión del sistema de video
void FlipScreen();
void Wait(int milliseconds);
void CleanScreen(SDL_Color color);
int Initialize(int width, int height, int depth, bool fullscreen);

bool IsInitialized() const;
SDL_Surface *GetScreen();

private :
SDL_Surface *m_screen;
SDL_Rect m_rectScreen;
bool m_initialized;

// Fuentes
std::vector<TTF_Font *> m_font;

// Superficies
std::vector<SDL_Surface *> m_surface;
};

#endif /* __S_VIDEO_H__ */



SVideo.cpp

Código (cpp) [Seleccionar] Expandir



#include "SVideo.h"

SVideo::SVideo(int width, int height, int depth, bool fullscreen, bool initialize /*= true*/)
: m_screen(NULL)
, m_initialized(false)
{
if ( initialize )
{
if ( Initialize(width, height, depth, fullscreen) < 0 )
{
#ifdef SVIDEO_DEBUG
std::cerr << "SVideo::SVideo() -> SDL Error: " << SDL_GetError() << "." << std::endl;
#endif

return;
}
}
}

SVideo::~SVideo()
{
for ( unsigned int i = 0; i < m_font.size(); i++ )
{
if ( m_font[i] )
{
TTF_CloseFont( m_font[i] );
}
}

for ( unsigned int i = 0; i < m_surface.size(); i++ )
{
if ( m_surface[i] )
{
SDL_FreeSurface( m_surface[i] );
}
}

if ( m_screen )
{
SDL_FreeSurface(m_screen);
}
}

/**
A partir de una cadena que indica el nombre de la fuente
y el tamaño, crea un TTF_Font en la clase SVideo.
Devuelve el índice de la fuente guardada en el vector.
Devuelve -1 si a habido un error.
@font: Cadena de la ruta de la fuente.
@size: Tamaño de la fuente.
**/
int SVideo::CreateFont(std::string font, int size)
{
m_font.push_back(TTF_OpenFont(font.c_str(), size));

unsigned int index = m_font.size() - 1;

if ( m_font[index] == NULL )
{
// No se creó bien, se borra y devuelve error.
#ifdef SVIDEO_DEBUG
std::cerr << "SVideo::CreateFont() -> SDL Error: " << SDL_GetError() << "." << std::endl;
#endif
m_font.erase(m_font.begin() + index);
return -1;
}

// Si se crea bien, se devuelve su índice.
return index;
}

/**
Devuelve el ancho en píxeles de un texto.
@font: Fuente de tipo TTF_Font.
@text: Texto que se quiere medir.
**/
int SVideo::GetWidth(TTF_Font *font, std::string text)
{
if ( font == NULL )
{
return -1;
}

int w, h;
TTF_SizeUTF8(font, text.c_str(), &w, &h);

return w;
}

/**
Devuelve el alto en píxeles de un texto.
Devuelve -1 si hay fallo.
@font: Fuente de tipo TTF_Font.
@text: Texto que se quiere medir.
**/
int SVideo::GetHeight(TTF_Font *font, std::string text)
{
if ( font == NULL )
{
return -1;
}

int w, h;
TTF_SizeUTF8(font, text.c_str(), &w, &h);

return h;
}

/**
Dibuja un texto.
@font: Fuente de tipo TTF_Font.
@text: Texto que se quiere escribir.
@color: Color del texto
@x: Posición horizontal.
@y: Posición vertical.
**/
void SVideo::DrawText(TTF_Font *font, std::string text, SDL_Color color, int x, int y)
{
if ( font == NULL )
{
return;
}

SDL_Surface *textSurface;

textSurface = TTF_RenderText_Blended(font, text.c_str(), color);

SDL_Rect dest;

dest.x = x;
dest.y = y;
dest.h = textSurface->h;
dest.w = textSurface->w;

if (SDL_BlitSurface(textSurface, NULL, m_screen, &dest) < 0 )
{
#ifdef SVIDEO_DEBUG
std::cerr << "SVideo::DrawText() -> SDL Error: " << SDL_GetError() << "." << std::endl;
#endif
return;
}

SDL_FreeSurface(textSurface);
}

/**
Devuelve una fuente guardada en el vector.
@index: Índice de la fuente en el vector.
**/
TTF_Font *SVideo::GetFont(unsigned int index)
{
if ( index < m_font.size() )
{
return m_font[index];
}

return NULL;
}

/**
crea una superficie en el vector de superficies.
Devuelve el índice de la superficie.
@image: Ruta de la imagen.
**/
int SVideo::CreateSurface(std::string image)
{
m_surface.push_back(IMG_Load(image.c_str()));

unsigned int index = m_surface.size() - 1;

if ( m_surface[index] == NULL )
{
// No se creó bien, se borra y devuelve error.
#ifdef SVIDEO_DEBUG
std::cerr << "SVideo::CreateSurface() -> SDL Error: " << SDL_GetError() << "." << std::endl;
#endif
m_surface.erase(m_surface.begin() + index);
return -1;
}

// Si se crea bien, se devuelve su índice.
return index;
}

/**
Dibuja una superficie en la pantalla principal.
@surface: Superficie a dibujar.
@x: Posición horizontal.
@y: Posición vertical.
**/
void SVideo::DrawSurface(SDL_Surface *surface, int x, int y)
{
SDL_Rect _rect = { x, y, surface->w, surface->h };
SDL_BlitSurface(surface, NULL, m_screen, &_rect);
}

/**
Dibuja una superficie en la pantalla principal.
@surface: Superficie a dibujar.
@rect: Rectángulo
**/
void SVideo::DrawSurface(SDL_Surface *surface, SDL_Rect rect)
{
SDL_BlitSurface(surface, NULL, m_screen, &rect);
}

/**
Devuelve una superficie creada.
@index: Índice de la superficie en el vector.
**/
SDL_Surface *SVideo::GetSurface(unsigned int index)
{
if ( index < m_surface.size() )
{
return m_surface[index];
}

return NULL;
}

/**
Muestra el buffer escondido.
**/
void SVideo::FlipScreen()
{
SDL_Flip(m_screen);
}

/**
Hace una pausa.
@milliseconds: Milisegundos de pausa.
**/
void SVideo::Wait(int milliseconds)
{
SDL_Delay(milliseconds);
}

/**
Limpia la pantalla con un color.
@color: Color de borrado.
**/
void SVideo::CleanScreen(SDL_Color color)
{
SDL_FillRect(m_screen, &m_rectScreen, SDL_MapRGB(m_screen->format, color.r, color.g, color.b));
}

/**
Inicia todo el sistema de video.

Devuelve:
< 0 Si hay error.
0 Si ha ido bien.
**/
int SVideo::Initialize(int width, int height, int depth, bool fullscreen)
{
m_initialized = false;

/** Video **/
if ( SDL_Init(SDL_INIT_VIDEO) == -1 )
{
return -1;
}
atexit(SDL_Quit);

if ( fullscreen ) m_screen = SDL_SetVideoMode(width, height, depth, SDL_SWSURFACE | SDL_DOUBLEBUF | SDL_FULLSCREEN);
else m_screen = SDL_SetVideoMode(width, height, depth, SDL_SWSURFACE | SDL_DOUBLEBUF);

if (m_screen == NULL)
{
return -2;
}

m_rectScreen.x = 0;
m_rectScreen.y = 0;
m_rectScreen.w = width;
m_rectScreen.h = height;

/** Textos **/
if (TTF_Init() == -1)
{
return -3;
}
atexit(TTF_Quit);

m_initialized = true;

return 0;
}

/**
Devuelve si el sistema está inicializado.
**/
bool SVideo::IsInitialized() const
{
return ( m_screen != NULL && m_initialized );
}

/**
Devuelve la pantalla principal.
**/
SDL_Surface *SVideo::GetScreen()
{
return m_screen;
}



Por supuesto le falta infinidad de cosas. Sugerencias, etc.

Aplicación con SDL pura.

Código (cpp) [Seleccionar] Expandir



#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>

using namespace std;

int main(int arc, char *argv[])
{
SDL_Event evento;
bool salida = false;
SDL_Rect rectPantalla;
SDL_Surface *pantalla;

SDL_Color _blanco = { 255, 255, 255 };
SDL_Color _negro = { 0, 0, 0 };

if ( SDL_Init(SDL_INIT_VIDEO) == -1 )
{
return -1;
}
atexit(SDL_Quit);

if ((pantalla = SDL_SetVideoMode(600, 200, 16, SDL_SWSURFACE | SDL_DOUBLEBUF)) == NULL)
{
return -1;
}

rectPantalla.x = 0;
rectPantalla.y = 0;
rectPantalla.w = 600;
rectPantalla.h = 200;

if (TTF_Init() == -1)
{
return -1;
}
atexit(TTF_Quit);

TTF_Font *miFuente = TTF_OpenFont("verdana.ttf", 50);
if ( miFuente == NULL )
{
return -1;
}

SDL_Surface *miGrafico = IMG_Load("grafico.png");
if ( miGrafico == NULL )
{
return -1;
}

while ( !salida )
{
while (SDL_PollEvent(&evento))
{
if ( evento.type == SDL_QUIT ) salida = true;
}

int w, h;
TTF_SizeUTF8(miFuente, "Mi Texto.", &w, &h);

SDL_Surface *textoSurface = TTF_RenderText_Blended(miFuente, "Mi Texto.", _blanco);

SDL_Rect rectTexto;

rectTexto.x = 600 / 2 - w / 2;
rectTexto.y = 20;
rectTexto.h = textoSurface->h;
rectTexto.w = textoSurface->w;

SDL_BlitSurface(textoSurface, NULL, pantalla, &rectTexto);
SDL_FreeSurface(textoSurface);

SDL_Rect rectGrafico;
rectGrafico.x = 3;
rectGrafico.y = 3;
rectGrafico.w = miGrafico->w;
rectGrafico.h = miGrafico->h;

SDL_BlitSurface(miGrafico, NULL, pantalla, &rectGrafico);

SDL_Flip(pantalla);
SDL_Delay(30);
}

TTF_CloseFont(miFuente);
SDL_FreeSurface(miGrafico);
SDL_FreeSurface(pantalla);

return EXIT_SUCCESS;




Aplicación con SVideo

Código (cpp) [Seleccionar] Expandir



#include "SVideo.h"

using namespace std;
typedef int FUENTE;
typedef int GRAFICO;

int main(int arc, char *argv[])
{
SDL_Event evento;
bool salida = false;

SDL_Color _blanco = { 255, 255, 255 };
SDL_Color _negro = { 0, 0, 0 };

SVideo *video = new SVideo(600, 200, 16, false);

if ( !video->IsInitialized() )
{
std::cout << "Error iniciando." << std::endl;
return -1;
}

FUENTE miFuente;
if ((miFuente = video->CreateFont("verdana.ttf", 50)) == -1)
{
std::cout << "Error creando fuente." << std::endl;
delete video;
return -1;
}

GRAFICO miGrafico;
if ((miGrafico = video->CreateSurface("grafico.png")) == -1)
{
std::cout << "Error creando gráfico." << std::endl;
delete video;
return -1;
}

while ( !salida )
{
while (SDL_PollEvent(&evento))
{
if ( evento.type == SDL_QUIT ) salida = true;
}

video->DrawText(video->GetFont(miFuente), "Mi Texto.", _blanco, (600 / 2)-(video->GetWidth(video->GetFont(miFuente), "Mi Texto.") / 2), 20);
video->DrawSurface(video->GetSurface(miGrafico), 3, 3);
video->FlipScreen();
video->Wait(30);
}

delete video;

return EXIT_SUCCESS;
}



Me imagino que muchos conocerán SDL. Esa librería para hacer juegos (www.libsdl.org/).

Pues bien, llevo usándola un tiempo y he conseguido hacer algunas cosillas con ella, pero siempre tengo el mismo problema e internet no ha conseguido subsanarlo. El problema es el consumo de la CPU, como bien dice el título.

Dependiendo de la aplicación que esté haciendo, puede llegar a consumir entre 5% y 40% (aunque suele rondar el 30%) de los recursos de la CPU. Según he leído en múltiples foros y blogs, el problema reside en el tiempo de espera que hay que darle entre loop y loop. Hay algunos métodos estándar para hacer una pausa ligera y a la vez reducir considerablemente el consumo, pero por alguna extraña razón, en mis aplicaciones no funcionan esos métodos, o la pausa entre loop y loop es gigante, y por consiguiente el consumo es ínfimo o la pausa es pequeña y por tanto, el consumo es enorme...

Sin embargo, he visto aplicaciones desarrolladas con SDL donde no consumen nada, y las pausas esas anteriormente citadas ni se notan. Por tanto...

¿Qué estoy haciendo mal?

Muchas gracias. Espero haberme explicado bien.

Me gustaría generar números aleatorios. Todos los manuales para crear números aleatorios utilizan la hora y fecha actual como semilla aleatoria. ¿Alguien puede explicarme como funciona esa semilla?¿Son realmente aleatorios los números que se generan a partir de esa semilla?Si no son ¿Se puede hacer de alguna manera para que los numeros generados tengan el 50% de probabilidad (si son dos), (33.3% si son tres) ,etc.?

Si quiero generar números aleatorios entre 0 y 2 ambos inclusive:
Al 0 se le da 33.3% de probabilidad
Al 1 otro 33.3%
Al 2 otro 33.3%

¿Me explico?

Ya está... El servidor FTP (vsftpd) que uso tiene una directiva que hace referencia a los permisos de los archivos que se suben...

local_umask
file_open_mode (aunque esta parece que no funciona....)

Según he leido, los permisos de los archivos es el XOR de ambas directivas

Gracias