[SOLUCIONADO] Llamar metodos de la clase hija al crear objeto de la clase madre

[newb]

Hola,
Tengo una clase ecuacion madre, y otras hijas que serian ecuacion lineal, ecuacion cuadratica, etc...
Lo que ocupo es calcular la imagen de "x" numero...
Eemplo: en f(x)=3x^2+3x+4, si x numero es 3 entonces f(3)=3*3^2+3x3+4...

El asunto es que ocupo el mismo metodo para todas las clases pero ocupo saber que tipo de ecuacion es para poder hacer el calculo...
Lo que hice para saber que ecuacion es fue esto:

Código:

//Esto en la clase madre
virtual string queSoy()const=0{}

//Esto en las clase hija:
virtual string queSoy()const{
		return typeid(*this).name();
	}

Asi me devuelve un string diciendo por ejemplo "class EcuacionCuadratica"

Pero el problema comienza aqui, este seria el metodo:

Código:

class Calculadora{
double calculaImagen(double x, Ecuacion *e){
		if(e->queSoy()=="class EcuacionLineal"){
			
			return e->getA()*x+e->getB();
		}
		if(e->queSoy()=="class EcuacionCuadratica"){
			return e->getA()*(x*x)+e->getB()*x+e->getC();}
   }
};

En la todas puedo llamar a getA y getB ya que es de la clase madre...
Pero al realizar el calculo de cuadratica no puedo llamar a getC que seria un atributo de la clase EcuacionCuadratica (clase hija)


Asi es la clase madre:

Código:

#include<string>
using namespace std;
class Ecuacion
{
protected:
	float a;
	float b;
public:

	Ecuacion(void)
	{ 
	    a = 0;
		b=0;
	}

	Ecuacion(float a1, float b1){
		a = a1;
		b = b1;
	}

	~Ecuacion(void){}

	void setA(float X1){ a = X1;}
	float getA(){return a;}

	void setB(float iy){ b = iy;}
	float getB(){return b;}
	
	virtual string queSoy()const=0{}

};

La clase Cuadratica:

Código:

#include"Ecuacion.h"

class EcuacionCuadratica: public  Ecuacion
{
private:
	float c;

public:

	EcuacionCuadratica(float X2,float x,float x1):Ecuacion(x,x1){
		c=X2;
	}

	~EcuacionCuadratica(void){
	}

	float getC(){
		return c;
	}
	void setC(float abc){
		c=abc;
	}

	virtual string queSoy()const{
		return typeid(*this).name();
	}

	
};

[eferion]

No estás haciendo las cosas bien.

La idea de tirar de herencia y polimorfismo es que se puedan usar diferentes tipos de objetos sin importar su origen concreto.

En tu caso, lo lógico sería que la función "ecuacion" tuviese un método virtual llamado "calcular", que devolviese un double y no recibiese parámetros... en la clase "ecuacion" este método debería ser virtual puro, sin embargo, las diferentes ecuaciones que heredasen de "ecuacion" deben implementar este método para realizar cada una el cálculo que le corresponda:

Código C++:

class Ecuacion
{
  public:
 
    virtual double calcular( double x ) const =0;
};
 
class EcuacionLineal : public Ecuacion
{
  public:
 
    virtual double calcular( double x) const override
    {
      return getA()*x+getB();
    }
};
 
int main( )
{
  Ecuacion* ecuacion = new EcuacionLineal( );
  ecuacion->setA( 10.0 );
  ecuacion->setB( 12.5 );
 
  std::cout<< ecuacion->calcular( 3.5 );
}
 

Si en un diseño se da el caso de que necesitas conocer el tipo concreto de clase hija en la clase padre, entonces es que estás haciendo mal las cosas.

PD.: "override" es una palabra clave nueva en el estándar C++11 si tu compilador no la soporta puedes quitarla sin ningún problema... su cometido es dar un error de compilación si la función en cuestión no sobreescribe la función de una clase padre.

Un saludo.