SOLUCIONADO. fui muy boludo y en el main no usaba la clase heredada JAJAJAJ. el cafe no basto para esa noche
Hola, como andan ? espero que bien :p

Verán, después de mucho regreso con C/C++ extrañando sus punteros jaja
Tengo este problema que ya me quemo las pestañas y no veo lo que esta mal.

Tengo mi clase base Escenario.h con su método virtual isEndEscena el cual luego reescribo en su clase derivada HelloEscena y por ultimo, almaceno HelloEscena en un vector de vector<CEscenario*> de la clase Cordinador

El problema esta, en que cuando, tengo llamar a isEndEscena, me llama a la de la clase base y no su deribada.

Dejo el código:

Escenario

//head
#pragma once
 
#include <SFML\Graphics.hpp>
#include "Sprite.h"
 
class CEscenario
{
public:
	void addSprite(CSprite*);
	void clearSprites();
	void deleteSprite(const char* key);
 
	virtual bool isEndEscena(sf::Event);
 
	void updateSprites(sf::Event);
	void drawSprites();
 
	char* getKey();
private:
	std::vector<CSprite*> sprites;
	char* key;
};
 
//cpp
 
#include "Escenario.h"
 
bool CEscenario::isEndEscena(sf::Event)
{ 
	return true; 
}
 
char* CEscenario::getKey()
{
	return this->key;
}
 
void CEscenario::updateSprites(sf::Event evento)
{
	int i = 0;
	for (int i = 0; i < int(this->sprites.size()); i++)
	{
		this->sprites[i]->update(evento);
	}
}
 
void CEscenario::addSprite(CSprite* newSprite)
{
	this->sprites.push_back(newSprite);
}
 
void CEscenario::deleteSprite(const char* key)
{
	int i = 0;
	for (int i = 0; i < int(this->sprites.size()); i++)
	{
		if (std::strcmp(this->sprites[i]->getKey(), key) == 0)
		{
			this->sprites.erase(this->sprites.begin() + i);
			return;
		}
	}
}
 
void CEscenario::clearSprites()
{
	this->sprites.clear();
}
 
void CEscenario::drawSprites()
{
	int i = 0;
	for (int i = 0; i < int(this->sprites.size()); i++)
	{
		this->sprites[i]->draw();
	}
}
 

HelloEscena

//head
#pragma once
 
#include <SFML\Graphics.hpp>
#include "Escenario.h"
 
class CHelloEscena : CEscenario
{
public:
	bool isEndEscena(sf::Event);
};
 
 
//cpp
#include "HelloEscena.h"
 
bool CHelloEscena::isEndEscena(sf::Event evento)
{
	int a = 0;
	return false;
}
 

Cordinador

 
//head
#pragma once
 
#include <vector>
#include "Escenario.h"
 
class CCordinador
{
public:
	void addEscenario(CEscenario*);
	void clearEscenarios();
	void deleteEscenario(const char *key);
 
	CEscenario* getEscenario();	
 
	//void nextEscenario();
	void(*nextEscenario)();
private:
	std::vector<CEscenario* > escenarios;
	CEscenario *escenarioActual;	
};
 
//cpp
#include <cstring>
 
#include "Cordinador.h"
 
CEscenario* CCordinador::getEscenario()
{
	return escenarioActual;
}
 
void CCordinador::addEscenario(CEscenario* newEscenario)
{
	this->escenarios.push_back(newEscenario);
	this->escenarioActual = newEscenario;
}
 
void CCordinador::deleteEscenario(const char* key)
{
	int i = 0;
	for (int i = 0; i < int(this->escenarios.size()); i++)
	{
		if (std::strcmp(this->escenarios[i]->getKey(), key) == 0)
		{
			this->escenarios.erase(this->escenarios.begin() + i);
			return;
		}
	}
}
 
void CCordinador::clearEscenarios()
{
	this->escenarios.clear();
}
 

Donde uso Cordinador....

//head
#pragma once
 
#include "Cordinador.h"
 
class CApp
{
public:
	CApp(sf::RenderWindow *widows);
 
	/*Parte del siclo de vida del juego*/
	void loopGame();
	void catchEvent();
	void clearScreen();
 
	void update(sf::Event);
	void draw();
	void displayWindows();
 
 
	/*Armado del juego*/	
	static sf::RenderWindow *window;
	void setCordinador(CCordinador *c) { this->cordinador = c; }
private:	
	CCordinador *cordinador;
};
 
//cpp
//solo puse donde lo uso por que es mucho si no xD
void CApp::update(sf::Event evento)
{
	if (evento.type == sf::Event::Closed)
	{
		this->window->close();
		return;
	}
 
	if (this->cordinador->getEscenario()->isEndEscena(evento))
	{
//regresa siempre true de la clase base, y no false de la clase derivada
 
		//Un momento del juego termino y pasa al siguiente
		//ej: menues, niveles, etc		
		this->cordinador->nextEscenario();
	}
 
	this->cordinador->getEscenario()->updateSprites(evento);
}
 

y el main infaltable :p

#include <SFML/Graphics.hpp>
 
#include "App.h"
 
#include "HelloSprite.h"
#include "HelloEscena.h"
 
int main()
{
	// Create the main window
	sf::RenderWindow win(sf::VideoMode(800, 600, 32), "Hello World - SFML");
 
	//Definimos los sprites:
	CHello sprite;
 
	//Definimos los escenario:
	//imprimira en pantalla en orden de pila de como se le fue agregando al escenario
	CEscenario test;
	test.addSprite(&sprite);
 
	//Cargamos los Escenarios al Cordinador
	CCordinador cordinador;
	cordinador.addEscenario(&test);
 
	//Le damos al App el cordinador
	CApp app(&win);
	app.setCordinador(&cordinador);
 
	//Empezamos el juego
	app.loopGame();
 
	return 0;
}
 

Desde ya muchas gracias por leer.

te puedo ayudar con la lógica, y resolución de código ya echo, pero no esperes que te lo de servido ya para copiar y pegar, no se hacen tareas...
vos te referís que si tengo la matriz:

el programa calcule el factorial de 1, 5 y 9 ?
si es eso, fíjate que todos esos elementos tienen en común que están ubicados en la posición de manera tal que su posición en fila/columna es igual, por ejemplo, el elemento 1 esta en Matriz [1] [1] , el elemento 5 en Matriz [2] [2] y elemento 9 en matriz [3] [3]

casi pero no, el FILE *f es local a la función conflictiva, en todo caso deberia ser =NULL el puntero a que manda al compo bufer de la función, no se molesten mas en seguir contestando, se lo agradezco de verdad la ayuda que dan, pero no les quiero sacar mas el tiempo en algo que ya solucione :$

el viernes les subo el soft completo que no es mas que uno para practicar menues, malloc, estructuras y ABM de un archivo, para que de esa manera si alguien en algún futuro busca códigos de ejemplo de eso lo encuentre :P

queres un source ? date MAÑA , yo soy un simple y bobo novato que solo conoce c++ y ASM (ASM bastante bien)  que hace preguntas estúpidas ,y aun así me puedo arreglar para darme maña y mostrarte ,con un básico de ABM que conozco, unas lineas de código que buscan archivos en tu pc,

 
void buscar_archivo(const char* ruta);
 
int main ()
{
   char a [250];
   cout<<"Indicar ruta y Archivo Deseado"<<endl;
   cin.getline(a,250);
   buscar_archivo(a);  
 
   return 0;
}
 
void buscar_archivo(const char* ruta)
{
  FILE *f;
  f=fopen(ruta,"rb");
  if(f==NULL)
  {
       cout<<"Archivo inexistente"<<endl;
   }
  else  cout<<"archivo encontrado";
}
fclose(f);
 

y eso se puede mejorar millones de veces mas dándote MAÑA y usando cosas a tu dispocision como llamadas al system(); para que te de una mano con sus comandos de la consola del SO.
segundo, yo estudio en la UTN FRGP de Arg. y no te enseñan esas cosas, te enseñan lo básico de lenguajes para que puedas agarrar un libro de un lenguaje en especial y entenderlo con noción. y como dijo pepe (alla él el que lo conozca) hay dos formas de lograr ser programador, conociendo lenguaje, o sabiendo lenguaje...

y por ultimo y como reflexión personal, acordare que del otro lado de tu lindo monitor hay personas, y si a las personas se las trata bien, te responden bien, tal vez no allá sido tu intención pero tus comentarios sonaron muy prepotentes y despectivos hacia los demás...

exacto ! , por eso decía que la función era lo de menos, por que no quería que se rompan el coco entendiéndola ajaj
el aviso lo genera por que recibe una variable puntero con basura y al detectar que realizan operaciones sobre ella salta el warning, pero como me es indistinto por que la sobre escribe usando malloc, ese aviso esta de mas y era molesto jaaj

gracias, era eso :D, lo de la función es lo de menos ,el aviso era por que mandaba un parámetro sin inicializar , pero no hacia falta por que lo sobrescribía mas tarde con malloc... muchas gracias :D

solo si alguien le sirve en algún futuro... le paso la función, crea un vector que contiene toda la información de un archivo usando malloc, solo le indicas la ruta del archivo, un puntero a la estructura a usar, y el tamaño de la estruc (sizeof)

 
void* Carga_enMalloc(const char* ruta, void* registro, size_t tam)
{
    int cant;
    FILE *f;
    f=fopen(ruta,"rb");
    error_archivo("\t ERROR: no se pudo abrir el archivo - T x 69", &f);
 
    cant=Cant_registros(ruta, tam);
 
    registro = malloc(cant*tam);
 
    fread(registro, tam, cant, f);
 
    fclose(f);
 
    return registro;
}
 

lo del aviso, se por que se genera, y que el return de la funcion esta de mas, pero cuando ya tenia el programa avansado al notarlo, no tuve ganas de cambiarlo (soy vago -_-)

si, por que te ayudara mas a comprender los programas basados en objetos, si vas a aprender c++ , y ya sabes c, tirate de lleno con las clases, strucs y sobrecargas.

hola como andan? espero que bien, yo de nuevo por acá jeje, tengo una duda con la instancia de compilación que realiza el IDE Code::Block... es posible evitar que me marque algunos avisos ? por que tengo una función que uso mucho pero por no ser muy linda a la vista del Sr.GCC siempre me tira avisos sobre la misma :P y... ya es molesto >.<

si alguien conoce un método para evitar esos avisos le agradeceré mucho :D

desde ya muchas gracias. y buena suerte.

con zig zag se refiere a que lee en diagonal, de una manera mejor escrita (si pretendes que hagamos la tarea al menos explicarla bien)

y la idea de que tengas ese tipo de ejercicio es para que te rompas la cabeza pensando, usando lógica, para que te abstraigas del código y pienses como programador, no en que código usar.

lo mas sencillo para empezar en c/c++ con sistema de archivos es:
fopen, fclose, fread, fwrite, fseek y fteel.

#include <cstdio>
 
FILE *p //siempre es un puntero FILE
 
//p = fopen (ruta,modo)
/* la ruta del archivo, ej mis documentos/archivo.dat
el modo, es el metodo con el que lo abres, si para leer ("rb"), agregar ("ab"), escribir("wb")*/
 
p= fopen (archivo.dat, "wb" ) //creas archivo.dat en la misma carpeta que el .exe y en p es ahora como si fuera "el archivo.dat"